Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/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 void param_free_charp(void *arg)
330 {
331         maybe_kfree_parameter(*((char **)arg));
332 }
333 EXPORT_SYMBOL(param_free_charp);
334 
335 const struct kernel_param_ops param_ops_charp = {
336         .set = param_set_charp,
337         .get = param_get_charp,
338         .free = param_free_charp,
339 };
340 EXPORT_SYMBOL(param_ops_charp);
341 
342 /* Actually could be a bool or an int, for historical reasons. */
343 int param_set_bool(const char *val, const struct kernel_param *kp)
344 {
345         /* No equals means "set"... */
346         if (!val) val = "1";
347 
348         /* One of =[yYnN01] */
349         return strtobool(val, kp->arg);
350 }
351 EXPORT_SYMBOL(param_set_bool);
352 
353 int param_get_bool(char *buffer, const struct kernel_param *kp)
354 {
355         /* Y and N chosen as being relatively non-coder friendly */
356         return sprintf(buffer, "%c", *(bool *)kp->arg ? 'Y' : 'N');
357 }
358 EXPORT_SYMBOL(param_get_bool);
359 
360 const struct kernel_param_ops param_ops_bool = {
361         .flags = KERNEL_PARAM_OPS_FL_NOARG,
362         .set = param_set_bool,
363         .get = param_get_bool,
364 };
365 EXPORT_SYMBOL(param_ops_bool);
366 
367 int param_set_bool_enable_only(const char *val, const struct kernel_param *kp)
368 {
369         int err = 0;
370         bool new_value;
371         bool orig_value = *(bool *)kp->arg;
372         struct kernel_param dummy_kp = *kp;
373 
374         dummy_kp.arg = &new_value;
375 
376         err = param_set_bool(val, &dummy_kp);
377         if (err)
378                 return err;
379 
380         /* Don't let them unset it once it's set! */
381         if (!new_value && orig_value)
382                 return -EROFS;
383 
384         if (new_value)
385                 err = param_set_bool(val, kp);
386 
387         return err;
388 }
389 EXPORT_SYMBOL_GPL(param_set_bool_enable_only);
390 
391 const struct kernel_param_ops param_ops_bool_enable_only = {
392         .flags = KERNEL_PARAM_OPS_FL_NOARG,
393         .set = param_set_bool_enable_only,
394         .get = param_get_bool,
395 };
396 EXPORT_SYMBOL_GPL(param_ops_bool_enable_only);
397 
398 /* This one must be bool. */
399 int param_set_invbool(const char *val, const struct kernel_param *kp)
400 {
401         int ret;
402         bool boolval;
403         struct kernel_param dummy;
404 
405         dummy.arg = &boolval;
406         ret = param_set_bool(val, &dummy);
407         if (ret == 0)
408                 *(bool *)kp->arg = !boolval;
409         return ret;
410 }
411 EXPORT_SYMBOL(param_set_invbool);
412 
413 int param_get_invbool(char *buffer, const struct kernel_param *kp)
414 {
415         return sprintf(buffer, "%c", (*(bool *)kp->arg) ? 'N' : 'Y');
416 }
417 EXPORT_SYMBOL(param_get_invbool);
418 
419 const struct kernel_param_ops param_ops_invbool = {
420         .set = param_set_invbool,
421         .get = param_get_invbool,
422 };
423 EXPORT_SYMBOL(param_ops_invbool);
424 
425 int param_set_bint(const char *val, const struct kernel_param *kp)
426 {
427         /* Match bool exactly, by re-using it. */
428         struct kernel_param boolkp = *kp;
429         bool v;
430         int ret;
431 
432         boolkp.arg = &v;
433 
434         ret = param_set_bool(val, &boolkp);
435         if (ret == 0)
436                 *(int *)kp->arg = v;
437         return ret;
438 }
439 EXPORT_SYMBOL(param_set_bint);
440 
441 const struct kernel_param_ops param_ops_bint = {
442         .flags = KERNEL_PARAM_OPS_FL_NOARG,
443         .set = param_set_bint,
444         .get = param_get_int,
445 };
446 EXPORT_SYMBOL(param_ops_bint);
447 
448 /* We break the rule and mangle the string. */
449 static int param_array(struct module *mod,
450                        const char *name,
451                        const char *val,
452                        unsigned int min, unsigned int max,
453                        void *elem, int elemsize,
454                        int (*set)(const char *, const struct kernel_param *kp),
455                        s16 level,
456                        unsigned int *num)
457 {
458         int ret;
459         struct kernel_param kp;
460         char save;
461 
462         /* Get the name right for errors. */
463         kp.name = name;
464         kp.arg = elem;
465         kp.level = level;
466 
467         *num = 0;
468         /* We expect a comma-separated list of values. */
469         do {
470                 int len;
471 
472                 if (*num == max) {
473                         pr_err("%s: can only take %i arguments\n", name, max);
474                         return -EINVAL;
475                 }
476                 len = strcspn(val, ",");
477 
478                 /* nul-terminate and parse */
479                 save = val[len];
480                 ((char *)val)[len] = '\0';
481                 check_kparam_locked(mod);
482                 ret = set(val, &kp);
483 
484                 if (ret != 0)
485                         return ret;
486                 kp.arg += elemsize;
487                 val += len+1;
488                 (*num)++;
489         } while (save == ',');
490 
491         if (*num < min) {
492                 pr_err("%s: needs at least %i arguments\n", name, min);
493                 return -EINVAL;
494         }
495         return 0;
496 }
497 
498 static int param_array_set(const char *val, const struct kernel_param *kp)
499 {
500         const struct kparam_array *arr = kp->arr;
501         unsigned int temp_num;
502 
503         return param_array(kp->mod, kp->name, val, 1, arr->max, arr->elem,
504                            arr->elemsize, arr->ops->set, kp->level,
505                            arr->num ?: &temp_num);
506 }
507 
508 static int param_array_get(char *buffer, const struct kernel_param *kp)
509 {
510         int i, off, ret;
511         const struct kparam_array *arr = kp->arr;
512         struct kernel_param p = *kp;
513 
514         for (i = off = 0; i < (arr->num ? *arr->num : arr->max); i++) {
515                 if (i)
516                         buffer[off++] = ',';
517                 p.arg = arr->elem + arr->elemsize * i;
518                 check_kparam_locked(p.mod);
519                 ret = arr->ops->get(buffer + off, &p);
520                 if (ret < 0)
521                         return ret;
522                 off += ret;
523         }
524         buffer[off] = '\0';
525         return off;
526 }
527 
528 static void param_array_free(void *arg)
529 {
530         unsigned int i;
531         const struct kparam_array *arr = arg;
532 
533         if (arr->ops->free)
534                 for (i = 0; i < (arr->num ? *arr->num : arr->max); i++)
535                         arr->ops->free(arr->elem + arr->elemsize * i);
536 }
537 
538 const struct kernel_param_ops param_array_ops = {
539         .set = param_array_set,
540         .get = param_array_get,
541         .free = param_array_free,
542 };
543 EXPORT_SYMBOL(param_array_ops);
544 
545 int param_set_copystring(const char *val, const struct kernel_param *kp)
546 {
547         const struct kparam_string *kps = kp->str;
548 
549         if (strlen(val)+1 > kps->maxlen) {
550                 pr_err("%s: string doesn't fit in %u chars.\n",
551                        kp->name, kps->maxlen-1);
552                 return -ENOSPC;
553         }
554         strcpy(kps->string, val);
555         return 0;
556 }
557 EXPORT_SYMBOL(param_set_copystring);
558 
559 int param_get_string(char *buffer, const struct kernel_param *kp)
560 {
561         const struct kparam_string *kps = kp->str;
562         return strlcpy(buffer, kps->string, kps->maxlen);
563 }
564 EXPORT_SYMBOL(param_get_string);
565 
566 const struct kernel_param_ops param_ops_string = {
567         .set = param_set_copystring,
568         .get = param_get_string,
569 };
570 EXPORT_SYMBOL(param_ops_string);
571 
572 /* sysfs output in /sys/modules/XYZ/parameters/ */
573 #define to_module_attr(n) container_of(n, struct module_attribute, attr)
574 #define to_module_kobject(n) container_of(n, struct module_kobject, kobj)
575 
576 struct param_attribute
577 {
578         struct module_attribute mattr;
579         const struct kernel_param *param;
580 };
581 
582 struct module_param_attrs
583 {
584         unsigned int num;
585         struct attribute_group grp;
586         struct param_attribute attrs[0];
587 };
588 
589 #ifdef CONFIG_SYSFS
590 #define to_param_attr(n) container_of(n, struct param_attribute, mattr)
591 
592 static ssize_t param_attr_show(struct module_attribute *mattr,
593                                struct module_kobject *mk, char *buf)
594 {
595         int count;
596         struct param_attribute *attribute = to_param_attr(mattr);
597 
598         if (!attribute->param->ops->get)
599                 return -EPERM;
600 
601         kernel_param_lock(mk->mod);
602         count = attribute->param->ops->get(buf, attribute->param);
603         kernel_param_unlock(mk->mod);
604         if (count > 0) {
605                 strcat(buf, "\n");
606                 ++count;
607         }
608         return count;
609 }
610 
611 /* sysfs always hands a nul-terminated string in buf.  We rely on that. */
612 static ssize_t param_attr_store(struct module_attribute *mattr,
613                                 struct module_kobject *mk,
614                                 const char *buf, size_t len)
615 {
616         int err;
617         struct param_attribute *attribute = to_param_attr(mattr);
618 
619         if (!attribute->param->ops->set)
620                 return -EPERM;
621 
622         kernel_param_lock(mk->mod);
623         param_check_unsafe(attribute->param);
624         err = attribute->param->ops->set(buf, attribute->param);
625         kernel_param_unlock(mk->mod);
626         if (!err)
627                 return len;
628         return err;
629 }
630 #endif
631 
632 #ifdef CONFIG_MODULES
633 #define __modinit
634 #else
635 #define __modinit __init
636 #endif
637 
638 #ifdef CONFIG_SYSFS
639 void kernel_param_lock(struct module *mod)
640 {
641         mutex_lock(KPARAM_MUTEX(mod));
642 }
643 
644 void kernel_param_unlock(struct module *mod)
645 {
646         mutex_unlock(KPARAM_MUTEX(mod));
647 }
648 
649 EXPORT_SYMBOL(kernel_param_lock);
650 EXPORT_SYMBOL(kernel_param_unlock);
651 
652 /*
653  * add_sysfs_param - add a parameter to sysfs
654  * @mk: struct module_kobject
655  * @kparam: the actual parameter definition to add to sysfs
656  * @name: name of parameter
657  *
658  * Create a kobject if for a (per-module) parameter if mp NULL, and
659  * create file in sysfs.  Returns an error on out of memory.  Always cleans up
660  * if there's an error.
661  */
662 static __modinit int add_sysfs_param(struct module_kobject *mk,
663                                      const struct kernel_param *kp,
664                                      const char *name)
665 {
666         struct module_param_attrs *new_mp;
667         struct attribute **new_attrs;
668         unsigned int i;
669 
670         /* We don't bother calling this with invisible parameters. */
671         BUG_ON(!kp->perm);
672 
673         if (!mk->mp) {
674                 /* First allocation. */
675                 mk->mp = kzalloc(sizeof(*mk->mp), GFP_KERNEL);
676                 if (!mk->mp)
677                         return -ENOMEM;
678                 mk->mp->grp.name = "parameters";
679                 /* NULL-terminated attribute array. */
680                 mk->mp->grp.attrs = kzalloc(sizeof(mk->mp->grp.attrs[0]),
681                                             GFP_KERNEL);
682                 /* Caller will cleanup via free_module_param_attrs */
683                 if (!mk->mp->grp.attrs)
684                         return -ENOMEM;
685         }
686 
687         /* Enlarge allocations. */
688         new_mp = krealloc(mk->mp,
689                           sizeof(*mk->mp) +
690                           sizeof(mk->mp->attrs[0]) * (mk->mp->num + 1),
691                           GFP_KERNEL);
692         if (!new_mp)
693                 return -ENOMEM;
694         mk->mp = new_mp;
695 
696         /* Extra pointer for NULL terminator */
697         new_attrs = krealloc(mk->mp->grp.attrs,
698                              sizeof(mk->mp->grp.attrs[0]) * (mk->mp->num + 2),
699                              GFP_KERNEL);
700         if (!new_attrs)
701                 return -ENOMEM;
702         mk->mp->grp.attrs = new_attrs;
703 
704         /* Tack new one on the end. */
705         memset(&mk->mp->attrs[mk->mp->num], 0, sizeof(mk->mp->attrs[0]));
706         sysfs_attr_init(&mk->mp->attrs[mk->mp->num].mattr.attr);
707         mk->mp->attrs[mk->mp->num].param = kp;
708         mk->mp->attrs[mk->mp->num].mattr.show = param_attr_show;
709         /* Do not allow runtime DAC changes to make param writable. */
710         if ((kp->perm & (S_IWUSR | S_IWGRP | S_IWOTH)) != 0)
711                 mk->mp->attrs[mk->mp->num].mattr.store = param_attr_store;
712         else
713                 mk->mp->attrs[mk->mp->num].mattr.store = NULL;
714         mk->mp->attrs[mk->mp->num].mattr.attr.name = (char *)name;
715         mk->mp->attrs[mk->mp->num].mattr.attr.mode = kp->perm;
716         mk->mp->num++;
717 
718         /* Fix up all the pointers, since krealloc can move us */
719         for (i = 0; i < mk->mp->num; i++)
720                 mk->mp->grp.attrs[i] = &mk->mp->attrs[i].mattr.attr;
721         mk->mp->grp.attrs[mk->mp->num] = NULL;
722         return 0;
723 }
724 
725 #ifdef CONFIG_MODULES
726 static void free_module_param_attrs(struct module_kobject *mk)
727 {
728         if (mk->mp)
729                 kfree(mk->mp->grp.attrs);
730         kfree(mk->mp);
731         mk->mp = NULL;
732 }
733 
734 /*
735  * module_param_sysfs_setup - setup sysfs support for one module
736  * @mod: module
737  * @kparam: module parameters (array)
738  * @num_params: number of module parameters
739  *
740  * Adds sysfs entries for module parameters under
741  * /sys/module/[mod->name]/parameters/
742  */
743 int module_param_sysfs_setup(struct module *mod,
744                              const struct kernel_param *kparam,
745                              unsigned int num_params)
746 {
747         int i, err;
748         bool params = false;
749 
750         for (i = 0; i < num_params; i++) {
751                 if (kparam[i].perm == 0)
752                         continue;
753                 err = add_sysfs_param(&mod->mkobj, &kparam[i], kparam[i].name);
754                 if (err) {
755                         free_module_param_attrs(&mod->mkobj);
756                         return err;
757                 }
758                 params = true;
759         }
760 
761         if (!params)
762                 return 0;
763 
764         /* Create the param group. */
765         err = sysfs_create_group(&mod->mkobj.kobj, &mod->mkobj.mp->grp);
766         if (err)
767                 free_module_param_attrs(&mod->mkobj);
768         return err;
769 }
770 
771 /*
772  * module_param_sysfs_remove - remove sysfs support for one module
773  * @mod: module
774  *
775  * Remove sysfs entries for module parameters and the corresponding
776  * kobject.
777  */
778 void module_param_sysfs_remove(struct module *mod)
779 {
780         if (mod->mkobj.mp) {
781                 sysfs_remove_group(&mod->mkobj.kobj, &mod->mkobj.mp->grp);
782                 /* We are positive that no one is using any param
783                  * attrs at this point.  Deallocate immediately. */
784                 free_module_param_attrs(&mod->mkobj);
785         }
786 }
787 #endif
788 
789 void destroy_params(const struct kernel_param *params, unsigned num)
790 {
791         unsigned int i;
792 
793         for (i = 0; i < num; i++)
794                 if (params[i].ops->free)
795                         params[i].ops->free(params[i].arg);
796 }
797 
798 static struct module_kobject * __init locate_module_kobject(const char *name)
799 {
800         struct module_kobject *mk;
801         struct kobject *kobj;
802         int err;
803 
804         kobj = kset_find_obj(module_kset, name);
805         if (kobj) {
806                 mk = to_module_kobject(kobj);
807         } else {
808                 mk = kzalloc(sizeof(struct module_kobject), GFP_KERNEL);
809                 BUG_ON(!mk);
810 
811                 mk->mod = THIS_MODULE;
812                 mk->kobj.kset = module_kset;
813                 err = kobject_init_and_add(&mk->kobj, &module_ktype, NULL,
814                                            "%s", name);
815 #ifdef CONFIG_MODULES
816                 if (!err)
817                         err = sysfs_create_file(&mk->kobj, &module_uevent.attr);
818 #endif
819                 if (err) {
820                         kobject_put(&mk->kobj);
821                         pr_crit("Adding module '%s' to sysfs failed (%d), the system may be unstable.\n",
822                                 name, err);
823                         return NULL;
824                 }
825 
826                 /* So that we hold reference in both cases. */
827                 kobject_get(&mk->kobj);
828         }
829 
830         return mk;
831 }
832 
833 static void __init kernel_add_sysfs_param(const char *name,
834                                           const struct kernel_param *kparam,
835                                           unsigned int name_skip)
836 {
837         struct module_kobject *mk;
838         int err;
839 
840         mk = locate_module_kobject(name);
841         if (!mk)
842                 return;
843 
844         /* We need to remove old parameters before adding more. */
845         if (mk->mp)
846                 sysfs_remove_group(&mk->kobj, &mk->mp->grp);
847 
848         /* These should not fail at boot. */
849         err = add_sysfs_param(mk, kparam, kparam->name + name_skip);
850         BUG_ON(err);
851         err = sysfs_create_group(&mk->kobj, &mk->mp->grp);
852         BUG_ON(err);
853         kobject_uevent(&mk->kobj, KOBJ_ADD);
854         kobject_put(&mk->kobj);
855 }
856 
857 /*
858  * param_sysfs_builtin - add sysfs parameters for built-in modules
859  *
860  * Add module_parameters to sysfs for "modules" built into the kernel.
861  *
862  * The "module" name (KBUILD_MODNAME) is stored before a dot, the
863  * "parameter" name is stored behind a dot in kernel_param->name. So,
864  * extract the "module" name for all built-in kernel_param-eters,
865  * and for all who have the same, call kernel_add_sysfs_param.
866  */
867 static void __init param_sysfs_builtin(void)
868 {
869         const struct kernel_param *kp;
870         unsigned int name_len;
871         char modname[MODULE_NAME_LEN];
872 
873         for (kp = __start___param; kp < __stop___param; kp++) {
874                 char *dot;
875 
876                 if (kp->perm == 0)
877                         continue;
878 
879                 dot = strchr(kp->name, '.');
880                 if (!dot) {
881                         /* This happens for core_param() */
882                         strcpy(modname, "kernel");
883                         name_len = 0;
884                 } else {
885                         name_len = dot - kp->name + 1;
886                         strlcpy(modname, kp->name, name_len);
887                 }
888                 kernel_add_sysfs_param(modname, kp, name_len);
889         }
890 }
891 
892 ssize_t __modver_version_show(struct module_attribute *mattr,
893                               struct module_kobject *mk, char *buf)
894 {
895         struct module_version_attribute *vattr =
896                 container_of(mattr, struct module_version_attribute, mattr);
897 
898         return scnprintf(buf, PAGE_SIZE, "%s\n", vattr->version);
899 }
900 
901 extern const struct module_version_attribute *__start___modver[];
902 extern const struct module_version_attribute *__stop___modver[];
903 
904 static void __init version_sysfs_builtin(void)
905 {
906         const struct module_version_attribute **p;
907         struct module_kobject *mk;
908         int err;
909 
910         for (p = __start___modver; p < __stop___modver; p++) {
911                 const struct module_version_attribute *vattr = *p;
912 
913                 mk = locate_module_kobject(vattr->module_name);
914                 if (mk) {
915                         err = sysfs_create_file(&mk->kobj, &vattr->mattr.attr);
916                         WARN_ON_ONCE(err);
917                         kobject_uevent(&mk->kobj, KOBJ_ADD);
918                         kobject_put(&mk->kobj);
919                 }
920         }
921 }
922 
923 /* module-related sysfs stuff */
924 
925 static ssize_t module_attr_show(struct kobject *kobj,
926                                 struct attribute *attr,
927                                 char *buf)
928 {
929         struct module_attribute *attribute;
930         struct module_kobject *mk;
931         int ret;
932 
933         attribute = to_module_attr(attr);
934         mk = to_module_kobject(kobj);
935 
936         if (!attribute->show)
937                 return -EIO;
938 
939         ret = attribute->show(attribute, mk, buf);
940 
941         return ret;
942 }
943 
944 static ssize_t module_attr_store(struct kobject *kobj,
945                                 struct attribute *attr,
946                                 const char *buf, size_t len)
947 {
948         struct module_attribute *attribute;
949         struct module_kobject *mk;
950         int ret;
951 
952         attribute = to_module_attr(attr);
953         mk = to_module_kobject(kobj);
954 
955         if (!attribute->store)
956                 return -EIO;
957 
958         ret = attribute->store(attribute, mk, buf, len);
959 
960         return ret;
961 }
962 
963 static const struct sysfs_ops module_sysfs_ops = {
964         .show = module_attr_show,
965         .store = module_attr_store,
966 };
967 
968 static int uevent_filter(struct kset *kset, struct kobject *kobj)
969 {
970         struct kobj_type *ktype = get_ktype(kobj);
971 
972         if (ktype == &module_ktype)
973                 return 1;
974         return 0;
975 }
976 
977 static const struct kset_uevent_ops module_uevent_ops = {
978         .filter = uevent_filter,
979 };
980 
981 struct kset *module_kset;
982 int module_sysfs_initialized;
983 
984 static void module_kobj_release(struct kobject *kobj)
985 {
986         struct module_kobject *mk = to_module_kobject(kobj);
987         complete(mk->kobj_completion);
988 }
989 
990 struct kobj_type module_ktype = {
991         .release   =    module_kobj_release,
992         .sysfs_ops =    &module_sysfs_ops,
993 };
994 
995 /*
996  * param_sysfs_init - wrapper for built-in params support
997  */
998 static int __init param_sysfs_init(void)
999 {
1000         module_kset = kset_create_and_add("module", &module_uevent_ops, NULL);
1001         if (!module_kset) {
1002                 printk(KERN_WARNING "%s (%d): error creating kset\n",
1003                         __FILE__, __LINE__);
1004                 return -ENOMEM;
1005         }
1006         module_sysfs_initialized = 1;
1007 
1008         version_sysfs_builtin();
1009         param_sysfs_builtin();
1010 
1011         return 0;
1012 }
1013 subsys_initcall(param_sysfs_init);
1014 
1015 #endif /* CONFIG_SYSFS */
1016 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us