projects/linux·blob v6.15 · refs

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