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