projects/linux·blob v6.17 · refs

440 lines · 9.8 KiB

1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Module sysfs support
4 *
5 * Copyright (C) 2008 Rusty Russell
6 */
7
8#include <linux/module.h>
9#include <linux/kernel.h>
10#include <linux/fs.h>
11#include <linux/sysfs.h>
12#include <linux/slab.h>
13#include <linux/kallsyms.h>
14#include <linux/mutex.h>
15#include "internal.h"
16
17/*
18 * /sys/module/foo/sections stuff
19 * J. Corbet <[email protected]>
20 */
21#ifdef CONFIG_KALLSYMS
22struct module_sect_attrs {
23 struct attribute_group grp;
24 struct bin_attribute attrs[];
25};
26
27#define MODULE_SECT_READ_SIZE (3 /* "0x", "\n" */ + (BITS_PER_LONG / 4))
28static ssize_t module_sect_read(struct file *file, struct kobject *kobj,
29 const struct bin_attribute *battr,
30 char *buf, loff_t pos, size_t count)
31{
32 char bounce[MODULE_SECT_READ_SIZE + 1];
33 size_t wrote;
34
35 if (pos != 0)
36 return -EINVAL;
37
38 /*
39 * Since we're a binary read handler, we must account for the
40 * trailing NUL byte that sprintf will write: if "buf" is
41 * too small to hold the NUL, or the NUL is exactly the last
42 * byte, the read will look like it got truncated by one byte.
43 * Since there is no way to ask sprintf nicely to not write
44 * the NUL, we have to use a bounce buffer.
45 */
46 wrote = scnprintf(bounce, sizeof(bounce), "0x%px\n",
47 kallsyms_show_value(file->f_cred)
48 ? battr->private : NULL);
49 count = min(count, wrote);
50 memcpy(buf, bounce, count);
51
52 return count;
53}
54
55static void free_sect_attrs(struct module_sect_attrs *sect_attrs)
56{
57 const struct bin_attribute *const *bin_attr;
58
59 for (bin_attr = sect_attrs->grp.bin_attrs; *bin_attr; bin_attr++)
60 kfree((*bin_attr)->attr.name);
61 kfree(sect_attrs->grp.bin_attrs);
62 kfree(sect_attrs);
63}
64
65static int add_sect_attrs(struct module *mod, const struct load_info *info)
66{
67 struct module_sect_attrs *sect_attrs;
68 const struct bin_attribute **gattr;
69 struct bin_attribute *sattr;
70 unsigned int nloaded = 0, i;
71 int ret;
72
73 /* Count loaded sections and allocate structures */
74 for (i = 0; i < info->hdr->e_shnum; i++)
75 if (!sect_empty(&info->sechdrs[i]))
76 nloaded++;
77 sect_attrs = kzalloc(struct_size(sect_attrs, attrs, nloaded), GFP_KERNEL);
78 if (!sect_attrs)
79 return -ENOMEM;
80
81 gattr = kcalloc(nloaded + 1, sizeof(*gattr), GFP_KERNEL);
82 if (!gattr) {
83 kfree(sect_attrs);
84 return -ENOMEM;
85 }
86
87 /* Setup section attributes. */
88 sect_attrs->grp.name = "sections";
89 sect_attrs->grp.bin_attrs = gattr;
90
91 sattr = &sect_attrs->attrs[0];
92 for (i = 0; i < info->hdr->e_shnum; i++) {
93 Elf_Shdr *sec = &info->sechdrs[i];
94
95 if (sect_empty(sec))
96 continue;
97 sysfs_bin_attr_init(sattr);
98 sattr->attr.name =
99 kstrdup(info->secstrings + sec->sh_name, GFP_KERNEL);
100 if (!sattr->attr.name) {
101 ret = -ENOMEM;
102 goto out;
103 }
104 sattr->read = module_sect_read;
105 sattr->private = (void *)sec->sh_addr;
106 sattr->size = MODULE_SECT_READ_SIZE;
107 sattr->attr.mode = 0400;
108 *(gattr++) = sattr++;
109 }
110
111 ret = sysfs_create_group(&mod->mkobj.kobj, &sect_attrs->grp);
112 if (ret)
113 goto out;
114
115 mod->sect_attrs = sect_attrs;
116 return 0;
117out:
118 free_sect_attrs(sect_attrs);
119 return ret;
120}
121
122static void remove_sect_attrs(struct module *mod)
123{
124 if (mod->sect_attrs) {
125 sysfs_remove_group(&mod->mkobj.kobj,
126 &mod->sect_attrs->grp);
127 /*
128 * We are positive that no one is using any sect attrs
129 * at this point. Deallocate immediately.
130 */
131 free_sect_attrs(mod->sect_attrs);
132 mod->sect_attrs = NULL;
133 }
134}
135
136/*
137 * /sys/module/foo/notes/.section.name gives contents of SHT_NOTE sections.
138 */
139
140struct module_notes_attrs {
141 struct attribute_group grp;
142 struct bin_attribute attrs[];
143};
144
145static void free_notes_attrs(struct module_notes_attrs *notes_attrs)
146{
147 kfree(notes_attrs->grp.bin_attrs);
148 kfree(notes_attrs);
149}
150
151static int add_notes_attrs(struct module *mod, const struct load_info *info)
152{
153 unsigned int notes, loaded, i;
154 struct module_notes_attrs *notes_attrs;
155 const struct bin_attribute **gattr;
156 struct bin_attribute *nattr;
157 int ret;
158
159 /* Count notes sections and allocate structures. */
160 notes = 0;
161 for (i = 0; i < info->hdr->e_shnum; i++)
162 if (!sect_empty(&info->sechdrs[i]) &&
163 info->sechdrs[i].sh_type == SHT_NOTE)
164 ++notes;
165
166 if (notes == 0)
167 return 0;
168
169 notes_attrs = kzalloc(struct_size(notes_attrs, attrs, notes),
170 GFP_KERNEL);
171 if (!notes_attrs)
172 return -ENOMEM;
173
174 gattr = kcalloc(notes + 1, sizeof(*gattr), GFP_KERNEL);
175 if (!gattr) {
176 kfree(notes_attrs);
177 return -ENOMEM;
178 }
179
180 notes_attrs->grp.name = "notes";
181 notes_attrs->grp.bin_attrs = gattr;
182
183 nattr = &notes_attrs->attrs[0];
184 for (loaded = i = 0; i < info->hdr->e_shnum; ++i) {
185 if (sect_empty(&info->sechdrs[i]))
186 continue;
187 if (info->sechdrs[i].sh_type == SHT_NOTE) {
188 sysfs_bin_attr_init(nattr);
189 nattr->attr.name = mod->sect_attrs->attrs[loaded].attr.name;
190 nattr->attr.mode = 0444;
191 nattr->size = info->sechdrs[i].sh_size;
192 nattr->private = (void *)info->sechdrs[i].sh_addr;
193 nattr->read = sysfs_bin_attr_simple_read;
194 *(gattr++) = nattr++;
195 }
196 ++loaded;
197 }
198
199 ret = sysfs_create_group(&mod->mkobj.kobj, &notes_attrs->grp);
200 if (ret)
201 goto out;
202
203 mod->notes_attrs = notes_attrs;
204 return 0;
205
206out:
207 free_notes_attrs(notes_attrs);
208 return ret;
209}
210
211static void remove_notes_attrs(struct module *mod)
212{
213 if (mod->notes_attrs) {
214 sysfs_remove_group(&mod->mkobj.kobj,
215 &mod->notes_attrs->grp);
216 /*
217 * We are positive that no one is using any notes attrs
218 * at this point. Deallocate immediately.
219 */
220 free_notes_attrs(mod->notes_attrs);
221 mod->notes_attrs = NULL;
222 }
223}
224
225#else /* !CONFIG_KALLSYMS */
226static inline int add_sect_attrs(struct module *mod, const struct load_info *info)
227{
228 return 0;
229}
230static inline void remove_sect_attrs(struct module *mod) { }
231static inline int add_notes_attrs(struct module *mod, const struct load_info *info)
232{
233 return 0;
234}
235static inline void remove_notes_attrs(struct module *mod) { }
236#endif /* CONFIG_KALLSYMS */
237
238static void del_usage_links(struct module *mod)
239{
240#ifdef CONFIG_MODULE_UNLOAD
241 struct module_use *use;
242
243 mutex_lock(&module_mutex);
244 list_for_each_entry(use, &mod->target_list, target_list)
245 sysfs_remove_link(use->target->holders_dir, mod->name);
246 mutex_unlock(&module_mutex);
247#endif
248}
249
250static int add_usage_links(struct module *mod)
251{
252 int ret = 0;
253#ifdef CONFIG_MODULE_UNLOAD
254 struct module_use *use;
255
256 mutex_lock(&module_mutex);
257 list_for_each_entry(use, &mod->target_list, target_list) {
258 ret = sysfs_create_link(use->target->holders_dir,
259 &mod->mkobj.kobj, mod->name);
260 if (ret)
261 break;
262 }
263 mutex_unlock(&module_mutex);
264 if (ret)
265 del_usage_links(mod);
266#endif
267 return ret;
268}
269
270static void module_remove_modinfo_attrs(struct module *mod, int end)
271{
272 const struct module_attribute *attr;
273 int i;
274
275 for (i = 0; (attr = &mod->modinfo_attrs[i]); i++) {
276 if (end >= 0 && i > end)
277 break;
278 /* pick a field to test for end of list */
279 if (!attr->attr.name)
280 break;
281 sysfs_remove_file(&mod->mkobj.kobj, &attr->attr);
282 if (attr->free)
283 attr->free(mod);
284 }
285 kfree(mod->modinfo_attrs);
286}
287
288static int module_add_modinfo_attrs(struct module *mod)
289{
290 const struct module_attribute *attr;
291 struct module_attribute *temp_attr;
292 int error = 0;
293 int i;
294
295 mod->modinfo_attrs = kzalloc((sizeof(struct module_attribute) *
296 (modinfo_attrs_count + 1)),
297 GFP_KERNEL);
298 if (!mod->modinfo_attrs)
299 return -ENOMEM;
300
301 temp_attr = mod->modinfo_attrs;
302 for (i = 0; (attr = modinfo_attrs[i]); i++) {
303 if (!attr->test || attr->test(mod)) {
304 memcpy(temp_attr, attr, sizeof(*temp_attr));
305 sysfs_attr_init(&temp_attr->attr);
306 error = sysfs_create_file(&mod->mkobj.kobj,
307 &temp_attr->attr);
308 if (error)
309 goto error_out;
310 ++temp_attr;
311 }
312 }
313
314 return 0;
315
316error_out:
317 if (i > 0)
318 module_remove_modinfo_attrs(mod, --i);
319 else
320 kfree(mod->modinfo_attrs);
321 return error;
322}
323
324static void mod_kobject_put(struct module *mod)
325{
326 DECLARE_COMPLETION_ONSTACK(c);
327
328 mod->mkobj.kobj_completion = &c;
329 kobject_put(&mod->mkobj.kobj);
330 wait_for_completion(&c);
331}
332
333static int mod_sysfs_init(struct module *mod)
334{
335 int err;
336 struct kobject *kobj;
337
338 if (!module_kset) {
339 pr_err("%s: module sysfs not initialized\n", mod->name);
340 err = -EINVAL;
341 goto out;
342 }
343
344 kobj = kset_find_obj(module_kset, mod->name);
345 if (kobj) {
346 pr_err("%s: module is already loaded\n", mod->name);
347 kobject_put(kobj);
348 err = -EINVAL;
349 goto out;
350 }
351
352 mod->mkobj.mod = mod;
353
354 memset(&mod->mkobj.kobj, 0, sizeof(mod->mkobj.kobj));
355 mod->mkobj.kobj.kset = module_kset;
356 err = kobject_init_and_add(&mod->mkobj.kobj, &module_ktype, NULL,
357 "%s", mod->name);
358 if (err)
359 mod_kobject_put(mod);
360
361out:
362 return err;
363}
364
365int mod_sysfs_setup(struct module *mod,
366 const struct load_info *info,
367 struct kernel_param *kparam,
368 unsigned int num_params)
369{
370 int err;
371
372 err = mod_sysfs_init(mod);
373 if (err)
374 goto out;
375
376 mod->holders_dir = kobject_create_and_add("holders", &mod->mkobj.kobj);
377 if (!mod->holders_dir) {
378 err = -ENOMEM;
379 goto out_unreg;
380 }
381
382 err = module_param_sysfs_setup(mod, kparam, num_params);
383 if (err)
384 goto out_unreg_holders;
385
386 err = module_add_modinfo_attrs(mod);
387 if (err)
388 goto out_unreg_param;
389
390 err = add_usage_links(mod);
391 if (err)
392 goto out_unreg_modinfo_attrs;
393
394 err = add_sect_attrs(mod, info);
395 if (err)
396 goto out_del_usage_links;
397
398 err = add_notes_attrs(mod, info);
399 if (err)
400 goto out_unreg_sect_attrs;
401
402 return 0;
403
404out_unreg_sect_attrs:
405 remove_sect_attrs(mod);
406out_del_usage_links:
407 del_usage_links(mod);
408out_unreg_modinfo_attrs:
409 module_remove_modinfo_attrs(mod, -1);
410out_unreg_param:
411 module_param_sysfs_remove(mod);
412out_unreg_holders:
413 kobject_put(mod->holders_dir);
414out_unreg:
415 mod_kobject_put(mod);
416out:
417 return err;
418}
419
420static void mod_sysfs_fini(struct module *mod)
421{
422 remove_notes_attrs(mod);
423 remove_sect_attrs(mod);
424 mod_kobject_put(mod);
425}
426
427void mod_sysfs_teardown(struct module *mod)
428{
429 del_usage_links(mod);
430 module_remove_modinfo_attrs(mod, -1);
431 module_param_sysfs_remove(mod);
432 kobject_put(mod->mkobj.drivers_dir);
433 kobject_put(mod->holders_dir);
434 mod_sysfs_fini(mod);
435}
436
437void init_param_lock(struct module *mod)
438{
439 mutex_init(&mod->param_lock);
440}