1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* Helpers for initial module or kernel cmdline parsing
3 Copyright (C) 2001 Rusty Russell.
6 #include <linux/kernel.h>
7 #include <linux/string.h>
8 #include <linux/errno.h>
9 #include <linux/module.h>
10 #include <linux/moduleparam.h>
11 #include <linux/device.h>
12 #include <linux/err.h>
13 #include <linux/slab.h>
14 #include <linux/ctype.h>
15 #include <linux/security.h>
18 /* Protects all built-in parameters, modules use their own param_lock */
19 static DEFINE_MUTEX(param_lock
);
21 /* Use the module's mutex, or if built-in use the built-in mutex */
23 #define KPARAM_MUTEX(mod) ((mod) ? &(mod)->param_lock : ¶m_lock)
25 #define KPARAM_MUTEX(mod) (¶m_lock)
28 static inline void check_kparam_locked(struct module
*mod
)
30 BUG_ON(!mutex_is_locked(KPARAM_MUTEX(mod
)));
33 static inline void check_kparam_locked(struct module
*mod
)
36 #endif /* !CONFIG_SYSFS */
38 /* This just allows us to keep track of which parameters are kmalloced. */
39 struct kmalloced_param
{
40 struct list_head list
;
43 static LIST_HEAD(kmalloced_params
);
44 static DEFINE_SPINLOCK(kmalloced_params_lock
);
46 static void *kmalloc_parameter(unsigned int size
)
48 struct kmalloced_param
*p
;
50 p
= kmalloc(sizeof(*p
) + size
, GFP_KERNEL
);
54 spin_lock(&kmalloced_params_lock
);
55 list_add(&p
->list
, &kmalloced_params
);
56 spin_unlock(&kmalloced_params_lock
);
61 /* Does nothing if parameter wasn't kmalloced above. */
62 static void maybe_kfree_parameter(void *param
)
64 struct kmalloced_param
*p
;
66 spin_lock(&kmalloced_params_lock
);
67 list_for_each_entry(p
, &kmalloced_params
, list
) {
68 if (p
->val
== param
) {
74 spin_unlock(&kmalloced_params_lock
);
77 static char dash2underscore(char c
)
84 bool parameqn(const char *a
, const char *b
, size_t n
)
88 for (i
= 0; i
< n
; i
++) {
89 if (dash2underscore(a
[i
]) != dash2underscore(b
[i
]))
95 bool parameq(const char *a
, const char *b
)
97 return parameqn(a
, b
, strlen(a
)+1);
100 static bool param_check_unsafe(const struct kernel_param
*kp
)
102 if (kp
->flags
& KERNEL_PARAM_FL_HWPARAM
&&
103 security_locked_down(LOCKDOWN_MODULE_PARAMETERS
))
106 if (kp
->flags
& KERNEL_PARAM_FL_UNSAFE
) {
107 pr_notice("Setting dangerous option %s - tainting kernel\n",
109 add_taint(TAINT_USER
, LOCKDEP_STILL_OK
);
115 static int parse_one(char *param
,
118 const struct kernel_param
*params
,
123 int (*handle_unknown
)(char *param
, char *val
,
124 const char *doing
, void *arg
))
130 for (i
= 0; i
< num_params
; i
++) {
131 if (parameq(param
, params
[i
].name
)) {
132 if (params
[i
].level
< min_level
133 || params
[i
].level
> max_level
)
135 /* No one handled NULL, so do it here. */
137 !(params
[i
].ops
->flags
& KERNEL_PARAM_OPS_FL_NOARG
))
139 pr_debug("handling %s with %p\n", param
,
141 kernel_param_lock(params
[i
].mod
);
142 if (param_check_unsafe(¶ms
[i
]))
143 err
= params
[i
].ops
->set(val
, ¶ms
[i
]);
146 kernel_param_unlock(params
[i
].mod
);
151 if (handle_unknown
) {
152 pr_debug("doing %s: %s='%s'\n", doing
, param
, val
);
153 return handle_unknown(param
, val
, doing
, arg
);
156 pr_debug("Unknown argument '%s'\n", param
);
160 /* Args looks like "foo=bar,bar2 baz=fuz wiz". */
161 char *parse_args(const char *doing
,
163 const struct kernel_param
*params
,
168 int (*unknown
)(char *param
, char *val
,
169 const char *doing
, void *arg
))
171 char *param
, *val
, *err
= NULL
;
173 /* Chew leading spaces */
174 args
= skip_spaces(args
);
177 pr_debug("doing %s, parsing ARGS: '%s'\n", doing
, args
);
181 int irq_was_disabled
;
183 args
= next_arg(args
, ¶m
, &val
);
185 if (!val
&& strcmp(param
, "--") == 0)
187 irq_was_disabled
= irqs_disabled();
188 ret
= parse_one(param
, val
, doing
, params
, num
,
189 min_level
, max_level
, arg
, unknown
);
190 if (irq_was_disabled
&& !irqs_disabled())
191 pr_warn("%s: option '%s' enabled irq's!\n",
198 pr_err("%s: Unknown parameter `%s'\n", doing
, param
);
201 pr_err("%s: `%s' too large for parameter `%s'\n",
202 doing
, val
?: "", param
);
205 pr_err("%s: `%s' invalid for parameter `%s'\n",
206 doing
, val
?: "", param
);
216 /* Lazy bastard, eh? */
217 #define STANDARD_PARAM_DEF(name, type, format, strtolfn) \
218 int param_set_##name(const char *val, const struct kernel_param *kp) \
220 return strtolfn(val, 0, (type *)kp->arg); \
222 int param_get_##name(char *buffer, const struct kernel_param *kp) \
224 return scnprintf(buffer, PAGE_SIZE, format "\n", \
225 *((type *)kp->arg)); \
227 const struct kernel_param_ops param_ops_##name = { \
228 .set = param_set_##name, \
229 .get = param_get_##name, \
231 EXPORT_SYMBOL(param_set_##name); \
232 EXPORT_SYMBOL(param_get_##name); \
233 EXPORT_SYMBOL(param_ops_##name)
236 STANDARD_PARAM_DEF(byte
, unsigned char, "%hhu", kstrtou8
);
237 STANDARD_PARAM_DEF(short, short, "%hi", kstrtos16
);
238 STANDARD_PARAM_DEF(ushort
, unsigned short, "%hu", kstrtou16
);
239 STANDARD_PARAM_DEF(int, int, "%i", kstrtoint
);
240 STANDARD_PARAM_DEF(uint
, unsigned int, "%u", kstrtouint
);
241 STANDARD_PARAM_DEF(long, long, "%li", kstrtol
);
242 STANDARD_PARAM_DEF(ulong
, unsigned long, "%lu", kstrtoul
);
243 STANDARD_PARAM_DEF(ullong
, unsigned long long, "%llu", kstrtoull
);
244 STANDARD_PARAM_DEF(hexint
, unsigned int, "%#08x", kstrtouint
);
246 int param_set_uint_minmax(const char *val
, const struct kernel_param
*kp
,
247 unsigned int min
, unsigned int max
)
254 ret
= kstrtouint(val
, 0, &num
);
257 if (num
< min
|| num
> max
)
259 *((unsigned int *)kp
->arg
) = num
;
262 EXPORT_SYMBOL_GPL(param_set_uint_minmax
);
264 int param_set_charp(const char *val
, const struct kernel_param
*kp
)
266 if (strlen(val
) > 1024) {
267 pr_err("%s: string parameter too long\n", kp
->name
);
271 maybe_kfree_parameter(*(char **)kp
->arg
);
273 /* This is a hack. We can't kmalloc in early boot, and we
274 * don't need to; this mangled commandline is preserved. */
275 if (slab_is_available()) {
276 *(char **)kp
->arg
= kmalloc_parameter(strlen(val
)+1);
277 if (!*(char **)kp
->arg
)
279 strcpy(*(char **)kp
->arg
, val
);
281 *(const char **)kp
->arg
= val
;
285 EXPORT_SYMBOL(param_set_charp
);
287 int param_get_charp(char *buffer
, const struct kernel_param
*kp
)
289 return scnprintf(buffer
, PAGE_SIZE
, "%s\n", *((char **)kp
->arg
));
291 EXPORT_SYMBOL(param_get_charp
);
293 void param_free_charp(void *arg
)
295 maybe_kfree_parameter(*((char **)arg
));
297 EXPORT_SYMBOL(param_free_charp
);
299 const struct kernel_param_ops param_ops_charp
= {
300 .set
= param_set_charp
,
301 .get
= param_get_charp
,
302 .free
= param_free_charp
,
304 EXPORT_SYMBOL(param_ops_charp
);
306 /* Actually could be a bool or an int, for historical reasons. */
307 int param_set_bool(const char *val
, const struct kernel_param
*kp
)
309 /* No equals means "set"... */
312 /* One of =[yYnN01] */
313 return strtobool(val
, kp
->arg
);
315 EXPORT_SYMBOL(param_set_bool
);
317 int param_get_bool(char *buffer
, const struct kernel_param
*kp
)
319 /* Y and N chosen as being relatively non-coder friendly */
320 return sprintf(buffer
, "%c\n", *(bool *)kp
->arg
? 'Y' : 'N');
322 EXPORT_SYMBOL(param_get_bool
);
324 const struct kernel_param_ops param_ops_bool
= {
325 .flags
= KERNEL_PARAM_OPS_FL_NOARG
,
326 .set
= param_set_bool
,
327 .get
= param_get_bool
,
329 EXPORT_SYMBOL(param_ops_bool
);
331 int param_set_bool_enable_only(const char *val
, const struct kernel_param
*kp
)
335 bool orig_value
= *(bool *)kp
->arg
;
336 struct kernel_param dummy_kp
= *kp
;
338 dummy_kp
.arg
= &new_value
;
340 err
= param_set_bool(val
, &dummy_kp
);
344 /* Don't let them unset it once it's set! */
345 if (!new_value
&& orig_value
)
349 err
= param_set_bool(val
, kp
);
353 EXPORT_SYMBOL_GPL(param_set_bool_enable_only
);
355 const struct kernel_param_ops param_ops_bool_enable_only
= {
356 .flags
= KERNEL_PARAM_OPS_FL_NOARG
,
357 .set
= param_set_bool_enable_only
,
358 .get
= param_get_bool
,
360 EXPORT_SYMBOL_GPL(param_ops_bool_enable_only
);
362 /* This one must be bool. */
363 int param_set_invbool(const char *val
, const struct kernel_param
*kp
)
367 struct kernel_param dummy
;
369 dummy
.arg
= &boolval
;
370 ret
= param_set_bool(val
, &dummy
);
372 *(bool *)kp
->arg
= !boolval
;
375 EXPORT_SYMBOL(param_set_invbool
);
377 int param_get_invbool(char *buffer
, const struct kernel_param
*kp
)
379 return sprintf(buffer
, "%c\n", (*(bool *)kp
->arg
) ? 'N' : 'Y');
381 EXPORT_SYMBOL(param_get_invbool
);
383 const struct kernel_param_ops param_ops_invbool
= {
384 .set
= param_set_invbool
,
385 .get
= param_get_invbool
,
387 EXPORT_SYMBOL(param_ops_invbool
);
389 int param_set_bint(const char *val
, const struct kernel_param
*kp
)
391 /* Match bool exactly, by re-using it. */
392 struct kernel_param boolkp
= *kp
;
398 ret
= param_set_bool(val
, &boolkp
);
403 EXPORT_SYMBOL(param_set_bint
);
405 const struct kernel_param_ops param_ops_bint
= {
406 .flags
= KERNEL_PARAM_OPS_FL_NOARG
,
407 .set
= param_set_bint
,
408 .get
= param_get_int
,
410 EXPORT_SYMBOL(param_ops_bint
);
412 /* We break the rule and mangle the string. */
413 static int param_array(struct module
*mod
,
416 unsigned int min
, unsigned int max
,
417 void *elem
, int elemsize
,
418 int (*set
)(const char *, const struct kernel_param
*kp
),
423 struct kernel_param kp
;
426 /* Get the name right for errors. */
432 /* We expect a comma-separated list of values. */
437 pr_err("%s: can only take %i arguments\n", name
, max
);
440 len
= strcspn(val
, ",");
442 /* nul-terminate and parse */
444 ((char *)val
)[len
] = '\0';
445 check_kparam_locked(mod
);
453 } while (save
== ',');
456 pr_err("%s: needs at least %i arguments\n", name
, min
);
462 static int param_array_set(const char *val
, const struct kernel_param
*kp
)
464 const struct kparam_array
*arr
= kp
->arr
;
465 unsigned int temp_num
;
467 return param_array(kp
->mod
, kp
->name
, val
, 1, arr
->max
, arr
->elem
,
468 arr
->elemsize
, arr
->ops
->set
, kp
->level
,
469 arr
->num
?: &temp_num
);
472 static int param_array_get(char *buffer
, const struct kernel_param
*kp
)
475 const struct kparam_array
*arr
= kp
->arr
;
476 struct kernel_param p
= *kp
;
478 for (i
= off
= 0; i
< (arr
->num
? *arr
->num
: arr
->max
); i
++) {
479 /* Replace \n with comma */
481 buffer
[off
- 1] = ',';
482 p
.arg
= arr
->elem
+ arr
->elemsize
* i
;
483 check_kparam_locked(p
.mod
);
484 ret
= arr
->ops
->get(buffer
+ off
, &p
);
493 static void param_array_free(void *arg
)
496 const struct kparam_array
*arr
= arg
;
499 for (i
= 0; i
< (arr
->num
? *arr
->num
: arr
->max
); i
++)
500 arr
->ops
->free(arr
->elem
+ arr
->elemsize
* i
);
503 const struct kernel_param_ops param_array_ops
= {
504 .set
= param_array_set
,
505 .get
= param_array_get
,
506 .free
= param_array_free
,
508 EXPORT_SYMBOL(param_array_ops
);
510 int param_set_copystring(const char *val
, const struct kernel_param
*kp
)
512 const struct kparam_string
*kps
= kp
->str
;
514 if (strlen(val
)+1 > kps
->maxlen
) {
515 pr_err("%s: string doesn't fit in %u chars.\n",
516 kp
->name
, kps
->maxlen
-1);
519 strcpy(kps
->string
, val
);
522 EXPORT_SYMBOL(param_set_copystring
);
524 int param_get_string(char *buffer
, const struct kernel_param
*kp
)
526 const struct kparam_string
*kps
= kp
->str
;
527 return scnprintf(buffer
, PAGE_SIZE
, "%s\n", kps
->string
);
529 EXPORT_SYMBOL(param_get_string
);
531 const struct kernel_param_ops param_ops_string
= {
532 .set
= param_set_copystring
,
533 .get
= param_get_string
,
535 EXPORT_SYMBOL(param_ops_string
);
537 /* sysfs output in /sys/modules/XYZ/parameters/ */
538 #define to_module_attr(n) container_of(n, struct module_attribute, attr)
539 #define to_module_kobject(n) container_of(n, struct module_kobject, kobj)
541 struct param_attribute
543 struct module_attribute mattr
;
544 const struct kernel_param
*param
;
547 struct module_param_attrs
550 struct attribute_group grp
;
551 struct param_attribute attrs
[];
555 #define to_param_attr(n) container_of(n, struct param_attribute, mattr)
557 static ssize_t
param_attr_show(struct module_attribute
*mattr
,
558 struct module_kobject
*mk
, char *buf
)
561 struct param_attribute
*attribute
= to_param_attr(mattr
);
563 if (!attribute
->param
->ops
->get
)
566 kernel_param_lock(mk
->mod
);
567 count
= attribute
->param
->ops
->get(buf
, attribute
->param
);
568 kernel_param_unlock(mk
->mod
);
572 /* sysfs always hands a nul-terminated string in buf. We rely on that. */
573 static ssize_t
param_attr_store(struct module_attribute
*mattr
,
574 struct module_kobject
*mk
,
575 const char *buf
, size_t len
)
578 struct param_attribute
*attribute
= to_param_attr(mattr
);
580 if (!attribute
->param
->ops
->set
)
583 kernel_param_lock(mk
->mod
);
584 if (param_check_unsafe(attribute
->param
))
585 err
= attribute
->param
->ops
->set(buf
, attribute
->param
);
588 kernel_param_unlock(mk
->mod
);
595 #ifdef CONFIG_MODULES
598 #define __modinit __init
602 void kernel_param_lock(struct module
*mod
)
604 mutex_lock(KPARAM_MUTEX(mod
));
607 void kernel_param_unlock(struct module
*mod
)
609 mutex_unlock(KPARAM_MUTEX(mod
));
612 EXPORT_SYMBOL(kernel_param_lock
);
613 EXPORT_SYMBOL(kernel_param_unlock
);
616 * add_sysfs_param - add a parameter to sysfs
617 * @mk: struct module_kobject
618 * @kp: the actual parameter definition to add to sysfs
619 * @name: name of parameter
621 * Create a kobject if for a (per-module) parameter if mp NULL, and
622 * create file in sysfs. Returns an error on out of memory. Always cleans up
623 * if there's an error.
625 static __modinit
int add_sysfs_param(struct module_kobject
*mk
,
626 const struct kernel_param
*kp
,
629 struct module_param_attrs
*new_mp
;
630 struct attribute
**new_attrs
;
633 /* We don't bother calling this with invisible parameters. */
637 /* First allocation. */
638 mk
->mp
= kzalloc(sizeof(*mk
->mp
), GFP_KERNEL
);
641 mk
->mp
->grp
.name
= "parameters";
642 /* NULL-terminated attribute array. */
643 mk
->mp
->grp
.attrs
= kzalloc(sizeof(mk
->mp
->grp
.attrs
[0]),
645 /* Caller will cleanup via free_module_param_attrs */
646 if (!mk
->mp
->grp
.attrs
)
650 /* Enlarge allocations. */
651 new_mp
= krealloc(mk
->mp
,
653 sizeof(mk
->mp
->attrs
[0]) * (mk
->mp
->num
+ 1),
659 /* Extra pointer for NULL terminator */
660 new_attrs
= krealloc(mk
->mp
->grp
.attrs
,
661 sizeof(mk
->mp
->grp
.attrs
[0]) * (mk
->mp
->num
+ 2),
665 mk
->mp
->grp
.attrs
= new_attrs
;
667 /* Tack new one on the end. */
668 memset(&mk
->mp
->attrs
[mk
->mp
->num
], 0, sizeof(mk
->mp
->attrs
[0]));
669 sysfs_attr_init(&mk
->mp
->attrs
[mk
->mp
->num
].mattr
.attr
);
670 mk
->mp
->attrs
[mk
->mp
->num
].param
= kp
;
671 mk
->mp
->attrs
[mk
->mp
->num
].mattr
.show
= param_attr_show
;
672 /* Do not allow runtime DAC changes to make param writable. */
673 if ((kp
->perm
& (S_IWUSR
| S_IWGRP
| S_IWOTH
)) != 0)
674 mk
->mp
->attrs
[mk
->mp
->num
].mattr
.store
= param_attr_store
;
676 mk
->mp
->attrs
[mk
->mp
->num
].mattr
.store
= NULL
;
677 mk
->mp
->attrs
[mk
->mp
->num
].mattr
.attr
.name
= (char *)name
;
678 mk
->mp
->attrs
[mk
->mp
->num
].mattr
.attr
.mode
= kp
->perm
;
681 /* Fix up all the pointers, since krealloc can move us */
682 for (i
= 0; i
< mk
->mp
->num
; i
++)
683 mk
->mp
->grp
.attrs
[i
] = &mk
->mp
->attrs
[i
].mattr
.attr
;
684 mk
->mp
->grp
.attrs
[mk
->mp
->num
] = NULL
;
688 #ifdef CONFIG_MODULES
689 static void free_module_param_attrs(struct module_kobject
*mk
)
692 kfree(mk
->mp
->grp
.attrs
);
698 * module_param_sysfs_setup - setup sysfs support for one module
700 * @kparam: module parameters (array)
701 * @num_params: number of module parameters
703 * Adds sysfs entries for module parameters under
704 * /sys/module/[mod->name]/parameters/
706 int module_param_sysfs_setup(struct module
*mod
,
707 const struct kernel_param
*kparam
,
708 unsigned int num_params
)
713 for (i
= 0; i
< num_params
; i
++) {
714 if (kparam
[i
].perm
== 0)
716 err
= add_sysfs_param(&mod
->mkobj
, &kparam
[i
], kparam
[i
].name
);
718 free_module_param_attrs(&mod
->mkobj
);
727 /* Create the param group. */
728 err
= sysfs_create_group(&mod
->mkobj
.kobj
, &mod
->mkobj
.mp
->grp
);
730 free_module_param_attrs(&mod
->mkobj
);
735 * module_param_sysfs_remove - remove sysfs support for one module
738 * Remove sysfs entries for module parameters and the corresponding
741 void module_param_sysfs_remove(struct module
*mod
)
744 sysfs_remove_group(&mod
->mkobj
.kobj
, &mod
->mkobj
.mp
->grp
);
745 /* We are positive that no one is using any param
746 * attrs at this point. Deallocate immediately. */
747 free_module_param_attrs(&mod
->mkobj
);
752 void destroy_params(const struct kernel_param
*params
, unsigned num
)
756 for (i
= 0; i
< num
; i
++)
757 if (params
[i
].ops
->free
)
758 params
[i
].ops
->free(params
[i
].arg
);
761 static struct module_kobject
* __init
locate_module_kobject(const char *name
)
763 struct module_kobject
*mk
;
764 struct kobject
*kobj
;
767 kobj
= kset_find_obj(module_kset
, name
);
769 mk
= to_module_kobject(kobj
);
771 mk
= kzalloc(sizeof(struct module_kobject
), GFP_KERNEL
);
774 mk
->mod
= THIS_MODULE
;
775 mk
->kobj
.kset
= module_kset
;
776 err
= kobject_init_and_add(&mk
->kobj
, &module_ktype
, NULL
,
778 #ifdef CONFIG_MODULES
780 err
= sysfs_create_file(&mk
->kobj
, &module_uevent
.attr
);
783 kobject_put(&mk
->kobj
);
784 pr_crit("Adding module '%s' to sysfs failed (%d), the system may be unstable.\n",
789 /* So that we hold reference in both cases. */
790 kobject_get(&mk
->kobj
);
796 static void __init
kernel_add_sysfs_param(const char *name
,
797 const struct kernel_param
*kparam
,
798 unsigned int name_skip
)
800 struct module_kobject
*mk
;
803 mk
= locate_module_kobject(name
);
807 /* We need to remove old parameters before adding more. */
809 sysfs_remove_group(&mk
->kobj
, &mk
->mp
->grp
);
811 /* These should not fail at boot. */
812 err
= add_sysfs_param(mk
, kparam
, kparam
->name
+ name_skip
);
814 err
= sysfs_create_group(&mk
->kobj
, &mk
->mp
->grp
);
816 kobject_uevent(&mk
->kobj
, KOBJ_ADD
);
817 kobject_put(&mk
->kobj
);
821 * param_sysfs_builtin - add sysfs parameters for built-in modules
823 * Add module_parameters to sysfs for "modules" built into the kernel.
825 * The "module" name (KBUILD_MODNAME) is stored before a dot, the
826 * "parameter" name is stored behind a dot in kernel_param->name. So,
827 * extract the "module" name for all built-in kernel_param-eters,
828 * and for all who have the same, call kernel_add_sysfs_param.
830 static void __init
param_sysfs_builtin(void)
832 const struct kernel_param
*kp
;
833 unsigned int name_len
;
834 char modname
[MODULE_NAME_LEN
];
836 for (kp
= __start___param
; kp
< __stop___param
; kp
++) {
842 dot
= strchr(kp
->name
, '.');
844 /* This happens for core_param() */
845 strcpy(modname
, "kernel");
848 name_len
= dot
- kp
->name
+ 1;
849 strlcpy(modname
, kp
->name
, name_len
);
851 kernel_add_sysfs_param(modname
, kp
, name_len
);
855 ssize_t
__modver_version_show(struct module_attribute
*mattr
,
856 struct module_kobject
*mk
, char *buf
)
858 struct module_version_attribute
*vattr
=
859 container_of(mattr
, struct module_version_attribute
, mattr
);
861 return scnprintf(buf
, PAGE_SIZE
, "%s\n", vattr
->version
);
864 extern const struct module_version_attribute __start___modver
[];
865 extern const struct module_version_attribute __stop___modver
[];
867 static void __init
version_sysfs_builtin(void)
869 const struct module_version_attribute
*vattr
;
870 struct module_kobject
*mk
;
873 for (vattr
= __start___modver
; vattr
< __stop___modver
; vattr
++) {
874 mk
= locate_module_kobject(vattr
->module_name
);
876 err
= sysfs_create_file(&mk
->kobj
, &vattr
->mattr
.attr
);
878 kobject_uevent(&mk
->kobj
, KOBJ_ADD
);
879 kobject_put(&mk
->kobj
);
884 /* module-related sysfs stuff */
886 static ssize_t
module_attr_show(struct kobject
*kobj
,
887 struct attribute
*attr
,
890 struct module_attribute
*attribute
;
891 struct module_kobject
*mk
;
894 attribute
= to_module_attr(attr
);
895 mk
= to_module_kobject(kobj
);
897 if (!attribute
->show
)
900 ret
= attribute
->show(attribute
, mk
, buf
);
905 static ssize_t
module_attr_store(struct kobject
*kobj
,
906 struct attribute
*attr
,
907 const char *buf
, size_t len
)
909 struct module_attribute
*attribute
;
910 struct module_kobject
*mk
;
913 attribute
= to_module_attr(attr
);
914 mk
= to_module_kobject(kobj
);
916 if (!attribute
->store
)
919 ret
= attribute
->store(attribute
, mk
, buf
, len
);
924 static const struct sysfs_ops module_sysfs_ops
= {
925 .show
= module_attr_show
,
926 .store
= module_attr_store
,
929 static int uevent_filter(struct kset
*kset
, struct kobject
*kobj
)
931 struct kobj_type
*ktype
= get_ktype(kobj
);
933 if (ktype
== &module_ktype
)
938 static const struct kset_uevent_ops module_uevent_ops
= {
939 .filter
= uevent_filter
,
942 struct kset
*module_kset
;
943 int module_sysfs_initialized
;
945 static void module_kobj_release(struct kobject
*kobj
)
947 struct module_kobject
*mk
= to_module_kobject(kobj
);
948 complete(mk
->kobj_completion
);
951 struct kobj_type module_ktype
= {
952 .release
= module_kobj_release
,
953 .sysfs_ops
= &module_sysfs_ops
,
957 * param_sysfs_init - wrapper for built-in params support
959 static int __init
param_sysfs_init(void)
961 module_kset
= kset_create_and_add("module", &module_uevent_ops
, NULL
);
963 printk(KERN_WARNING
"%s (%d): error creating kset\n",
967 module_sysfs_initialized
= 1;
969 version_sysfs_builtin();
970 param_sysfs_builtin();
974 subsys_initcall(param_sysfs_init
);
976 #endif /* CONFIG_SYSFS */