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