~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/params.c

Version: ~ [ linux-5.1-rc1 ] ~ [ linux-5.0.3 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.30 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.107 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.164 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.176 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.136 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.63 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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_notice("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 /* Args looks like "foo=bar,bar2 baz=fuz wiz". */
164 char *parse_args(const char *doing,
165                  char *args,
166                  const struct kernel_param *params,
167                  unsigned num,
168                  s16 min_level,
169                  s16 max_level,
170                  void *arg,
171                  int (*unknown)(char *param, char *val,
172                                 const char *doing, void *arg))
173 {
174         char *param, *val, *err = NULL;
175 
176         /* Chew leading spaces */
177         args = skip_spaces(args);
178 
179         if (*args)
180                 pr_debug("doing %s, parsing ARGS: '%s'\n", doing, args);
181 
182         while (*args) {
183                 int ret;
184                 int irq_was_disabled;
185 
186                 args = next_arg(args, &param, &val);
187                 /* Stop at -- */
188                 if (!val && strcmp(param, "--") == 0)
189                         return err ?: args;
190                 irq_was_disabled = irqs_disabled();
191                 ret = parse_one(param, val, doing, params, num,
192                                 min_level, max_level, arg, unknown);
193                 if (irq_was_disabled && !irqs_disabled())
194                         pr_warn("%s: option '%s' enabled irq's!\n",
195                                 doing, param);
196 
197                 switch (ret) {
198                 case 0:
199                         continue;
200                 case -ENOENT:
201                         pr_err("%s: Unknown parameter `%s'\n", doing, param);
202                         break;
203                 case -ENOSPC:
204                         pr_err("%s: `%s' too large for parameter `%s'\n",
205                                doing, val ?: "", param);
206                         break;
207                 default:
208                         pr_err("%s: `%s' invalid for parameter `%s'\n",
209                                doing, val ?: "", param);
210                         break;
211                 }
212 
213                 err = ERR_PTR(ret);
214         }
215 
216         return err;
217 }
218 
219 /* Lazy bastard, eh? */
220 #define STANDARD_PARAM_DEF(name, type, format, strtolfn)                \
221         int param_set_##name(const char *val, const struct kernel_param *kp) \
222         {                                                               \
223                 return strtolfn(val, 0, (type *)kp->arg);               \
224         }                                                               \
225         int param_get_##name(char *buffer, const struct kernel_param *kp) \
226         {                                                               \
227                 return scnprintf(buffer, PAGE_SIZE, format "\n",        \
228                                 *((type *)kp->arg));                    \
229         }                                                               \
230         const struct kernel_param_ops param_ops_##name = {                      \
231                 .set = param_set_##name,                                \
232                 .get = param_get_##name,                                \
233         };                                                              \
234         EXPORT_SYMBOL(param_set_##name);                                \
235         EXPORT_SYMBOL(param_get_##name);                                \
236         EXPORT_SYMBOL(param_ops_##name)
237 
238 
239 STANDARD_PARAM_DEF(byte,        unsigned char,          "%hhu", kstrtou8);
240 STANDARD_PARAM_DEF(short,       short,                  "%hi",  kstrtos16);
241 STANDARD_PARAM_DEF(ushort,      unsigned short,         "%hu",  kstrtou16);
242 STANDARD_PARAM_DEF(int,         int,                    "%i",   kstrtoint);
243 STANDARD_PARAM_DEF(uint,        unsigned int,           "%u",   kstrtouint);
244 STANDARD_PARAM_DEF(long,        long,                   "%li",  kstrtol);
245 STANDARD_PARAM_DEF(ulong,       unsigned long,          "%lu",  kstrtoul);
246 STANDARD_PARAM_DEF(ullong,      unsigned long long,     "%llu", kstrtoull);
247 
248 int param_set_charp(const char *val, const struct kernel_param *kp)
249 {
250         if (strlen(val) > 1024) {
251                 pr_err("%s: string parameter too long\n", kp->name);
252                 return -ENOSPC;
253         }
254 
255         maybe_kfree_parameter(*(char **)kp->arg);
256 
257         /* This is a hack.  We can't kmalloc in early boot, and we
258          * don't need to; this mangled commandline is preserved. */
259         if (slab_is_available()) {
260                 *(char **)kp->arg = kmalloc_parameter(strlen(val)+1);
261                 if (!*(char **)kp->arg)
262                         return -ENOMEM;
263                 strcpy(*(char **)kp->arg, val);
264         } else
265                 *(const char **)kp->arg = val;
266 
267         return 0;
268 }
269 EXPORT_SYMBOL(param_set_charp);
270 
271 int param_get_charp(char *buffer, const struct kernel_param *kp)
272 {
273         return scnprintf(buffer, PAGE_SIZE, "%s\n", *((char **)kp->arg));
274 }
275 EXPORT_SYMBOL(param_get_charp);
276 
277 void param_free_charp(void *arg)
278 {
279         maybe_kfree_parameter(*((char **)arg));
280 }
281 EXPORT_SYMBOL(param_free_charp);
282 
283 const struct kernel_param_ops param_ops_charp = {
284         .set = param_set_charp,
285         .get = param_get_charp,
286         .free = param_free_charp,
287 };
288 EXPORT_SYMBOL(param_ops_charp);
289 
290 /* Actually could be a bool or an int, for historical reasons. */
291 int param_set_bool(const char *val, const struct kernel_param *kp)
292 {
293         /* No equals means "set"... */
294         if (!val) val = "1";
295 
296         /* One of =[yYnN01] */
297         return strtobool(val, kp->arg);
298 }
299 EXPORT_SYMBOL(param_set_bool);
300 
301 int param_get_bool(char *buffer, const struct kernel_param *kp)
302 {
303         /* Y and N chosen as being relatively non-coder friendly */
304         return sprintf(buffer, "%c\n", *(bool *)kp->arg ? 'Y' : 'N');
305 }
306 EXPORT_SYMBOL(param_get_bool);
307 
308 const struct kernel_param_ops param_ops_bool = {
309         .flags = KERNEL_PARAM_OPS_FL_NOARG,
310         .set = param_set_bool,
311         .get = param_get_bool,
312 };
313 EXPORT_SYMBOL(param_ops_bool);
314 
315 int param_set_bool_enable_only(const char *val, const struct kernel_param *kp)
316 {
317         int err = 0;
318         bool new_value;
319         bool orig_value = *(bool *)kp->arg;
320         struct kernel_param dummy_kp = *kp;
321 
322         dummy_kp.arg = &new_value;
323 
324         err = param_set_bool(val, &dummy_kp);
325         if (err)
326                 return err;
327 
328         /* Don't let them unset it once it's set! */
329         if (!new_value && orig_value)
330                 return -EROFS;
331 
332         if (new_value)
333                 err = param_set_bool(val, kp);
334 
335         return err;
336 }
337 EXPORT_SYMBOL_GPL(param_set_bool_enable_only);
338 
339 const struct kernel_param_ops param_ops_bool_enable_only = {
340         .flags = KERNEL_PARAM_OPS_FL_NOARG,
341         .set = param_set_bool_enable_only,
342         .get = param_get_bool,
343 };
344 EXPORT_SYMBOL_GPL(param_ops_bool_enable_only);
345 
346 /* This one must be bool. */
347 int param_set_invbool(const char *val, const struct kernel_param *kp)
348 {
349         int ret;
350         bool boolval;
351         struct kernel_param dummy;
352 
353         dummy.arg = &boolval;
354         ret = param_set_bool(val, &dummy);
355         if (ret == 0)
356                 *(bool *)kp->arg = !boolval;
357         return ret;
358 }
359 EXPORT_SYMBOL(param_set_invbool);
360 
361 int param_get_invbool(char *buffer, const struct kernel_param *kp)
362 {
363         return sprintf(buffer, "%c\n", (*(bool *)kp->arg) ? 'N' : 'Y');
364 }
365 EXPORT_SYMBOL(param_get_invbool);
366 
367 const struct kernel_param_ops param_ops_invbool = {
368         .set = param_set_invbool,
369         .get = param_get_invbool,
370 };
371 EXPORT_SYMBOL(param_ops_invbool);
372 
373 int param_set_bint(const char *val, const struct kernel_param *kp)
374 {
375         /* Match bool exactly, by re-using it. */
376         struct kernel_param boolkp = *kp;
377         bool v;
378         int ret;
379 
380         boolkp.arg = &v;
381 
382         ret = param_set_bool(val, &boolkp);
383         if (ret == 0)
384                 *(int *)kp->arg = v;
385         return ret;
386 }
387 EXPORT_SYMBOL(param_set_bint);
388 
389 const struct kernel_param_ops param_ops_bint = {
390         .flags = KERNEL_PARAM_OPS_FL_NOARG,
391         .set = param_set_bint,
392         .get = param_get_int,
393 };
394 EXPORT_SYMBOL(param_ops_bint);
395 
396 /* We break the rule and mangle the string. */
397 static int param_array(struct module *mod,
398                        const char *name,
399                        const char *val,
400                        unsigned int min, unsigned int max,
401                        void *elem, int elemsize,
402                        int (*set)(const char *, const struct kernel_param *kp),
403                        s16 level,
404                        unsigned int *num)
405 {
406         int ret;
407         struct kernel_param kp;
408         char save;
409 
410         /* Get the name right for errors. */
411         kp.name = name;
412         kp.arg = elem;
413         kp.level = level;
414 
415         *num = 0;
416         /* We expect a comma-separated list of values. */
417         do {
418                 int len;
419 
420                 if (*num == max) {
421                         pr_err("%s: can only take %i arguments\n", name, max);
422                         return -EINVAL;
423                 }
424                 len = strcspn(val, ",");
425 
426                 /* nul-terminate and parse */
427                 save = val[len];
428                 ((char *)val)[len] = '\0';
429                 check_kparam_locked(mod);
430                 ret = set(val, &kp);
431 
432                 if (ret != 0)
433                         return ret;
434                 kp.arg += elemsize;
435                 val += len+1;
436                 (*num)++;
437         } while (save == ',');
438 
439         if (*num < min) {
440                 pr_err("%s: needs at least %i arguments\n", name, min);
441                 return -EINVAL;
442         }
443         return 0;
444 }
445 
446 static int param_array_set(const char *val, const struct kernel_param *kp)
447 {
448         const struct kparam_array *arr = kp->arr;
449         unsigned int temp_num;
450 
451         return param_array(kp->mod, kp->name, val, 1, arr->max, arr->elem,
452                            arr->elemsize, arr->ops->set, kp->level,
453                            arr->num ?: &temp_num);
454 }
455 
456 static int param_array_get(char *buffer, const struct kernel_param *kp)
457 {
458         int i, off, ret;
459         const struct kparam_array *arr = kp->arr;
460         struct kernel_param p = *kp;
461 
462         for (i = off = 0; i < (arr->num ? *arr->num : arr->max); i++) {
463                 /* Replace \n with comma */
464                 if (i)
465                         buffer[off - 1] = ',';
466                 p.arg = arr->elem + arr->elemsize * i;
467                 check_kparam_locked(p.mod);
468                 ret = arr->ops->get(buffer + off, &p);
469                 if (ret < 0)
470                         return ret;
471                 off += ret;
472         }
473         buffer[off] = '\0';
474         return off;
475 }
476 
477 static void param_array_free(void *arg)
478 {
479         unsigned int i;
480         const struct kparam_array *arr = arg;
481 
482         if (arr->ops->free)
483                 for (i = 0; i < (arr->num ? *arr->num : arr->max); i++)
484                         arr->ops->free(arr->elem + arr->elemsize * i);
485 }
486 
487 const struct kernel_param_ops param_array_ops = {
488         .set = param_array_set,
489         .get = param_array_get,
490         .free = param_array_free,
491 };
492 EXPORT_SYMBOL(param_array_ops);
493 
494 int param_set_copystring(const char *val, const struct kernel_param *kp)
495 {
496         const struct kparam_string *kps = kp->str;
497 
498         if (strlen(val)+1 > kps->maxlen) {
499                 pr_err("%s: string doesn't fit in %u chars.\n",
500                        kp->name, kps->maxlen-1);
501                 return -ENOSPC;
502         }
503         strcpy(kps->string, val);
504         return 0;
505 }
506 EXPORT_SYMBOL(param_set_copystring);
507 
508 int param_get_string(char *buffer, const struct kernel_param *kp)
509 {
510         const struct kparam_string *kps = kp->str;
511         return scnprintf(buffer, PAGE_SIZE, "%s\n", kps->string);
512 }
513 EXPORT_SYMBOL(param_get_string);
514 
515 const struct kernel_param_ops param_ops_string = {
516         .set = param_set_copystring,
517         .get = param_get_string,
518 };
519 EXPORT_SYMBOL(param_ops_string);
520 
521 /* sysfs output in /sys/modules/XYZ/parameters/ */
522 #define to_module_attr(n) container_of(n, struct module_attribute, attr)
523 #define to_module_kobject(n) container_of(n, struct module_kobject, kobj)
524 
525 struct param_attribute
526 {
527         struct module_attribute mattr;
528         const struct kernel_param *param;
529 };
530 
531 struct module_param_attrs
532 {
533         unsigned int num;
534         struct attribute_group grp;
535         struct param_attribute attrs[0];
536 };
537 
538 #ifdef CONFIG_SYSFS
539 #define to_param_attr(n) container_of(n, struct param_attribute, mattr)
540 
541 static ssize_t param_attr_show(struct module_attribute *mattr,
542                                struct module_kobject *mk, char *buf)
543 {
544         int count;
545         struct param_attribute *attribute = to_param_attr(mattr);
546 
547         if (!attribute->param->ops->get)
548                 return -EPERM;
549 
550         kernel_param_lock(mk->mod);
551         count = attribute->param->ops->get(buf, attribute->param);
552         kernel_param_unlock(mk->mod);
553         return count;
554 }
555 
556 /* sysfs always hands a nul-terminated string in buf.  We rely on that. */
557 static ssize_t param_attr_store(struct module_attribute *mattr,
558                                 struct module_kobject *mk,
559                                 const char *buf, size_t len)
560 {
561         int err;
562         struct param_attribute *attribute = to_param_attr(mattr);
563 
564         if (!attribute->param->ops->set)
565                 return -EPERM;
566 
567         kernel_param_lock(mk->mod);
568         param_check_unsafe(attribute->param);
569         err = attribute->param->ops->set(buf, attribute->param);
570         kernel_param_unlock(mk->mod);
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(struct module *mod)
585 {
586         mutex_lock(KPARAM_MUTEX(mod));
587 }
588 
589 void kernel_param_unlock(struct module *mod)
590 {
591         mutex_unlock(KPARAM_MUTEX(mod));
592 }
593 
594 EXPORT_SYMBOL(kernel_param_lock);
595 EXPORT_SYMBOL(kernel_param_unlock);
596 
597 /*
598  * add_sysfs_param - add a parameter to sysfs
599  * @mk: struct module_kobject
600  * @kp: the actual parameter definition to add to sysfs
601  * @name: name of parameter
602  *
603  * Create a kobject if for a (per-module) parameter if mp NULL, and
604  * create file in sysfs.  Returns an error on out of memory.  Always cleans up
605  * if there's an error.
606  */
607 static __modinit int add_sysfs_param(struct module_kobject *mk,
608                                      const struct kernel_param *kp,
609                                      const char *name)
610 {
611         struct module_param_attrs *new_mp;
612         struct attribute **new_attrs;
613         unsigned int i;
614 
615         /* We don't bother calling this with invisible parameters. */
616         BUG_ON(!kp->perm);
617 
618         if (!mk->mp) {
619                 /* First allocation. */
620                 mk->mp = kzalloc(sizeof(*mk->mp), GFP_KERNEL);
621                 if (!mk->mp)
622                         return -ENOMEM;
623                 mk->mp->grp.name = "parameters";
624                 /* NULL-terminated attribute array. */
625                 mk->mp->grp.attrs = kzalloc(sizeof(mk->mp->grp.attrs[0]),
626                                             GFP_KERNEL);
627                 /* Caller will cleanup via free_module_param_attrs */
628                 if (!mk->mp->grp.attrs)
629                         return -ENOMEM;
630         }
631 
632         /* Enlarge allocations. */
633         new_mp = krealloc(mk->mp,
634                           sizeof(*mk->mp) +
635                           sizeof(mk->mp->attrs[0]) * (mk->mp->num + 1),
636                           GFP_KERNEL);
637         if (!new_mp)
638                 return -ENOMEM;
639         mk->mp = new_mp;
640 
641         /* Extra pointer for NULL terminator */
642         new_attrs = krealloc(mk->mp->grp.attrs,
643                              sizeof(mk->mp->grp.attrs[0]) * (mk->mp->num + 2),
644                              GFP_KERNEL);
645         if (!new_attrs)
646                 return -ENOMEM;
647         mk->mp->grp.attrs = new_attrs;
648 
649         /* Tack new one on the end. */
650         memset(&mk->mp->attrs[mk->mp->num], 0, sizeof(mk->mp->attrs[0]));
651         sysfs_attr_init(&mk->mp->attrs[mk->mp->num].mattr.attr);
652         mk->mp->attrs[mk->mp->num].param = kp;
653         mk->mp->attrs[mk->mp->num].mattr.show = param_attr_show;
654         /* Do not allow runtime DAC changes to make param writable. */
655         if ((kp->perm & (S_IWUSR | S_IWGRP | S_IWOTH)) != 0)
656                 mk->mp->attrs[mk->mp->num].mattr.store = param_attr_store;
657         else
658                 mk->mp->attrs[mk->mp->num].mattr.store = NULL;
659         mk->mp->attrs[mk->mp->num].mattr.attr.name = (char *)name;
660         mk->mp->attrs[mk->mp->num].mattr.attr.mode = kp->perm;
661         mk->mp->num++;
662 
663         /* Fix up all the pointers, since krealloc can move us */
664         for (i = 0; i < mk->mp->num; i++)
665                 mk->mp->grp.attrs[i] = &mk->mp->attrs[i].mattr.attr;
666         mk->mp->grp.attrs[mk->mp->num] = NULL;
667         return 0;
668 }
669 
670 #ifdef CONFIG_MODULES
671 static void free_module_param_attrs(struct module_kobject *mk)
672 {
673         if (mk->mp)
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                         free_module_param_attrs(&mod->mkobj);
701                         return err;
702                 }
703                 params = true;
704         }
705 
706         if (!params)
707                 return 0;
708 
709         /* Create the param group. */
710         err = sysfs_create_group(&mod->mkobj.kobj, &mod->mkobj.mp->grp);
711         if (err)
712                 free_module_param_attrs(&mod->mkobj);
713         return err;
714 }
715 
716 /*
717  * module_param_sysfs_remove - remove sysfs support for one module
718  * @mod: module
719  *
720  * Remove sysfs entries for module parameters and the corresponding
721  * kobject.
722  */
723 void module_param_sysfs_remove(struct module *mod)
724 {
725         if (mod->mkobj.mp) {
726                 sysfs_remove_group(&mod->mkobj.kobj, &mod->mkobj.mp->grp);
727                 /* We are positive that no one is using any param
728                  * attrs at this point.  Deallocate immediately. */
729                 free_module_param_attrs(&mod->mkobj);
730         }
731 }
732 #endif
733 
734 void destroy_params(const struct kernel_param *params, unsigned num)
735 {
736         unsigned int i;
737 
738         for (i = 0; i < num; i++)
739                 if (params[i].ops->free)
740                         params[i].ops->free(params[i].arg);
741 }
742 
743 static struct module_kobject * __init locate_module_kobject(const char *name)
744 {
745         struct module_kobject *mk;
746         struct kobject *kobj;
747         int err;
748 
749         kobj = kset_find_obj(module_kset, name);
750         if (kobj) {
751                 mk = to_module_kobject(kobj);
752         } else {
753                 mk = kzalloc(sizeof(struct module_kobject), GFP_KERNEL);
754                 BUG_ON(!mk);
755 
756                 mk->mod = THIS_MODULE;
757                 mk->kobj.kset = module_kset;
758                 err = kobject_init_and_add(&mk->kobj, &module_ktype, NULL,
759                                            "%s", name);
760 #ifdef CONFIG_MODULES
761                 if (!err)
762                         err = sysfs_create_file(&mk->kobj, &module_uevent.attr);
763 #endif
764                 if (err) {
765                         kobject_put(&mk->kobj);
766                         pr_crit("Adding module '%s' to sysfs failed (%d), the system may be unstable.\n",
767                                 name, err);
768                         return NULL;
769                 }
770 
771                 /* So that we hold reference in both cases. */
772                 kobject_get(&mk->kobj);
773         }
774 
775         return mk;
776 }
777 
778 static void __init kernel_add_sysfs_param(const char *name,
779                                           const struct kernel_param *kparam,
780                                           unsigned int name_skip)
781 {
782         struct module_kobject *mk;
783         int err;
784 
785         mk = locate_module_kobject(name);
786         if (!mk)
787                 return;
788 
789         /* We need to remove old parameters before adding more. */
790         if (mk->mp)
791                 sysfs_remove_group(&mk->kobj, &mk->mp->grp);
792 
793         /* These should not fail at boot. */
794         err = add_sysfs_param(mk, kparam, kparam->name + name_skip);
795         BUG_ON(err);
796         err = sysfs_create_group(&mk->kobj, &mk->mp->grp);
797         BUG_ON(err);
798         kobject_uevent(&mk->kobj, KOBJ_ADD);
799         kobject_put(&mk->kobj);
800 }
801 
802 /*
803  * param_sysfs_builtin - add sysfs parameters for built-in modules
804  *
805  * Add module_parameters to sysfs for "modules" built into the kernel.
806  *
807  * The "module" name (KBUILD_MODNAME) is stored before a dot, the
808  * "parameter" name is stored behind a dot in kernel_param->name. So,
809  * extract the "module" name for all built-in kernel_param-eters,
810  * and for all who have the same, call kernel_add_sysfs_param.
811  */
812 static void __init param_sysfs_builtin(void)
813 {
814         const struct kernel_param *kp;
815         unsigned int name_len;
816         char modname[MODULE_NAME_LEN];
817 
818         for (kp = __start___param; kp < __stop___param; kp++) {
819                 char *dot;
820 
821                 if (kp->perm == 0)
822                         continue;
823 
824                 dot = strchr(kp->name, '.');
825                 if (!dot) {
826                         /* This happens for core_param() */
827                         strcpy(modname, "kernel");
828                         name_len = 0;
829                 } else {
830                         name_len = dot - kp->name + 1;
831                         strlcpy(modname, kp->name, name_len);
832                 }
833                 kernel_add_sysfs_param(modname, kp, name_len);
834         }
835 }
836 
837 ssize_t __modver_version_show(struct module_attribute *mattr,
838                               struct module_kobject *mk, char *buf)
839 {
840         struct module_version_attribute *vattr =
841                 container_of(mattr, struct module_version_attribute, mattr);
842 
843         return scnprintf(buf, PAGE_SIZE, "%s\n", vattr->version);
844 }
845 
846 extern const struct module_version_attribute *__start___modver[];
847 extern const struct module_version_attribute *__stop___modver[];
848 
849 static void __init version_sysfs_builtin(void)
850 {
851         const struct module_version_attribute **p;
852         struct module_kobject *mk;
853         int err;
854 
855         for (p = __start___modver; p < __stop___modver; p++) {
856                 const struct module_version_attribute *vattr = *p;
857 
858                 mk = locate_module_kobject(vattr->module_name);
859                 if (mk) {
860                         err = sysfs_create_file(&mk->kobj, &vattr->mattr.attr);
861                         WARN_ON_ONCE(err);
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 static void module_kobj_release(struct kobject *kobj)
930 {
931         struct module_kobject *mk = to_module_kobject(kobj);
932         complete(mk->kobj_completion);
933 }
934 
935 struct kobj_type module_ktype = {
936         .release   =    module_kobj_release,
937         .sysfs_ops =    &module_sysfs_ops,
938 };
939 
940 /*
941  * param_sysfs_init - wrapper for built-in params support
942  */
943 static int __init param_sysfs_init(void)
944 {
945         module_kset = kset_create_and_add("module", &module_uevent_ops, NULL);
946         if (!module_kset) {
947                 printk(KERN_WARNING "%s (%d): error creating kset\n",
948                         __FILE__, __LINE__);
949                 return -ENOMEM;
950         }
951         module_sysfs_initialized = 1;
952 
953         version_sysfs_builtin();
954         param_sysfs_builtin();
955 
956         return 0;
957 }
958 subsys_initcall(param_sysfs_init);
959 
960 #endif /* CONFIG_SYSFS */
961 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp