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