xref: /linux-6.15/kernel/module/sysfs.c (revision 4b2c11e4) 
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
22 struct module_sect_attr {
23 	struct bin_attribute battr;
24 };
25 
26 struct module_sect_attrs {
27 	struct attribute_group grp;
28 	struct module_sect_attr attrs[];
29 };
30 
31 #define MODULE_SECT_READ_SIZE (3 /* "0x", "\n" */ + (BITS_PER_LONG / 4))
32 static ssize_t module_sect_read(struct file *file, struct kobject *kobj,
33 				struct bin_attribute *battr,
34 				char *buf, loff_t pos, size_t count)
35 {
36 	char bounce[MODULE_SECT_READ_SIZE + 1];
37 	size_t wrote;
38 
39 	if (pos != 0)
40 		return -EINVAL;
41 
42 	/*
43 	 * Since we're a binary read handler, we must account for the
44 	 * trailing NUL byte that sprintf will write: if "buf" is
45 	 * too small to hold the NUL, or the NUL is exactly the last
46 	 * byte, the read will look like it got truncated by one byte.
47 	 * Since there is no way to ask sprintf nicely to not write
48 	 * the NUL, we have to use a bounce buffer.
49 	 */
50 	wrote = scnprintf(bounce, sizeof(bounce), "0x%px\n",
51 			  kallsyms_show_value(file->f_cred)
52 				? battr->private : NULL);
53 	count = min(count, wrote);
54 	memcpy(buf, bounce, count);
55 
56 	return count;
57 }
58 
59 static void free_sect_attrs(struct module_sect_attrs *sect_attrs)
60 {
61 	struct bin_attribute **bin_attr;
62 
63 	for (bin_attr = sect_attrs->grp.bin_attrs; *bin_attr; bin_attr++)
64 		kfree((*bin_attr)->attr.name);
65 	kfree(sect_attrs);
66 }
67 
68 static int add_sect_attrs(struct module *mod, const struct load_info *info)
69 {
70 	unsigned int nloaded = 0, i, size[2];
71 	struct module_sect_attrs *sect_attrs;
72 	struct module_sect_attr *sattr;
73 	struct bin_attribute **gattr;
74 	int ret;
75 
76 	/* Count loaded sections and allocate structures */
77 	for (i = 0; i < info->hdr->e_shnum; i++)
78 		if (!sect_empty(&info->sechdrs[i]))
79 			nloaded++;
80 	size[0] = ALIGN(struct_size(sect_attrs, attrs, nloaded),
81 			sizeof(sect_attrs->grp.bin_attrs[0]));
82 	size[1] = (nloaded + 1) * sizeof(sect_attrs->grp.bin_attrs[0]);
83 	sect_attrs = kzalloc(size[0] + size[1], GFP_KERNEL);
84 	if (!sect_attrs)
85 		return -ENOMEM;
86 
87 	/* Setup section attributes. */
88 	sect_attrs->grp.name = "sections";
89 	sect_attrs->grp.bin_attrs = (void *)sect_attrs + size[0];
90 
91 	sattr = &sect_attrs->attrs[0];
92 	gattr = &sect_attrs->grp.bin_attrs[0];
93 	for (i = 0; i < info->hdr->e_shnum; i++) {
94 		Elf_Shdr *sec = &info->sechdrs[i];
95 
96 		if (sect_empty(sec))
97 			continue;
98 		sysfs_bin_attr_init(&sattr->battr);
99 		sattr->battr.attr.name =
100 			kstrdup(info->secstrings + sec->sh_name, GFP_KERNEL);
101 		if (!sattr->battr.attr.name) {
102 			ret = -ENOMEM;
103 			goto out;
104 		}
105 		sattr->battr.read = module_sect_read;
106 		sattr->battr.private = (void *)sec->sh_addr;
107 		sattr->battr.size = MODULE_SECT_READ_SIZE;
108 		sattr->battr.attr.mode = 0400;
109 		*(gattr++) = &(sattr++)->battr;
110 	}
111 	*gattr = NULL;
112 
113 	ret = sysfs_create_group(&mod->mkobj.kobj, &sect_attrs->grp);
114 	if (ret)
115 		goto out;
116 
117 	mod->sect_attrs = sect_attrs;
118 	return 0;
119 out:
120 	free_sect_attrs(sect_attrs);
121 	return ret;
122 }
123 
124 static void remove_sect_attrs(struct module *mod)
125 {
126 	if (mod->sect_attrs) {
127 		sysfs_remove_group(&mod->mkobj.kobj,
128 				   &mod->sect_attrs->grp);
129 		/*
130 		 * We are positive that no one is using any sect attrs
131 		 * at this point.  Deallocate immediately.
132 		 */
133 		free_sect_attrs(mod->sect_attrs);
134 		mod->sect_attrs = NULL;
135 	}
136 }
137 
138 /*
139  * /sys/module/foo/notes/.section.name gives contents of SHT_NOTE sections.
140  */
141 
142 struct module_notes_attrs {
143 	struct kobject *dir;
144 	unsigned int notes;
145 	struct bin_attribute attrs[] __counted_by(notes);
146 };
147 
148 static void free_notes_attrs(struct module_notes_attrs *notes_attrs,
149 			     unsigned int i)
150 {
151 	if (notes_attrs->dir) {
152 		while (i-- > 0)
153 			sysfs_remove_bin_file(notes_attrs->dir,
154 					      &notes_attrs->attrs[i]);
155 		kobject_put(notes_attrs->dir);
156 	}
157 	kfree(notes_attrs);
158 }
159 
160 static int add_notes_attrs(struct module *mod, const struct load_info *info)
161 {
162 	unsigned int notes, loaded, i;
163 	struct module_notes_attrs *notes_attrs;
164 	struct bin_attribute *nattr;
165 	int ret;
166 
167 	/* Count notes sections and allocate structures.  */
168 	notes = 0;
169 	for (i = 0; i < info->hdr->e_shnum; i++)
170 		if (!sect_empty(&info->sechdrs[i]) &&
171 		    info->sechdrs[i].sh_type == SHT_NOTE)
172 			++notes;
173 
174 	if (notes == 0)
175 		return 0;
176 
177 	notes_attrs = kzalloc(struct_size(notes_attrs, attrs, notes),
178 			      GFP_KERNEL);
179 	if (!notes_attrs)
180 		return -ENOMEM;
181 
182 	notes_attrs->notes = notes;
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].battr.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 			++nattr;
195 		}
196 		++loaded;
197 	}
198 
199 	notes_attrs->dir = kobject_create_and_add("notes", &mod->mkobj.kobj);
200 	if (!notes_attrs->dir) {
201 		ret = -ENOMEM;
202 		goto out;
203 	}
204 
205 	for (i = 0; i < notes; ++i) {
206 		ret = sysfs_create_bin_file(notes_attrs->dir, &notes_attrs->attrs[i]);
207 		if (ret)
208 			goto out;
209 	}
210 
211 	mod->notes_attrs = notes_attrs;
212 	return 0;
213 
214 out:
215 	free_notes_attrs(notes_attrs, i);
216 	return ret;
217 }
218 
219 static void remove_notes_attrs(struct module *mod)
220 {
221 	if (mod->notes_attrs)
222 		free_notes_attrs(mod->notes_attrs, mod->notes_attrs->notes);
223 }
224 
225 #else /* !CONFIG_KALLSYMS */
226 static inline int add_sect_attrs(struct module *mod, const struct load_info *info)
227 {
228 	return 0;
229 }
230 static inline void remove_sect_attrs(struct module *mod) { }
231 static inline int add_notes_attrs(struct module *mod, const struct load_info *info)
232 {
233 	return 0;
234 }
235 static inline void remove_notes_attrs(struct module *mod) { }
236 #endif /* CONFIG_KALLSYMS */
237 
238 static 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 
250 static 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 
270 static 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 
288 static 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 
316 error_out:
317 	if (i > 0)
318 		module_remove_modinfo_attrs(mod, --i);
319 	else
320 		kfree(mod->modinfo_attrs);
321 	return error;
322 }
323 
324 static 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 
333 static 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 
361 out:
362 	return err;
363 }
364 
365 int 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 
404 out_unreg_sect_attrs:
405 	remove_sect_attrs(mod);
406 out_del_usage_links:
407 	del_usage_links(mod);
408 out_unreg_modinfo_attrs:
409 	module_remove_modinfo_attrs(mod, -1);
410 out_unreg_param:
411 	module_param_sysfs_remove(mod);
412 out_unreg_holders:
413 	kobject_put(mod->holders_dir);
414 out_unreg:
415 	mod_kobject_put(mod);
416 out:
417 	return err;
418 }
419 
420 static 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 
427 void 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 
437 void init_param_lock(struct module *mod)
438 {
439 	mutex_init(&mod->param_lock);
440 }
441