1 /* Helpers for initial module or kernel cmdline parsing
2 Copyright (C) 2001 Rusty Russell.
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 #include <linux/kernel.h>
19 #include <linux/string.h>
20 #include <linux/errno.h>
21 #include <linux/module.h>
22 #include <linux/moduleparam.h>
23 #include <linux/device.h>
24 #include <linux/err.h>
25 #include <linux/slab.h>
26 #include <linux/ctype.h>
28 /* Protects all parameters, and incidentally kmalloced_param list. */
29 static DEFINE_MUTEX(param_lock
);
31 /* This just allows us to keep track of which parameters are kmalloced. */
32 struct kmalloced_param
{
33 struct list_head list
;
36 static LIST_HEAD(kmalloced_params
);
38 static void *kmalloc_parameter(unsigned int size
)
40 struct kmalloced_param
*p
;
42 p
= kmalloc(sizeof(*p
) + size
, GFP_KERNEL
);
46 list_add(&p
->list
, &kmalloced_params
);
50 /* Does nothing if parameter wasn't kmalloced above. */
51 static void maybe_kfree_parameter(void *param
)
53 struct kmalloced_param
*p
;
55 list_for_each_entry(p
, &kmalloced_params
, list
) {
56 if (p
->val
== param
) {
64 static char dash2underscore(char c
)
71 bool parameqn(const char *a
, const char *b
, size_t n
)
75 for (i
= 0; i
< n
; i
++) {
76 if (dash2underscore(a
[i
]) != dash2underscore(b
[i
]))
82 bool parameq(const char *a
, const char *b
)
84 return parameqn(a
, b
, strlen(a
)+1);
87 static void param_check_unsafe(const struct kernel_param
*kp
)
89 if (kp
->flags
& KERNEL_PARAM_FL_UNSAFE
) {
90 pr_warn("Setting dangerous option %s - tainting kernel\n",
92 add_taint(TAINT_USER
, LOCKDEP_STILL_OK
);
96 static int parse_one(char *param
,
99 const struct kernel_param
*params
,
103 int (*handle_unknown
)(char *param
, char *val
,
110 for (i
= 0; i
< num_params
; i
++) {
111 if (parameq(param
, params
[i
].name
)) {
112 if (params
[i
].level
< min_level
113 || params
[i
].level
> max_level
)
115 /* No one handled NULL, so do it here. */
117 !(params
[i
].ops
->flags
& KERNEL_PARAM_OPS_FL_NOARG
))
119 pr_debug("handling %s with %p\n", param
,
121 mutex_lock(¶m_lock
);
122 param_check_unsafe(¶ms
[i
]);
123 err
= params
[i
].ops
->set(val
, ¶ms
[i
]);
124 mutex_unlock(¶m_lock
);
129 if (handle_unknown
) {
130 pr_debug("doing %s: %s='%s'\n", doing
, param
, val
);
131 return handle_unknown(param
, val
, doing
);
134 pr_debug("Unknown argument '%s'\n", param
);
138 /* You can use " around spaces, but can't escape ". */
139 /* Hyphens and underscores equivalent in parameter names. */
140 static char *next_arg(char *args
, char **param
, char **val
)
142 unsigned int i
, equals
= 0;
143 int in_quote
= 0, quoted
= 0;
152 for (i
= 0; args
[i
]; i
++) {
153 if (isspace(args
[i
]) && !in_quote
)
160 in_quote
= !in_quote
;
168 *val
= args
+ equals
+ 1;
170 /* Don't include quotes in value. */
173 if (args
[i
-1] == '"')
177 if (quoted
&& args
[i
-1] == '"')
186 /* Chew up trailing spaces. */
187 return skip_spaces(next
);
190 /* Args looks like "foo=bar,bar2 baz=fuz wiz". */
191 char *parse_args(const char *doing
,
193 const struct kernel_param
*params
,
197 int (*unknown
)(char *param
, char *val
, const char *doing
))
201 /* Chew leading spaces */
202 args
= skip_spaces(args
);
205 pr_debug("doing %s, parsing ARGS: '%s'\n", doing
, args
);
209 int irq_was_disabled
;
211 args
= next_arg(args
, ¶m
, &val
);
213 if (!val
&& strcmp(param
, "--") == 0)
215 irq_was_disabled
= irqs_disabled();
216 ret
= parse_one(param
, val
, doing
, params
, num
,
217 min_level
, max_level
, unknown
);
218 if (irq_was_disabled
&& !irqs_disabled())
219 pr_warn("%s: option '%s' enabled irq's!\n",
224 pr_err("%s: Unknown parameter `%s'\n", doing
, param
);
227 pr_err("%s: `%s' too large for parameter `%s'\n",
228 doing
, val
?: "", param
);
233 pr_err("%s: `%s' invalid for parameter `%s'\n",
234 doing
, val
?: "", param
);
243 /* Lazy bastard, eh? */
244 #define STANDARD_PARAM_DEF(name, type, format, strtolfn) \
245 int param_set_##name(const char *val, const struct kernel_param *kp) \
247 return strtolfn(val, 0, (type *)kp->arg); \
249 int param_get_##name(char *buffer, const struct kernel_param *kp) \
251 return scnprintf(buffer, PAGE_SIZE, format, \
252 *((type *)kp->arg)); \
254 const struct kernel_param_ops param_ops_##name = { \
255 .set = param_set_##name, \
256 .get = param_get_##name, \
258 EXPORT_SYMBOL(param_set_##name); \
259 EXPORT_SYMBOL(param_get_##name); \
260 EXPORT_SYMBOL(param_ops_##name)
263 STANDARD_PARAM_DEF(byte
, unsigned char, "%hhu", kstrtou8
);
264 STANDARD_PARAM_DEF(short, short, "%hi", kstrtos16
);
265 STANDARD_PARAM_DEF(ushort
, unsigned short, "%hu", kstrtou16
);
266 STANDARD_PARAM_DEF(int, int, "%i", kstrtoint
);
267 STANDARD_PARAM_DEF(uint
, unsigned int, "%u", kstrtouint
);
268 STANDARD_PARAM_DEF(long, long, "%li", kstrtol
);
269 STANDARD_PARAM_DEF(ulong
, unsigned long, "%lu", kstrtoul
);
270 STANDARD_PARAM_DEF(ullong
, unsigned long long, "%llu", kstrtoull
);
272 int param_set_charp(const char *val
, const struct kernel_param
*kp
)
274 if (strlen(val
) > 1024) {
275 pr_err("%s: string parameter too long\n", kp
->name
);
279 maybe_kfree_parameter(*(char **)kp
->arg
);
281 /* This is a hack. We can't kmalloc in early boot, and we
282 * don't need to; this mangled commandline is preserved. */
283 if (slab_is_available()) {
284 *(char **)kp
->arg
= kmalloc_parameter(strlen(val
)+1);
285 if (!*(char **)kp
->arg
)
287 strcpy(*(char **)kp
->arg
, val
);
289 *(const char **)kp
->arg
= val
;
293 EXPORT_SYMBOL(param_set_charp
);
295 int param_get_charp(char *buffer
, const struct kernel_param
*kp
)
297 return scnprintf(buffer
, PAGE_SIZE
, "%s", *((char **)kp
->arg
));
299 EXPORT_SYMBOL(param_get_charp
);
301 static void param_free_charp(void *arg
)
303 maybe_kfree_parameter(*((char **)arg
));
306 const struct kernel_param_ops param_ops_charp
= {
307 .set
= param_set_charp
,
308 .get
= param_get_charp
,
309 .free
= param_free_charp
,
311 EXPORT_SYMBOL(param_ops_charp
);
313 /* Actually could be a bool or an int, for historical reasons. */
314 int param_set_bool(const char *val
, const struct kernel_param
*kp
)
316 /* No equals means "set"... */
319 /* One of =[yYnN01] */
320 return strtobool(val
, kp
->arg
);
322 EXPORT_SYMBOL(param_set_bool
);
324 int param_get_bool(char *buffer
, const struct kernel_param
*kp
)
326 /* Y and N chosen as being relatively non-coder friendly */
327 return sprintf(buffer
, "%c", *(bool *)kp
->arg
? 'Y' : 'N');
329 EXPORT_SYMBOL(param_get_bool
);
331 const struct kernel_param_ops param_ops_bool
= {
332 .flags
= KERNEL_PARAM_OPS_FL_NOARG
,
333 .set
= param_set_bool
,
334 .get
= param_get_bool
,
336 EXPORT_SYMBOL(param_ops_bool
);
338 int param_set_bool_enable_only(const char *val
, const struct kernel_param
*kp
)
342 bool orig_value
= *(bool *)kp
->arg
;
343 struct kernel_param dummy_kp
= *kp
;
345 dummy_kp
.arg
= &new_value
;
347 err
= param_set_bool(val
, &dummy_kp
);
351 /* Don't let them unset it once it's set! */
352 if (!new_value
&& orig_value
)
356 err
= param_set_bool(val
, kp
);
360 EXPORT_SYMBOL_GPL(param_set_bool_enable_only
);
362 const struct kernel_param_ops param_ops_bool_enable_only
= {
363 .flags
= KERNEL_PARAM_OPS_FL_NOARG
,
364 .set
= param_set_bool_enable_only
,
365 .get
= param_get_bool
,
368 /* This one must be bool. */
369 int param_set_invbool(const char *val
, const struct kernel_param
*kp
)
373 struct kernel_param dummy
;
375 dummy
.arg
= &boolval
;
376 ret
= param_set_bool(val
, &dummy
);
378 *(bool *)kp
->arg
= !boolval
;
381 EXPORT_SYMBOL(param_set_invbool
);
383 int param_get_invbool(char *buffer
, const struct kernel_param
*kp
)
385 return sprintf(buffer
, "%c", (*(bool *)kp
->arg
) ? 'N' : 'Y');
387 EXPORT_SYMBOL(param_get_invbool
);
389 const struct kernel_param_ops param_ops_invbool
= {
390 .set
= param_set_invbool
,
391 .get
= param_get_invbool
,
393 EXPORT_SYMBOL(param_ops_invbool
);
395 int param_set_bint(const char *val
, const struct kernel_param
*kp
)
397 struct kernel_param boolkp
;
401 /* Match bool exactly, by re-using it. */
405 ret
= param_set_bool(val
, &boolkp
);
410 EXPORT_SYMBOL(param_set_bint
);
412 const struct kernel_param_ops param_ops_bint
= {
413 .flags
= KERNEL_PARAM_OPS_FL_NOARG
,
414 .set
= param_set_bint
,
415 .get
= param_get_int
,
417 EXPORT_SYMBOL(param_ops_bint
);
419 /* We break the rule and mangle the string. */
420 static int param_array(const char *name
,
422 unsigned int min
, unsigned int max
,
423 void *elem
, int elemsize
,
424 int (*set
)(const char *, const struct kernel_param
*kp
),
429 struct kernel_param kp
;
432 /* Get the name right for errors. */
438 /* We expect a comma-separated list of values. */
443 pr_err("%s: can only take %i arguments\n", name
, max
);
446 len
= strcspn(val
, ",");
448 /* nul-terminate and parse */
450 ((char *)val
)[len
] = '\0';
451 BUG_ON(!mutex_is_locked(¶m_lock
));
459 } while (save
== ',');
462 pr_err("%s: needs at least %i arguments\n", name
, min
);
468 static int param_array_set(const char *val
, const struct kernel_param
*kp
)
470 const struct kparam_array
*arr
= kp
->arr
;
471 unsigned int temp_num
;
473 return param_array(kp
->name
, val
, 1, arr
->max
, arr
->elem
,
474 arr
->elemsize
, arr
->ops
->set
, kp
->level
,
475 arr
->num
?: &temp_num
);
478 static int param_array_get(char *buffer
, const struct kernel_param
*kp
)
481 const struct kparam_array
*arr
= kp
->arr
;
482 struct kernel_param p
;
485 for (i
= off
= 0; i
< (arr
->num
? *arr
->num
: arr
->max
); i
++) {
488 p
.arg
= arr
->elem
+ arr
->elemsize
* i
;
489 BUG_ON(!mutex_is_locked(¶m_lock
));
490 ret
= arr
->ops
->get(buffer
+ off
, &p
);
499 static void param_array_free(void *arg
)
502 const struct kparam_array
*arr
= arg
;
505 for (i
= 0; i
< (arr
->num
? *arr
->num
: arr
->max
); i
++)
506 arr
->ops
->free(arr
->elem
+ arr
->elemsize
* i
);
509 const struct kernel_param_ops param_array_ops
= {
510 .set
= param_array_set
,
511 .get
= param_array_get
,
512 .free
= param_array_free
,
514 EXPORT_SYMBOL(param_array_ops
);
516 int param_set_copystring(const char *val
, const struct kernel_param
*kp
)
518 const struct kparam_string
*kps
= kp
->str
;
520 if (strlen(val
)+1 > kps
->maxlen
) {
521 pr_err("%s: string doesn't fit in %u chars.\n",
522 kp
->name
, kps
->maxlen
-1);
525 strcpy(kps
->string
, val
);
528 EXPORT_SYMBOL(param_set_copystring
);
530 int param_get_string(char *buffer
, const struct kernel_param
*kp
)
532 const struct kparam_string
*kps
= kp
->str
;
533 return strlcpy(buffer
, kps
->string
, kps
->maxlen
);
535 EXPORT_SYMBOL(param_get_string
);
537 const struct kernel_param_ops param_ops_string
= {
538 .set
= param_set_copystring
,
539 .get
= param_get_string
,
541 EXPORT_SYMBOL(param_ops_string
);
543 /* sysfs output in /sys/modules/XYZ/parameters/ */
544 #define to_module_attr(n) container_of(n, struct module_attribute, attr)
545 #define to_module_kobject(n) container_of(n, struct module_kobject, kobj)
547 struct param_attribute
549 struct module_attribute mattr
;
550 const struct kernel_param
*param
;
553 struct module_param_attrs
556 struct attribute_group grp
;
557 struct param_attribute attrs
[0];
561 #define to_param_attr(n) container_of(n, struct param_attribute, mattr)
563 static ssize_t
param_attr_show(struct module_attribute
*mattr
,
564 struct module_kobject
*mk
, char *buf
)
567 struct param_attribute
*attribute
= to_param_attr(mattr
);
569 if (!attribute
->param
->ops
->get
)
572 mutex_lock(¶m_lock
);
573 count
= attribute
->param
->ops
->get(buf
, attribute
->param
);
574 mutex_unlock(¶m_lock
);
582 /* sysfs always hands a nul-terminated string in buf. We rely on that. */
583 static ssize_t
param_attr_store(struct module_attribute
*mattr
,
584 struct module_kobject
*km
,
585 const char *buf
, size_t len
)
588 struct param_attribute
*attribute
= to_param_attr(mattr
);
590 if (!attribute
->param
->ops
->set
)
593 mutex_lock(¶m_lock
);
594 param_check_unsafe(attribute
->param
);
595 err
= attribute
->param
->ops
->set(buf
, attribute
->param
);
596 mutex_unlock(¶m_lock
);
603 #ifdef CONFIG_MODULES
606 #define __modinit __init
610 void __kernel_param_lock(void)
612 mutex_lock(¶m_lock
);
614 EXPORT_SYMBOL(__kernel_param_lock
);
616 void __kernel_param_unlock(void)
618 mutex_unlock(¶m_lock
);
620 EXPORT_SYMBOL(__kernel_param_unlock
);
623 * add_sysfs_param - add a parameter to sysfs
624 * @mk: struct module_kobject
625 * @kparam: the actual parameter definition to add to sysfs
626 * @name: name of parameter
628 * Create a kobject if for a (per-module) parameter if mp NULL, and
629 * create file in sysfs. Returns an error on out of memory. Always cleans up
630 * if there's an error.
632 static __modinit
int add_sysfs_param(struct module_kobject
*mk
,
633 const struct kernel_param
*kp
,
636 struct module_param_attrs
*new_mp
;
637 struct attribute
**new_attrs
;
640 /* We don't bother calling this with invisible parameters. */
644 /* First allocation. */
645 mk
->mp
= kzalloc(sizeof(*mk
->mp
), GFP_KERNEL
);
648 mk
->mp
->grp
.name
= "parameters";
649 /* NULL-terminated attribute array. */
650 mk
->mp
->grp
.attrs
= kzalloc(sizeof(mk
->mp
->grp
.attrs
[0]),
652 /* Caller will cleanup via free_module_param_attrs */
653 if (!mk
->mp
->grp
.attrs
)
657 /* Enlarge allocations. */
658 new_mp
= krealloc(mk
->mp
,
660 sizeof(mk
->mp
->attrs
[0]) * (mk
->mp
->num
+ 1),
666 /* Extra pointer for NULL terminator */
667 new_attrs
= krealloc(mk
->mp
->grp
.attrs
,
668 sizeof(mk
->mp
->grp
.attrs
[0]) * (mk
->mp
->num
+ 2),
672 mk
->mp
->grp
.attrs
= new_attrs
;
674 /* Tack new one on the end. */
675 memset(&mk
->mp
->attrs
[mk
->mp
->num
], 0, sizeof(mk
->mp
->attrs
[0]));
676 sysfs_attr_init(&mk
->mp
->attrs
[mk
->mp
->num
].mattr
.attr
);
677 mk
->mp
->attrs
[mk
->mp
->num
].param
= kp
;
678 mk
->mp
->attrs
[mk
->mp
->num
].mattr
.show
= param_attr_show
;
679 /* Do not allow runtime DAC changes to make param writable. */
680 if ((kp
->perm
& (S_IWUSR
| S_IWGRP
| S_IWOTH
)) != 0)
681 mk
->mp
->attrs
[mk
->mp
->num
].mattr
.store
= param_attr_store
;
683 mk
->mp
->attrs
[mk
->mp
->num
].mattr
.store
= NULL
;
684 mk
->mp
->attrs
[mk
->mp
->num
].mattr
.attr
.name
= (char *)name
;
685 mk
->mp
->attrs
[mk
->mp
->num
].mattr
.attr
.mode
= kp
->perm
;
688 /* Fix up all the pointers, since krealloc can move us */
689 for (i
= 0; i
< mk
->mp
->num
; i
++)
690 mk
->mp
->grp
.attrs
[i
] = &mk
->mp
->attrs
[i
].mattr
.attr
;
691 mk
->mp
->grp
.attrs
[mk
->mp
->num
] = NULL
;
695 #ifdef CONFIG_MODULES
696 static void free_module_param_attrs(struct module_kobject
*mk
)
699 kfree(mk
->mp
->grp
.attrs
);
705 * module_param_sysfs_setup - setup sysfs support for one module
707 * @kparam: module parameters (array)
708 * @num_params: number of module parameters
710 * Adds sysfs entries for module parameters under
711 * /sys/module/[mod->name]/parameters/
713 int module_param_sysfs_setup(struct module
*mod
,
714 const struct kernel_param
*kparam
,
715 unsigned int num_params
)
720 for (i
= 0; i
< num_params
; i
++) {
721 if (kparam
[i
].perm
== 0)
723 err
= add_sysfs_param(&mod
->mkobj
, &kparam
[i
], kparam
[i
].name
);
725 free_module_param_attrs(&mod
->mkobj
);
734 /* Create the param group. */
735 err
= sysfs_create_group(&mod
->mkobj
.kobj
, &mod
->mkobj
.mp
->grp
);
737 free_module_param_attrs(&mod
->mkobj
);
742 * module_param_sysfs_remove - remove sysfs support for one module
745 * Remove sysfs entries for module parameters and the corresponding
748 void module_param_sysfs_remove(struct module
*mod
)
751 sysfs_remove_group(&mod
->mkobj
.kobj
, &mod
->mkobj
.mp
->grp
);
752 /* We are positive that no one is using any param
753 * attrs at this point. Deallocate immediately. */
754 free_module_param_attrs(&mod
->mkobj
);
759 void destroy_params(const struct kernel_param
*params
, unsigned num
)
763 for (i
= 0; i
< num
; i
++)
764 if (params
[i
].ops
->free
)
765 params
[i
].ops
->free(params
[i
].arg
);
768 static struct module_kobject
* __init
locate_module_kobject(const char *name
)
770 struct module_kobject
*mk
;
771 struct kobject
*kobj
;
774 kobj
= kset_find_obj(module_kset
, name
);
776 mk
= to_module_kobject(kobj
);
778 mk
= kzalloc(sizeof(struct module_kobject
), GFP_KERNEL
);
781 mk
->mod
= THIS_MODULE
;
782 mk
->kobj
.kset
= module_kset
;
783 err
= kobject_init_and_add(&mk
->kobj
, &module_ktype
, NULL
,
785 #ifdef CONFIG_MODULES
787 err
= sysfs_create_file(&mk
->kobj
, &module_uevent
.attr
);
790 kobject_put(&mk
->kobj
);
791 pr_crit("Adding module '%s' to sysfs failed (%d), the system may be unstable.\n",
796 /* So that we hold reference in both cases. */
797 kobject_get(&mk
->kobj
);
803 static void __init
kernel_add_sysfs_param(const char *name
,
804 const struct kernel_param
*kparam
,
805 unsigned int name_skip
)
807 struct module_kobject
*mk
;
810 mk
= locate_module_kobject(name
);
814 /* We need to remove old parameters before adding more. */
816 sysfs_remove_group(&mk
->kobj
, &mk
->mp
->grp
);
818 /* These should not fail at boot. */
819 err
= add_sysfs_param(mk
, kparam
, kparam
->name
+ name_skip
);
821 err
= sysfs_create_group(&mk
->kobj
, &mk
->mp
->grp
);
823 kobject_uevent(&mk
->kobj
, KOBJ_ADD
);
824 kobject_put(&mk
->kobj
);
828 * param_sysfs_builtin - add sysfs parameters for built-in modules
830 * Add module_parameters to sysfs for "modules" built into the kernel.
832 * The "module" name (KBUILD_MODNAME) is stored before a dot, the
833 * "parameter" name is stored behind a dot in kernel_param->name. So,
834 * extract the "module" name for all built-in kernel_param-eters,
835 * and for all who have the same, call kernel_add_sysfs_param.
837 static void __init
param_sysfs_builtin(void)
839 const struct kernel_param
*kp
;
840 unsigned int name_len
;
841 char modname
[MODULE_NAME_LEN
];
843 for (kp
= __start___param
; kp
< __stop___param
; kp
++) {
849 dot
= strchr(kp
->name
, '.');
851 /* This happens for core_param() */
852 strcpy(modname
, "kernel");
855 name_len
= dot
- kp
->name
+ 1;
856 strlcpy(modname
, kp
->name
, name_len
);
858 kernel_add_sysfs_param(modname
, kp
, name_len
);
862 ssize_t
__modver_version_show(struct module_attribute
*mattr
,
863 struct module_kobject
*mk
, char *buf
)
865 struct module_version_attribute
*vattr
=
866 container_of(mattr
, struct module_version_attribute
, mattr
);
868 return scnprintf(buf
, PAGE_SIZE
, "%s\n", vattr
->version
);
871 extern const struct module_version_attribute
*__start___modver
[];
872 extern const struct module_version_attribute
*__stop___modver
[];
874 static void __init
version_sysfs_builtin(void)
876 const struct module_version_attribute
**p
;
877 struct module_kobject
*mk
;
880 for (p
= __start___modver
; p
< __stop___modver
; p
++) {
881 const struct module_version_attribute
*vattr
= *p
;
883 mk
= locate_module_kobject(vattr
->module_name
);
885 err
= sysfs_create_file(&mk
->kobj
, &vattr
->mattr
.attr
);
886 kobject_uevent(&mk
->kobj
, KOBJ_ADD
);
887 kobject_put(&mk
->kobj
);
892 /* module-related sysfs stuff */
894 static ssize_t
module_attr_show(struct kobject
*kobj
,
895 struct attribute
*attr
,
898 struct module_attribute
*attribute
;
899 struct module_kobject
*mk
;
902 attribute
= to_module_attr(attr
);
903 mk
= to_module_kobject(kobj
);
905 if (!attribute
->show
)
908 ret
= attribute
->show(attribute
, mk
, buf
);
913 static ssize_t
module_attr_store(struct kobject
*kobj
,
914 struct attribute
*attr
,
915 const char *buf
, size_t len
)
917 struct module_attribute
*attribute
;
918 struct module_kobject
*mk
;
921 attribute
= to_module_attr(attr
);
922 mk
= to_module_kobject(kobj
);
924 if (!attribute
->store
)
927 ret
= attribute
->store(attribute
, mk
, buf
, len
);
932 static const struct sysfs_ops module_sysfs_ops
= {
933 .show
= module_attr_show
,
934 .store
= module_attr_store
,
937 static int uevent_filter(struct kset
*kset
, struct kobject
*kobj
)
939 struct kobj_type
*ktype
= get_ktype(kobj
);
941 if (ktype
== &module_ktype
)
946 static const struct kset_uevent_ops module_uevent_ops
= {
947 .filter
= uevent_filter
,
950 struct kset
*module_kset
;
951 int module_sysfs_initialized
;
953 static void module_kobj_release(struct kobject
*kobj
)
955 struct module_kobject
*mk
= to_module_kobject(kobj
);
956 complete(mk
->kobj_completion
);
959 struct kobj_type module_ktype
= {
960 .release
= module_kobj_release
,
961 .sysfs_ops
= &module_sysfs_ops
,
965 * param_sysfs_init - wrapper for built-in params support
967 static int __init
param_sysfs_init(void)
969 module_kset
= kset_create_and_add("module", &module_uevent_ops
, NULL
);
971 printk(KERN_WARNING
"%s (%d): error creating kset\n",
975 module_sysfs_initialized
= 1;
977 version_sysfs_builtin();
978 param_sysfs_builtin();
982 subsys_initcall(param_sysfs_init
);
984 #endif /* CONFIG_SYSFS */