projects/linux·blob 2c455ddc · refs

425 lines · 9.3 KiB

1// SPDX-License-Identifier: GPL-2.0-only
2#include <linux/codetag.h>
3#include <linux/idr.h>
4#include <linux/kallsyms.h>
5#include <linux/module.h>
6#include <linux/seq_buf.h>
7#include <linux/slab.h>
8#include <linux/vmalloc.h>
9
10struct codetag_type {
11 struct list_head link;
12 unsigned int count;
13 struct idr mod_idr;
14 /*
15 * protects mod_idr, next_mod_seq,
16 * iter->mod_seq and cmod->mod_seq
17 */
18 struct rw_semaphore mod_lock;
19 struct codetag_type_desc desc;
20 /* generates unique sequence number for module load */
21 unsigned long next_mod_seq;
22 /* bumped on every module load and unload */
23 unsigned long content_id;
24};
25
26struct codetag_range {
27 struct codetag *start;
28 struct codetag *stop;
29};
30
31struct codetag_module {
32 struct module *mod;
33 struct codetag_range range;
34 unsigned long mod_seq;
35};
36
37static DEFINE_MUTEX(codetag_lock);
38static LIST_HEAD(codetag_types);
39
40void codetag_lock_module_list(struct codetag_type *cttype)
41{
42 down_read(&cttype->mod_lock);
43}
44
45bool codetag_trylock_module_list(struct codetag_type *cttype)
46{
47 return down_read_trylock(&cttype->mod_lock) != 0;
48}
49
50void codetag_unlock_module_list(struct codetag_type *cttype)
51{
52 up_read(&cttype->mod_lock);
53}
54
55unsigned long codetag_get_content_id(struct codetag_type *cttype)
56{
57 lockdep_assert_held(&cttype->mod_lock);
58
59 return cttype->content_id;
60}
61
62unsigned int codetag_get_count(struct codetag_type *cttype)
63{
64 lockdep_assert_held(&cttype->mod_lock);
65
66 return cttype->count;
67}
68
69struct codetag_iterator codetag_get_ct_iter(struct codetag_type *cttype)
70{
71 struct codetag_iterator iter = {
72 .cttype = cttype,
73 .cmod = NULL,
74 .mod_id = 0,
75 .ct = NULL,
76 .mod_seq = 0,
77 };
78
79 return iter;
80}
81
82static inline struct codetag *get_first_module_ct(struct codetag_module *cmod)
83{
84 return cmod->range.start < cmod->range.stop ? cmod->range.start : NULL;
85}
86
87static inline
88struct codetag *get_next_module_ct(struct codetag_iterator *iter)
89{
90 struct codetag *res = (struct codetag *)
91 ((char *)iter->ct + iter->cttype->desc.tag_size);
92
93 return res < iter->cmod->range.stop ? res : NULL;
94}
95
96struct codetag *codetag_next_ct(struct codetag_iterator *iter)
97{
98 struct codetag_type *cttype = iter->cttype;
99 struct codetag_module *cmod;
100 struct codetag *ct;
101
102 lockdep_assert_held(&cttype->mod_lock);
103
104 if (unlikely(idr_is_empty(&cttype->mod_idr)))
105 return NULL;
106
107 ct = NULL;
108 while (true) {
109 cmod = idr_find(&cttype->mod_idr, iter->mod_id);
110
111 /* If module was removed move to the next one */
112 if (!cmod)
113 cmod = idr_get_next_ul(&cttype->mod_idr,
114 &iter->mod_id);
115
116 /* Exit if no more modules */
117 if (!cmod)
118 break;
119
120 if (!iter->cmod || iter->mod_seq != cmod->mod_seq) {
121 iter->cmod = cmod;
122 iter->mod_seq = cmod->mod_seq;
123 ct = get_first_module_ct(cmod);
124 } else {
125 ct = get_next_module_ct(iter);
126 }
127
128 if (ct)
129 break;
130
131 iter->mod_id++;
132 }
133
134 iter->ct = ct;
135 return ct;
136}
137
138void codetag_to_text(struct seq_buf *out, struct codetag *ct)
139{
140 if (ct->modname)
141 seq_buf_printf(out, "%s:%u [%s] func:%s",
142 ct->filename, ct->lineno,
143 ct->modname, ct->function);
144 else
145 seq_buf_printf(out, "%s:%u func:%s",
146 ct->filename, ct->lineno, ct->function);
147}
148
149static inline size_t range_size(const struct codetag_type *cttype,
150 const struct codetag_range *range)
151{
152 return ((char *)range->stop - (char *)range->start) /
153 cttype->desc.tag_size;
154}
155
156static void *get_symbol(struct module *mod, const char *prefix, const char *name)
157{
158 DECLARE_SEQ_BUF(sb, KSYM_NAME_LEN);
159 const char *buf;
160 void *ret;
161
162 seq_buf_printf(&sb, "%s%s", prefix, name);
163 if (seq_buf_has_overflowed(&sb))
164 return NULL;
165
166 buf = seq_buf_str(&sb);
167 preempt_disable();
168 ret = mod ?
169 (void *)find_kallsyms_symbol_value(mod, buf) :
170 (void *)kallsyms_lookup_name(buf);
171 preempt_enable();
172
173 return ret;
174}
175
176static struct codetag_range get_section_range(struct module *mod,
177 const char *section)
178{
179 return (struct codetag_range) {
180 get_symbol(mod, CODETAG_SECTION_START_PREFIX, section),
181 get_symbol(mod, CODETAG_SECTION_STOP_PREFIX, section),
182 };
183}
184
185static const char *get_mod_name(__maybe_unused struct module *mod)
186{
187#ifdef CONFIG_MODULES
188 if (mod)
189 return mod->name;
190#endif
191 return "(built-in)";
192}
193
194static int codetag_module_init(struct codetag_type *cttype, struct module *mod)
195{
196 struct codetag_range range;
197 struct codetag_module *cmod;
198 int mod_id;
199 int err;
200
201 range = get_section_range(mod, cttype->desc.section);
202 if (!range.start || !range.stop) {
203 pr_warn("Failed to load code tags of type %s from the module %s\n",
204 cttype->desc.section, get_mod_name(mod));
205 return -EINVAL;
206 }
207
208 /* Ignore empty ranges */
209 if (range.start == range.stop)
210 return 0;
211
212 BUG_ON(range.start > range.stop);
213
214 cmod = kmalloc_obj(*cmod);
215 if (unlikely(!cmod))
216 return -ENOMEM;
217
218 cmod->mod = mod;
219 cmod->range = range;
220
221 down_write(&cttype->mod_lock);
222 cmod->mod_seq = ++cttype->next_mod_seq;
223 ++cttype->content_id;
224 mod_id = idr_alloc(&cttype->mod_idr, cmod, 0, 0, GFP_KERNEL);
225 if (mod_id >= 0) {
226 if (cttype->desc.module_load) {
227 err = cttype->desc.module_load(mod, range.start, range.stop);
228 if (!err)
229 cttype->count += range_size(cttype, &range);
230 else
231 idr_remove(&cttype->mod_idr, mod_id);
232 } else {
233 cttype->count += range_size(cttype, &range);
234 err = 0;
235 }
236 } else {
237 err = mod_id;
238 }
239 up_write(&cttype->mod_lock);
240
241 if (err < 0) {
242 kfree(cmod);
243 return err;
244 }
245
246 return 0;
247}
248
249#ifdef CONFIG_MODULES
250#define CODETAG_SECTION_PREFIX ".codetag."
251
252/* Some codetag types need a separate module section */
253bool codetag_needs_module_section(struct module *mod, const char *name,
254 unsigned long size)
255{
256 const char *type_name;
257 struct codetag_type *cttype;
258 bool ret = false;
259
260 if (strncmp(name, CODETAG_SECTION_PREFIX, strlen(CODETAG_SECTION_PREFIX)))
261 return false;
262
263 type_name = name + strlen(CODETAG_SECTION_PREFIX);
264 mutex_lock(&codetag_lock);
265 list_for_each_entry(cttype, &codetag_types, link) {
266 if (strcmp(type_name, cttype->desc.section) == 0) {
267 if (!cttype->desc.needs_section_mem)
268 break;
269
270 down_write(&cttype->mod_lock);
271 ret = cttype->desc.needs_section_mem(mod, size);
272 up_write(&cttype->mod_lock);
273 break;
274 }
275 }
276 mutex_unlock(&codetag_lock);
277
278 return ret;
279}
280
281void *codetag_alloc_module_section(struct module *mod, const char *name,
282 unsigned long size, unsigned int prepend,
283 unsigned long align)
284{
285 const char *type_name = name + strlen(CODETAG_SECTION_PREFIX);
286 struct codetag_type *cttype;
287 void *ret = ERR_PTR(-EINVAL);
288
289 mutex_lock(&codetag_lock);
290 list_for_each_entry(cttype, &codetag_types, link) {
291 if (strcmp(type_name, cttype->desc.section) == 0) {
292 if (WARN_ON(!cttype->desc.alloc_section_mem))
293 break;
294
295 down_write(&cttype->mod_lock);
296 ret = cttype->desc.alloc_section_mem(mod, size, prepend, align);
297 up_write(&cttype->mod_lock);
298 break;
299 }
300 }
301 mutex_unlock(&codetag_lock);
302
303 return ret;
304}
305
306void codetag_free_module_sections(struct module *mod)
307{
308 struct codetag_type *cttype;
309
310 mutex_lock(&codetag_lock);
311 list_for_each_entry(cttype, &codetag_types, link) {
312 if (!cttype->desc.free_section_mem)
313 continue;
314
315 down_write(&cttype->mod_lock);
316 cttype->desc.free_section_mem(mod, false);
317 up_write(&cttype->mod_lock);
318 }
319 mutex_unlock(&codetag_lock);
320}
321
322void codetag_module_replaced(struct module *mod, struct module *new_mod)
323{
324 struct codetag_type *cttype;
325
326 mutex_lock(&codetag_lock);
327 list_for_each_entry(cttype, &codetag_types, link) {
328 if (!cttype->desc.module_replaced)
329 continue;
330
331 down_write(&cttype->mod_lock);
332 cttype->desc.module_replaced(mod, new_mod);
333 up_write(&cttype->mod_lock);
334 }
335 mutex_unlock(&codetag_lock);
336}
337
338int codetag_load_module(struct module *mod)
339{
340 struct codetag_type *cttype;
341 int ret = 0;
342
343 if (!mod)
344 return 0;
345
346 mutex_lock(&codetag_lock);
347 list_for_each_entry(cttype, &codetag_types, link) {
348 ret = codetag_module_init(cttype, mod);
349 if (ret)
350 break;
351 }
352 mutex_unlock(&codetag_lock);
353
354 return ret;
355}
356
357void codetag_unload_module(struct module *mod)
358{
359 struct codetag_type *cttype;
360
361 if (!mod)
362 return;
363
364 /* await any module's kfree_rcu() operations to complete */
365 kvfree_rcu_barrier();
366
367 mutex_lock(&codetag_lock);
368 list_for_each_entry(cttype, &codetag_types, link) {
369 struct codetag_module *found = NULL;
370 struct codetag_module *cmod;
371 unsigned long mod_id, tmp;
372
373 down_write(&cttype->mod_lock);
374 idr_for_each_entry_ul(&cttype->mod_idr, cmod, tmp, mod_id) {
375 if (cmod->mod && cmod->mod == mod) {
376 found = cmod;
377 break;
378 }
379 }
380 if (found) {
381 if (cttype->desc.module_unload)
382 cttype->desc.module_unload(cmod->mod,
383 cmod->range.start, cmod->range.stop);
384
385 cttype->count -= range_size(cttype, &cmod->range);
386 idr_remove(&cttype->mod_idr, mod_id);
387 kfree(cmod);
388 ++cttype->content_id;
389 }
390 up_write(&cttype->mod_lock);
391 if (found && cttype->desc.free_section_mem)
392 cttype->desc.free_section_mem(mod, true);
393 }
394 mutex_unlock(&codetag_lock);
395}
396#endif /* CONFIG_MODULES */
397
398struct codetag_type *
399codetag_register_type(const struct codetag_type_desc *desc)
400{
401 struct codetag_type *cttype;
402 int err;
403
404 BUG_ON(desc->tag_size <= 0);
405
406 cttype = kzalloc_obj(*cttype);
407 if (unlikely(!cttype))
408 return ERR_PTR(-ENOMEM);
409
410 cttype->desc = *desc;
411 idr_init(&cttype->mod_idr);
412 init_rwsem(&cttype->mod_lock);
413
414 err = codetag_module_init(cttype, NULL);
415 if (unlikely(err)) {
416 kfree(cttype);
417 return ERR_PTR(err);
418 }
419
420 mutex_lock(&codetag_lock);
421 list_add_tail(&cttype->link, &codetag_types);
422 mutex_unlock(&codetag_lock);
423
424 return cttype;
425}