ARM: Merge for-2635/samsung-hwmon
[linux-2.6-block.git] / kernel / params.c
CommitLineData
1da177e4
LT
1/* Helpers for initial module or kernel cmdline parsing
2 Copyright (C) 2001 Rusty Russell.
3
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.
8
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.
13
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
17*/
1da177e4
LT
18#include <linux/moduleparam.h>
19#include <linux/kernel.h>
20#include <linux/string.h>
21#include <linux/errno.h>
22#include <linux/module.h>
23#include <linux/device.h>
24#include <linux/err.h>
4e57b681 25#include <linux/slab.h>
26d052bf 26#include <linux/ctype.h>
1da177e4
LT
27
28#if 0
29#define DEBUGP printk
30#else
31#define DEBUGP(fmt, a...)
32#endif
33
b9e20a92 34static inline char dash2underscore(char c)
1da177e4
LT
35{
36 if (c == '-')
37 return '_';
38 return c;
39}
40
41static inline int parameq(const char *input, const char *paramname)
42{
43 unsigned int i;
44 for (i = 0; dash2underscore(input[i]) == paramname[i]; i++)
45 if (input[i] == '\0')
46 return 1;
47 return 0;
48}
49
50static int parse_one(char *param,
51 char *val,
52 struct kernel_param *params,
53 unsigned num_params,
54 int (*handle_unknown)(char *param, char *val))
55{
56 unsigned int i;
57
58 /* Find parameter */
59 for (i = 0; i < num_params; i++) {
60 if (parameq(param, params[i].name)) {
61 DEBUGP("They are equal! Calling %p\n",
62 params[i].set);
63 return params[i].set(val, &params[i]);
64 }
65 }
66
67 if (handle_unknown) {
68 DEBUGP("Unknown argument: calling %p\n", handle_unknown);
69 return handle_unknown(param, val);
70 }
71
72 DEBUGP("Unknown argument `%s'\n", param);
73 return -ENOENT;
74}
75
76/* You can use " around spaces, but can't escape ". */
77/* Hyphens and underscores equivalent in parameter names. */
78static char *next_arg(char *args, char **param, char **val)
79{
80 unsigned int i, equals = 0;
81 int in_quote = 0, quoted = 0;
82 char *next;
83
1da177e4
LT
84 if (*args == '"') {
85 args++;
86 in_quote = 1;
87 quoted = 1;
88 }
89
90 for (i = 0; args[i]; i++) {
26d052bf 91 if (isspace(args[i]) && !in_quote)
1da177e4
LT
92 break;
93 if (equals == 0) {
94 if (args[i] == '=')
95 equals = i;
96 }
97 if (args[i] == '"')
98 in_quote = !in_quote;
99 }
100
101 *param = args;
102 if (!equals)
103 *val = NULL;
104 else {
105 args[equals] = '\0';
106 *val = args + equals + 1;
107
108 /* Don't include quotes in value. */
109 if (**val == '"') {
110 (*val)++;
111 if (args[i-1] == '"')
112 args[i-1] = '\0';
113 }
114 if (quoted && args[i-1] == '"')
115 args[i-1] = '\0';
116 }
117
118 if (args[i]) {
119 args[i] = '\0';
120 next = args + i + 1;
121 } else
122 next = args + i;
f36462f0
RR
123
124 /* Chew up trailing spaces. */
e7d2860b 125 return skip_spaces(next);
1da177e4
LT
126}
127
128/* Args looks like "foo=bar,bar2 baz=fuz wiz". */
129int parse_args(const char *name,
130 char *args,
131 struct kernel_param *params,
132 unsigned num,
133 int (*unknown)(char *param, char *val))
134{
135 char *param, *val;
136
137 DEBUGP("Parsing ARGS: %s\n", args);
138
f36462f0 139 /* Chew leading spaces */
e7d2860b 140 args = skip_spaces(args);
f36462f0 141
1da177e4
LT
142 while (*args) {
143 int ret;
a416aba6 144 int irq_was_disabled;
1da177e4
LT
145
146 args = next_arg(args, &param, &val);
a416aba6 147 irq_was_disabled = irqs_disabled();
1da177e4 148 ret = parse_one(param, val, params, num, unknown);
a416aba6
AB
149 if (irq_was_disabled && !irqs_disabled()) {
150 printk(KERN_WARNING "parse_args(): option '%s' enabled "
151 "irq's!\n", param);
152 }
1da177e4
LT
153 switch (ret) {
154 case -ENOENT:
155 printk(KERN_ERR "%s: Unknown parameter `%s'\n",
156 name, param);
157 return ret;
158 case -ENOSPC:
159 printk(KERN_ERR
160 "%s: `%s' too large for parameter `%s'\n",
161 name, val ?: "", param);
162 return ret;
163 case 0:
164 break;
165 default:
166 printk(KERN_ERR
167 "%s: `%s' invalid for parameter `%s'\n",
168 name, val ?: "", param);
169 return ret;
170 }
171 }
172
173 /* All parsed OK. */
174 return 0;
175}
176
177/* Lazy bastard, eh? */
178#define STANDARD_PARAM_DEF(name, type, format, tmptype, strtolfn) \
179 int param_set_##name(const char *val, struct kernel_param *kp) \
180 { \
1da177e4 181 tmptype l; \
06b2a76d 182 int ret; \
1da177e4
LT
183 \
184 if (!val) return -EINVAL; \
06b2a76d
YY
185 ret = strtolfn(val, 0, &l); \
186 if (ret == -EINVAL || ((type)l != l)) \
1da177e4
LT
187 return -EINVAL; \
188 *((type *)kp->arg) = l; \
189 return 0; \
190 } \
191 int param_get_##name(char *buffer, struct kernel_param *kp) \
192 { \
193 return sprintf(buffer, format, *((type *)kp->arg)); \
194 }
195
06b2a76d
YY
196STANDARD_PARAM_DEF(byte, unsigned char, "%c", unsigned long, strict_strtoul);
197STANDARD_PARAM_DEF(short, short, "%hi", long, strict_strtol);
198STANDARD_PARAM_DEF(ushort, unsigned short, "%hu", unsigned long, strict_strtoul);
199STANDARD_PARAM_DEF(int, int, "%i", long, strict_strtol);
200STANDARD_PARAM_DEF(uint, unsigned int, "%u", unsigned long, strict_strtoul);
201STANDARD_PARAM_DEF(long, long, "%li", long, strict_strtol);
202STANDARD_PARAM_DEF(ulong, unsigned long, "%lu", unsigned long, strict_strtoul);
1da177e4
LT
203
204int param_set_charp(const char *val, struct kernel_param *kp)
205{
206 if (!val) {
207 printk(KERN_ERR "%s: string parameter expected\n",
208 kp->name);
209 return -EINVAL;
210 }
211
212 if (strlen(val) > 1024) {
213 printk(KERN_ERR "%s: string parameter too long\n",
214 kp->name);
215 return -ENOSPC;
216 }
217
e180a6b7
RR
218 /* This is a hack. We can't need to strdup in early boot, and we
219 * don't need to; this mangled commandline is preserved. */
220 if (slab_is_available()) {
e180a6b7 221 *(char **)kp->arg = kstrdup(val, GFP_KERNEL);
d553ad86 222 if (!*(char **)kp->arg)
e180a6b7
RR
223 return -ENOMEM;
224 } else
225 *(const char **)kp->arg = val;
226
1da177e4
LT
227 return 0;
228}
229
230int param_get_charp(char *buffer, struct kernel_param *kp)
231{
232 return sprintf(buffer, "%s", *((char **)kp->arg));
233}
234
fddd5201 235/* Actually could be a bool or an int, for historical reasons. */
1da177e4
LT
236int param_set_bool(const char *val, struct kernel_param *kp)
237{
fddd5201
RR
238 bool v;
239
1da177e4
LT
240 /* No equals means "set"... */
241 if (!val) val = "1";
242
243 /* One of =[yYnN01] */
244 switch (val[0]) {
245 case 'y': case 'Y': case '1':
fddd5201
RR
246 v = true;
247 break;
1da177e4 248 case 'n': case 'N': case '0':
fddd5201
RR
249 v = false;
250 break;
251 default:
252 return -EINVAL;
1da177e4 253 }
fddd5201
RR
254
255 if (kp->flags & KPARAM_ISBOOL)
256 *(bool *)kp->arg = v;
257 else
258 *(int *)kp->arg = v;
259 return 0;
1da177e4
LT
260}
261
262int param_get_bool(char *buffer, struct kernel_param *kp)
263{
fddd5201
RR
264 bool val;
265 if (kp->flags & KPARAM_ISBOOL)
266 val = *(bool *)kp->arg;
267 else
268 val = *(int *)kp->arg;
269
1da177e4 270 /* Y and N chosen as being relatively non-coder friendly */
fddd5201 271 return sprintf(buffer, "%c", val ? 'Y' : 'N');
1da177e4
LT
272}
273
fddd5201 274/* This one must be bool. */
1da177e4
LT
275int param_set_invbool(const char *val, struct kernel_param *kp)
276{
fddd5201
RR
277 int ret;
278 bool boolval;
22e48eaf 279 struct kernel_param dummy;
1da177e4 280
22e48eaf 281 dummy.arg = &boolval;
fddd5201 282 dummy.flags = KPARAM_ISBOOL;
1da177e4
LT
283 ret = param_set_bool(val, &dummy);
284 if (ret == 0)
9a71af2c 285 *(bool *)kp->arg = !boolval;
1da177e4
LT
286 return ret;
287}
288
289int param_get_invbool(char *buffer, struct kernel_param *kp)
290{
9a71af2c 291 return sprintf(buffer, "%c", (*(bool *)kp->arg) ? 'N' : 'Y');
1da177e4
LT
292}
293
9730b5b0 294/* We break the rule and mangle the string. */
9871728b
AB
295static int param_array(const char *name,
296 const char *val,
297 unsigned int min, unsigned int max,
298 void *elem, int elemsize,
299 int (*set)(const char *, struct kernel_param *kp),
3c7d76e3 300 u16 flags,
eb38a996 301 unsigned int *num)
1da177e4
LT
302{
303 int ret;
304 struct kernel_param kp;
305 char save;
306
307 /* Get the name right for errors. */
308 kp.name = name;
309 kp.arg = elem;
3c7d76e3 310 kp.flags = flags;
1da177e4
LT
311
312 /* No equals sign? */
313 if (!val) {
314 printk(KERN_ERR "%s: expects arguments\n", name);
315 return -EINVAL;
316 }
317
318 *num = 0;
319 /* We expect a comma-separated list of values. */
320 do {
321 int len;
322
323 if (*num == max) {
324 printk(KERN_ERR "%s: can only take %i arguments\n",
325 name, max);
326 return -EINVAL;
327 }
328 len = strcspn(val, ",");
329
330 /* nul-terminate and parse */
331 save = val[len];
332 ((char *)val)[len] = '\0';
333 ret = set(val, &kp);
334
335 if (ret != 0)
336 return ret;
337 kp.arg += elemsize;
338 val += len+1;
339 (*num)++;
340 } while (save == ',');
341
342 if (*num < min) {
343 printk(KERN_ERR "%s: needs at least %i arguments\n",
344 name, min);
345 return -EINVAL;
346 }
347 return 0;
348}
349
350int param_array_set(const char *val, struct kernel_param *kp)
351{
22e48eaf 352 const struct kparam_array *arr = kp->arr;
31143a12 353 unsigned int temp_num;
1da177e4
LT
354
355 return param_array(kp->name, val, 1, arr->max, arr->elem,
3c7d76e3
RR
356 arr->elemsize, arr->set, kp->flags,
357 arr->num ?: &temp_num);
1da177e4
LT
358}
359
360int param_array_get(char *buffer, struct kernel_param *kp)
361{
362 int i, off, ret;
22e48eaf 363 const struct kparam_array *arr = kp->arr;
1da177e4
LT
364 struct kernel_param p;
365
366 p = *kp;
367 for (i = off = 0; i < (arr->num ? *arr->num : arr->max); i++) {
368 if (i)
369 buffer[off++] = ',';
370 p.arg = arr->elem + arr->elemsize * i;
371 ret = arr->get(buffer + off, &p);
372 if (ret < 0)
373 return ret;
374 off += ret;
375 }
376 buffer[off] = '\0';
377 return off;
378}
379
380int param_set_copystring(const char *val, struct kernel_param *kp)
381{
22e48eaf 382 const struct kparam_string *kps = kp->str;
1da177e4 383
fe20e581
RD
384 if (!val) {
385 printk(KERN_ERR "%s: missing param set value\n", kp->name);
386 return -EINVAL;
387 }
1da177e4
LT
388 if (strlen(val)+1 > kps->maxlen) {
389 printk(KERN_ERR "%s: string doesn't fit in %u chars.\n",
390 kp->name, kps->maxlen-1);
391 return -ENOSPC;
392 }
393 strcpy(kps->string, val);
394 return 0;
395}
396
397int param_get_string(char *buffer, struct kernel_param *kp)
398{
22e48eaf 399 const struct kparam_string *kps = kp->str;
1da177e4
LT
400 return strlcpy(buffer, kps->string, kps->maxlen);
401}
402
403/* sysfs output in /sys/modules/XYZ/parameters/ */
350f8258
EY
404#define to_module_attr(n) container_of(n, struct module_attribute, attr)
405#define to_module_kobject(n) container_of(n, struct module_kobject, kobj)
1da177e4
LT
406
407extern struct kernel_param __start___param[], __stop___param[];
408
1da177e4
LT
409struct param_attribute
410{
411 struct module_attribute mattr;
412 struct kernel_param *param;
413};
414
415struct module_param_attrs
416{
9b473de8 417 unsigned int num;
1da177e4
LT
418 struct attribute_group grp;
419 struct param_attribute attrs[0];
420};
421
ef665c1a 422#ifdef CONFIG_SYSFS
350f8258 423#define to_param_attr(n) container_of(n, struct param_attribute, mattr)
1da177e4
LT
424
425static ssize_t param_attr_show(struct module_attribute *mattr,
426 struct module *mod, char *buf)
427{
428 int count;
429 struct param_attribute *attribute = to_param_attr(mattr);
430
431 if (!attribute->param->get)
432 return -EPERM;
433
434 count = attribute->param->get(buf, attribute->param);
435 if (count > 0) {
436 strcat(buf, "\n");
437 ++count;
438 }
439 return count;
440}
441
442/* sysfs always hands a nul-terminated string in buf. We rely on that. */
443static ssize_t param_attr_store(struct module_attribute *mattr,
444 struct module *owner,
445 const char *buf, size_t len)
446{
447 int err;
448 struct param_attribute *attribute = to_param_attr(mattr);
449
450 if (!attribute->param->set)
451 return -EPERM;
452
453 err = attribute->param->set(buf, attribute->param);
454 if (!err)
455 return len;
456 return err;
457}
ef665c1a 458#endif
1da177e4
LT
459
460#ifdef CONFIG_MODULES
461#define __modinit
462#else
463#define __modinit __init
464#endif
465
ef665c1a 466#ifdef CONFIG_SYSFS
1da177e4 467/*
9b473de8
RR
468 * add_sysfs_param - add a parameter to sysfs
469 * @mk: struct module_kobject
470 * @kparam: the actual parameter definition to add to sysfs
471 * @name: name of parameter
1da177e4 472 *
9b473de8
RR
473 * Create a kobject if for a (per-module) parameter if mp NULL, and
474 * create file in sysfs. Returns an error on out of memory. Always cleans up
475 * if there's an error.
1da177e4 476 */
9b473de8
RR
477static __modinit int add_sysfs_param(struct module_kobject *mk,
478 struct kernel_param *kp,
479 const char *name)
1da177e4 480{
9b473de8
RR
481 struct module_param_attrs *new;
482 struct attribute **attrs;
483 int err, num;
484
485 /* We don't bother calling this with invisible parameters. */
486 BUG_ON(!kp->perm);
487
488 if (!mk->mp) {
489 num = 0;
490 attrs = NULL;
491 } else {
492 num = mk->mp->num;
493 attrs = mk->mp->grp.attrs;
1da177e4
LT
494 }
495
9b473de8
RR
496 /* Enlarge. */
497 new = krealloc(mk->mp,
498 sizeof(*mk->mp) + sizeof(mk->mp->attrs[0]) * (num+1),
499 GFP_KERNEL);
500 if (!new) {
501 kfree(mk->mp);
502 err = -ENOMEM;
503 goto fail;
504 }
505 attrs = krealloc(attrs, sizeof(new->grp.attrs[0])*(num+2), GFP_KERNEL);
506 if (!attrs) {
507 err = -ENOMEM;
508 goto fail_free_new;
509 }
1da177e4 510
9b473de8
RR
511 /* Sysfs wants everything zeroed. */
512 memset(new, 0, sizeof(*new));
513 memset(&new->attrs[num], 0, sizeof(new->attrs[num]));
514 memset(&attrs[num], 0, sizeof(attrs[num]));
515 new->grp.name = "parameters";
516 new->grp.attrs = attrs;
517
518 /* Tack new one on the end. */
a07e4156 519 sysfs_attr_init(&new->attrs[num].mattr.attr);
9b473de8
RR
520 new->attrs[num].param = kp;
521 new->attrs[num].mattr.show = param_attr_show;
522 new->attrs[num].mattr.store = param_attr_store;
523 new->attrs[num].mattr.attr.name = (char *)name;
524 new->attrs[num].mattr.attr.mode = kp->perm;
525 new->num = num+1;
526
527 /* Fix up all the pointers, since krealloc can move us */
528 for (num = 0; num < new->num; num++)
529 new->grp.attrs[num] = &new->attrs[num].mattr.attr;
530 new->grp.attrs[num] = NULL;
531
532 mk->mp = new;
533 return 0;
1da177e4 534
9b473de8
RR
535fail_free_new:
536 kfree(new);
537fail:
538 mk->mp = NULL;
539 return err;
540}
1da177e4 541
d2441183 542#ifdef CONFIG_MODULES
9b473de8
RR
543static void free_module_param_attrs(struct module_kobject *mk)
544{
545 kfree(mk->mp->grp.attrs);
546 kfree(mk->mp);
547 mk->mp = NULL;
1da177e4
LT
548}
549
1da177e4
LT
550/*
551 * module_param_sysfs_setup - setup sysfs support for one module
552 * @mod: module
553 * @kparam: module parameters (array)
554 * @num_params: number of module parameters
555 *
9b473de8
RR
556 * Adds sysfs entries for module parameters under
557 * /sys/module/[mod->name]/parameters/
1da177e4
LT
558 */
559int module_param_sysfs_setup(struct module *mod,
560 struct kernel_param *kparam,
561 unsigned int num_params)
562{
9b473de8
RR
563 int i, err;
564 bool params = false;
565
566 for (i = 0; i < num_params; i++) {
567 if (kparam[i].perm == 0)
568 continue;
569 err = add_sysfs_param(&mod->mkobj, &kparam[i], kparam[i].name);
570 if (err)
571 return err;
572 params = true;
573 }
1da177e4 574
9b473de8
RR
575 if (!params)
576 return 0;
1da177e4 577
9b473de8
RR
578 /* Create the param group. */
579 err = sysfs_create_group(&mod->mkobj.kobj, &mod->mkobj.mp->grp);
580 if (err)
581 free_module_param_attrs(&mod->mkobj);
582 return err;
1da177e4
LT
583}
584
585/*
586 * module_param_sysfs_remove - remove sysfs support for one module
587 * @mod: module
588 *
589 * Remove sysfs entries for module parameters and the corresponding
590 * kobject.
591 */
592void module_param_sysfs_remove(struct module *mod)
593{
9b473de8
RR
594 if (mod->mkobj.mp) {
595 sysfs_remove_group(&mod->mkobj.kobj, &mod->mkobj.mp->grp);
1da177e4
LT
596 /* We are positive that no one is using any param
597 * attrs at this point. Deallocate immediately. */
9b473de8 598 free_module_param_attrs(&mod->mkobj);
1da177e4
LT
599 }
600}
601#endif
602
e180a6b7
RR
603void destroy_params(const struct kernel_param *params, unsigned num)
604{
65afac7d 605 /* FIXME: This should free kmalloced charp parameters. It doesn't. */
e180a6b7
RR
606}
607
9b473de8
RR
608static void __init kernel_add_sysfs_param(const char *name,
609 struct kernel_param *kparam,
610 unsigned int name_skip)
1da177e4
LT
611{
612 struct module_kobject *mk;
9b473de8
RR
613 struct kobject *kobj;
614 int err;
1da177e4 615
9b473de8
RR
616 kobj = kset_find_obj(module_kset, name);
617 if (kobj) {
618 /* We already have one. Remove params so we can add more. */
619 mk = to_module_kobject(kobj);
620 /* We need to remove it before adding parameters. */
621 sysfs_remove_group(&mk->kobj, &mk->mp->grp);
622 } else {
623 mk = kzalloc(sizeof(struct module_kobject), GFP_KERNEL);
624 BUG_ON(!mk);
625
626 mk->mod = THIS_MODULE;
627 mk->kobj.kset = module_kset;
628 err = kobject_init_and_add(&mk->kobj, &module_ktype, NULL,
629 "%s", name);
630 if (err) {
631 kobject_put(&mk->kobj);
632 printk(KERN_ERR "Module '%s' failed add to sysfs, "
633 "error number %d\n", name, err);
634 printk(KERN_ERR "The system will be unstable now.\n");
635 return;
636 }
637 /* So that exit path is even. */
638 kobject_get(&mk->kobj);
74c5b597 639 }
9b473de8
RR
640
641 /* These should not fail at boot. */
642 err = add_sysfs_param(mk, kparam, kparam->name + name_skip);
643 BUG_ON(err);
644 err = sysfs_create_group(&mk->kobj, &mk->mp->grp);
645 BUG_ON(err);
f30c53a8 646 kobject_uevent(&mk->kobj, KOBJ_ADD);
9b473de8 647 kobject_put(&mk->kobj);
1da177e4
LT
648}
649
650/*
651 * param_sysfs_builtin - add contents in /sys/parameters for built-in modules
652 *
653 * Add module_parameters to sysfs for "modules" built into the kernel.
654 *
655 * The "module" name (KBUILD_MODNAME) is stored before a dot, the
656 * "parameter" name is stored behind a dot in kernel_param->name. So,
657 * extract the "module" name for all built-in kernel_param-eters,
9b473de8 658 * and for all who have the same, call kernel_add_sysfs_param.
1da177e4
LT
659 */
660static void __init param_sysfs_builtin(void)
661{
9b473de8
RR
662 struct kernel_param *kp;
663 unsigned int name_len;
664 char modname[MODULE_NAME_LEN];
1da177e4 665
9b473de8 666 for (kp = __start___param; kp < __stop___param; kp++) {
1da177e4
LT
667 char *dot;
668
9b473de8
RR
669 if (kp->perm == 0)
670 continue;
1da177e4 671
730b69d2 672 dot = strchr(kp->name, '.');
1da177e4 673 if (!dot) {
67e67cea
RR
674 /* This happens for core_param() */
675 strcpy(modname, "kernel");
676 name_len = 0;
677 } else {
678 name_len = dot - kp->name + 1;
679 strlcpy(modname, kp->name, name_len);
1da177e4 680 }
67e67cea 681 kernel_add_sysfs_param(modname, kp, name_len);
1da177e4 682 }
1da177e4
LT
683}
684
685
686/* module-related sysfs stuff */
1da177e4 687
1da177e4
LT
688static ssize_t module_attr_show(struct kobject *kobj,
689 struct attribute *attr,
690 char *buf)
691{
692 struct module_attribute *attribute;
693 struct module_kobject *mk;
694 int ret;
695
696 attribute = to_module_attr(attr);
697 mk = to_module_kobject(kobj);
698
699 if (!attribute->show)
70f2817a 700 return -EIO;
1da177e4 701
1da177e4
LT
702 ret = attribute->show(attribute, mk->mod, buf);
703
1da177e4
LT
704 return ret;
705}
706
707static ssize_t module_attr_store(struct kobject *kobj,
708 struct attribute *attr,
709 const char *buf, size_t len)
710{
711 struct module_attribute *attribute;
712 struct module_kobject *mk;
713 int ret;
714
715 attribute = to_module_attr(attr);
716 mk = to_module_kobject(kobj);
717
718 if (!attribute->store)
70f2817a 719 return -EIO;
1da177e4 720
1da177e4
LT
721 ret = attribute->store(attribute, mk->mod, buf, len);
722
1da177e4
LT
723 return ret;
724}
725
52cf25d0 726static const struct sysfs_ops module_sysfs_ops = {
1da177e4
LT
727 .show = module_attr_show,
728 .store = module_attr_store,
729};
730
270a6c4c
KS
731static int uevent_filter(struct kset *kset, struct kobject *kobj)
732{
733 struct kobj_type *ktype = get_ktype(kobj);
734
735 if (ktype == &module_ktype)
736 return 1;
737 return 0;
738}
739
9cd43611 740static const struct kset_uevent_ops module_uevent_ops = {
270a6c4c
KS
741 .filter = uevent_filter,
742};
743
7405c1e1 744struct kset *module_kset;
823bccfc 745int module_sysfs_initialized;
1da177e4 746
7405c1e1 747struct kobj_type module_ktype = {
1da177e4
LT
748 .sysfs_ops = &module_sysfs_ops,
749};
750
1da177e4
LT
751/*
752 * param_sysfs_init - wrapper for built-in params support
753 */
754static int __init param_sysfs_init(void)
755{
7405c1e1
GKH
756 module_kset = kset_create_and_add("module", &module_uevent_ops, NULL);
757 if (!module_kset) {
758 printk(KERN_WARNING "%s (%d): error creating kset\n",
759 __FILE__, __LINE__);
760 return -ENOMEM;
d8c7649e 761 }
823bccfc 762 module_sysfs_initialized = 1;
1da177e4
LT
763
764 param_sysfs_builtin();
765
766 return 0;
767}
d10be6d1 768subsys_initcall(param_sysfs_init);
1da177e4 769
7405c1e1 770#endif /* CONFIG_SYSFS */
ef665c1a 771
1da177e4
LT
772EXPORT_SYMBOL(param_set_byte);
773EXPORT_SYMBOL(param_get_byte);
774EXPORT_SYMBOL(param_set_short);
775EXPORT_SYMBOL(param_get_short);
776EXPORT_SYMBOL(param_set_ushort);
777EXPORT_SYMBOL(param_get_ushort);
778EXPORT_SYMBOL(param_set_int);
779EXPORT_SYMBOL(param_get_int);
780EXPORT_SYMBOL(param_set_uint);
781EXPORT_SYMBOL(param_get_uint);
782EXPORT_SYMBOL(param_set_long);
783EXPORT_SYMBOL(param_get_long);
784EXPORT_SYMBOL(param_set_ulong);
785EXPORT_SYMBOL(param_get_ulong);
786EXPORT_SYMBOL(param_set_charp);
787EXPORT_SYMBOL(param_get_charp);
788EXPORT_SYMBOL(param_set_bool);
789EXPORT_SYMBOL(param_get_bool);
790EXPORT_SYMBOL(param_set_invbool);
791EXPORT_SYMBOL(param_get_invbool);
792EXPORT_SYMBOL(param_array_set);
793EXPORT_SYMBOL(param_array_get);
794EXPORT_SYMBOL(param_set_copystring);
795EXPORT_SYMBOL(param_get_string);