projects/linux·blob v7.0 · refs

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