ufs: pass qstr instead of dentry where necessary for NFS
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / kernel / params.c
blobcf1b691831275f85247ebd93628b8015fac1c70d
1 /* Helpers for initial module or kernel cmdline parsing
2 Copyright (C) 2001 Rusty Russell.
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.
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.
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
18 #include <linux/moduleparam.h>
19 #include <linux/kernel.h>
20 #include <linux/string.h>
21 #include <linux/errno.h>
22 #include <linux/module.h>
23 #include <linux/device.h>
24 #include <linux/err.h>
25 #include <linux/slab.h>
26 #include <linux/ctype.h>
27 #include <linux/string.h>
29 #if 0
30 #define DEBUGP printk
31 #else
32 #define DEBUGP(fmt, a...)
33 #endif
35 static inline char dash2underscore(char c)
37 if (c == '-')
38 return '_';
39 return c;
42 static inline int parameq(const char *input, const char *paramname)
44 unsigned int i;
45 for (i = 0; dash2underscore(input[i]) == paramname[i]; i++)
46 if (input[i] == '\0')
47 return 1;
48 return 0;
51 static int parse_one(char *param,
52 char *val,
53 struct kernel_param *params,
54 unsigned num_params,
55 int (*handle_unknown)(char *param, char *val))
57 unsigned int i;
59 /* Find parameter */
60 for (i = 0; i < num_params; i++) {
61 if (parameq(param, params[i].name)) {
62 DEBUGP("They are equal! Calling %p\n",
63 params[i].set);
64 return params[i].set(val, &params[i]);
68 if (handle_unknown) {
69 DEBUGP("Unknown argument: calling %p\n", handle_unknown);
70 return handle_unknown(param, val);
73 DEBUGP("Unknown argument `%s'\n", param);
74 return -ENOENT;
77 /* You can use " around spaces, but can't escape ". */
78 /* Hyphens and underscores equivalent in parameter names. */
79 static char *next_arg(char *args, char **param, char **val)
81 unsigned int i, equals = 0;
82 int in_quote = 0, quoted = 0;
83 char *next;
85 if (*args == '"') {
86 args++;
87 in_quote = 1;
88 quoted = 1;
91 for (i = 0; args[i]; i++) {
92 if (isspace(args[i]) && !in_quote)
93 break;
94 if (equals == 0) {
95 if (args[i] == '=')
96 equals = i;
98 if (args[i] == '"')
99 in_quote = !in_quote;
102 *param = args;
103 if (!equals)
104 *val = NULL;
105 else {
106 args[equals] = '\0';
107 *val = args + equals + 1;
109 /* Don't include quotes in value. */
110 if (**val == '"') {
111 (*val)++;
112 if (args[i-1] == '"')
113 args[i-1] = '\0';
115 if (quoted && args[i-1] == '"')
116 args[i-1] = '\0';
119 if (args[i]) {
120 args[i] = '\0';
121 next = args + i + 1;
122 } else
123 next = args + i;
125 /* Chew up trailing spaces. */
126 return skip_spaces(next);
129 /* Args looks like "foo=bar,bar2 baz=fuz wiz". */
130 int parse_args(const char *name,
131 char *args,
132 struct kernel_param *params,
133 unsigned num,
134 int (*unknown)(char *param, char *val))
136 char *param, *val;
138 DEBUGP("Parsing ARGS: %s\n", args);
140 /* Chew leading spaces */
141 args = skip_spaces(args);
143 while (*args) {
144 int ret;
145 int irq_was_disabled;
147 args = next_arg(args, &param, &val);
148 irq_was_disabled = irqs_disabled();
149 ret = parse_one(param, val, params, num, unknown);
150 if (irq_was_disabled && !irqs_disabled()) {
151 printk(KERN_WARNING "parse_args(): option '%s' enabled "
152 "irq's!\n", param);
154 switch (ret) {
155 case -ENOENT:
156 printk(KERN_ERR "%s: Unknown parameter `%s'\n",
157 name, param);
158 return ret;
159 case -ENOSPC:
160 printk(KERN_ERR
161 "%s: `%s' too large for parameter `%s'\n",
162 name, val ?: "", param);
163 return ret;
164 case 0:
165 break;
166 default:
167 printk(KERN_ERR
168 "%s: `%s' invalid for parameter `%s'\n",
169 name, val ?: "", param);
170 return ret;
174 /* All parsed OK. */
175 return 0;
178 /* Lazy bastard, eh? */
179 #define STANDARD_PARAM_DEF(name, type, format, tmptype, strtolfn) \
180 int param_set_##name(const char *val, struct kernel_param *kp) \
182 tmptype l; \
183 int ret; \
185 if (!val) return -EINVAL; \
186 ret = strtolfn(val, 0, &l); \
187 if (ret == -EINVAL || ((type)l != l)) \
188 return -EINVAL; \
189 *((type *)kp->arg) = l; \
190 return 0; \
192 int param_get_##name(char *buffer, struct kernel_param *kp) \
194 return sprintf(buffer, format, *((type *)kp->arg)); \
197 STANDARD_PARAM_DEF(byte, unsigned char, "%c", unsigned long, strict_strtoul);
198 STANDARD_PARAM_DEF(short, short, "%hi", long, strict_strtol);
199 STANDARD_PARAM_DEF(ushort, unsigned short, "%hu", unsigned long, strict_strtoul);
200 STANDARD_PARAM_DEF(int, int, "%i", long, strict_strtol);
201 STANDARD_PARAM_DEF(uint, unsigned int, "%u", unsigned long, strict_strtoul);
202 STANDARD_PARAM_DEF(long, long, "%li", long, strict_strtol);
203 STANDARD_PARAM_DEF(ulong, unsigned long, "%lu", unsigned long, strict_strtoul);
205 int param_set_charp(const char *val, struct kernel_param *kp)
207 if (!val) {
208 printk(KERN_ERR "%s: string parameter expected\n",
209 kp->name);
210 return -EINVAL;
213 if (strlen(val) > 1024) {
214 printk(KERN_ERR "%s: string parameter too long\n",
215 kp->name);
216 return -ENOSPC;
219 /* This is a hack. We can't need to strdup in early boot, and we
220 * don't need to; this mangled commandline is preserved. */
221 if (slab_is_available()) {
222 *(char **)kp->arg = kstrdup(val, GFP_KERNEL);
223 if (!*(char **)kp->arg)
224 return -ENOMEM;
225 } else
226 *(const char **)kp->arg = val;
228 return 0;
231 int param_get_charp(char *buffer, struct kernel_param *kp)
233 return sprintf(buffer, "%s", *((char **)kp->arg));
236 /* Actually could be a bool or an int, for historical reasons. */
237 int param_set_bool(const char *val, struct kernel_param *kp)
239 bool v;
241 /* No equals means "set"... */
242 if (!val) val = "1";
244 /* One of =[yYnN01] */
245 switch (val[0]) {
246 case 'y': case 'Y': case '1':
247 v = true;
248 break;
249 case 'n': case 'N': case '0':
250 v = false;
251 break;
252 default:
253 return -EINVAL;
256 if (kp->flags & KPARAM_ISBOOL)
257 *(bool *)kp->arg = v;
258 else
259 *(int *)kp->arg = v;
260 return 0;
263 int param_get_bool(char *buffer, struct kernel_param *kp)
265 bool val;
266 if (kp->flags & KPARAM_ISBOOL)
267 val = *(bool *)kp->arg;
268 else
269 val = *(int *)kp->arg;
271 /* Y and N chosen as being relatively non-coder friendly */
272 return sprintf(buffer, "%c", val ? 'Y' : 'N');
275 /* This one must be bool. */
276 int param_set_invbool(const char *val, struct kernel_param *kp)
278 int ret;
279 bool boolval;
280 struct kernel_param dummy;
282 dummy.arg = &boolval;
283 dummy.flags = KPARAM_ISBOOL;
284 ret = param_set_bool(val, &dummy);
285 if (ret == 0)
286 *(bool *)kp->arg = !boolval;
287 return ret;
290 int param_get_invbool(char *buffer, struct kernel_param *kp)
292 return sprintf(buffer, "%c", (*(bool *)kp->arg) ? 'N' : 'Y');
295 /* We break the rule and mangle the string. */
296 static int param_array(const char *name,
297 const char *val,
298 unsigned int min, unsigned int max,
299 void *elem, int elemsize,
300 int (*set)(const char *, struct kernel_param *kp),
301 u16 flags,
302 unsigned int *num)
304 int ret;
305 struct kernel_param kp;
306 char save;
308 /* Get the name right for errors. */
309 kp.name = name;
310 kp.arg = elem;
311 kp.flags = flags;
313 /* No equals sign? */
314 if (!val) {
315 printk(KERN_ERR "%s: expects arguments\n", name);
316 return -EINVAL;
319 *num = 0;
320 /* We expect a comma-separated list of values. */
321 do {
322 int len;
324 if (*num == max) {
325 printk(KERN_ERR "%s: can only take %i arguments\n",
326 name, max);
327 return -EINVAL;
329 len = strcspn(val, ",");
331 /* nul-terminate and parse */
332 save = val[len];
333 ((char *)val)[len] = '\0';
334 ret = set(val, &kp);
336 if (ret != 0)
337 return ret;
338 kp.arg += elemsize;
339 val += len+1;
340 (*num)++;
341 } while (save == ',');
343 if (*num < min) {
344 printk(KERN_ERR "%s: needs at least %i arguments\n",
345 name, min);
346 return -EINVAL;
348 return 0;
351 int param_array_set(const char *val, struct kernel_param *kp)
353 const struct kparam_array *arr = kp->arr;
354 unsigned int temp_num;
356 return param_array(kp->name, val, 1, arr->max, arr->elem,
357 arr->elemsize, arr->set, kp->flags,
358 arr->num ?: &temp_num);
361 int param_array_get(char *buffer, struct kernel_param *kp)
363 int i, off, ret;
364 const struct kparam_array *arr = kp->arr;
365 struct kernel_param p;
367 p = *kp;
368 for (i = off = 0; i < (arr->num ? *arr->num : arr->max); i++) {
369 if (i)
370 buffer[off++] = ',';
371 p.arg = arr->elem + arr->elemsize * i;
372 ret = arr->get(buffer + off, &p);
373 if (ret < 0)
374 return ret;
375 off += ret;
377 buffer[off] = '\0';
378 return off;
381 int param_set_copystring(const char *val, struct kernel_param *kp)
383 const struct kparam_string *kps = kp->str;
385 if (!val) {
386 printk(KERN_ERR "%s: missing param set value\n", kp->name);
387 return -EINVAL;
389 if (strlen(val)+1 > kps->maxlen) {
390 printk(KERN_ERR "%s: string doesn't fit in %u chars.\n",
391 kp->name, kps->maxlen-1);
392 return -ENOSPC;
394 strcpy(kps->string, val);
395 return 0;
398 int param_get_string(char *buffer, struct kernel_param *kp)
400 const struct kparam_string *kps = kp->str;
401 return strlcpy(buffer, kps->string, kps->maxlen);
404 /* sysfs output in /sys/modules/XYZ/parameters/ */
405 #define to_module_attr(n) container_of(n, struct module_attribute, attr);
406 #define to_module_kobject(n) container_of(n, struct module_kobject, kobj);
408 extern struct kernel_param __start___param[], __stop___param[];
410 struct param_attribute
412 struct module_attribute mattr;
413 struct kernel_param *param;
416 struct module_param_attrs
418 unsigned int num;
419 struct attribute_group grp;
420 struct param_attribute attrs[0];
423 #ifdef CONFIG_SYSFS
424 #define to_param_attr(n) container_of(n, struct param_attribute, mattr);
426 static ssize_t param_attr_show(struct module_attribute *mattr,
427 struct module *mod, char *buf)
429 int count;
430 struct param_attribute *attribute = to_param_attr(mattr);
432 if (!attribute->param->get)
433 return -EPERM;
435 count = attribute->param->get(buf, attribute->param);
436 if (count > 0) {
437 strcat(buf, "\n");
438 ++count;
440 return count;
443 /* sysfs always hands a nul-terminated string in buf. We rely on that. */
444 static ssize_t param_attr_store(struct module_attribute *mattr,
445 struct module *owner,
446 const char *buf, size_t len)
448 int err;
449 struct param_attribute *attribute = to_param_attr(mattr);
451 if (!attribute->param->set)
452 return -EPERM;
454 err = attribute->param->set(buf, attribute->param);
455 if (!err)
456 return len;
457 return err;
459 #endif
461 #ifdef CONFIG_MODULES
462 #define __modinit
463 #else
464 #define __modinit __init
465 #endif
467 #ifdef CONFIG_SYSFS
469 * add_sysfs_param - add a parameter to sysfs
470 * @mk: struct module_kobject
471 * @kparam: the actual parameter definition to add to sysfs
472 * @name: name of parameter
474 * Create a kobject if for a (per-module) parameter if mp NULL, and
475 * create file in sysfs. Returns an error on out of memory. Always cleans up
476 * if there's an error.
478 static __modinit int add_sysfs_param(struct module_kobject *mk,
479 struct kernel_param *kp,
480 const char *name)
482 struct module_param_attrs *new;
483 struct attribute **attrs;
484 int err, num;
486 /* We don't bother calling this with invisible parameters. */
487 BUG_ON(!kp->perm);
489 if (!mk->mp) {
490 num = 0;
491 attrs = NULL;
492 } else {
493 num = mk->mp->num;
494 attrs = mk->mp->grp.attrs;
497 /* Enlarge. */
498 new = krealloc(mk->mp,
499 sizeof(*mk->mp) + sizeof(mk->mp->attrs[0]) * (num+1),
500 GFP_KERNEL);
501 if (!new) {
502 kfree(mk->mp);
503 err = -ENOMEM;
504 goto fail;
506 attrs = krealloc(attrs, sizeof(new->grp.attrs[0])*(num+2), GFP_KERNEL);
507 if (!attrs) {
508 err = -ENOMEM;
509 goto fail_free_new;
512 /* Sysfs wants everything zeroed. */
513 memset(new, 0, sizeof(*new));
514 memset(&new->attrs[num], 0, sizeof(new->attrs[num]));
515 memset(&attrs[num], 0, sizeof(attrs[num]));
516 new->grp.name = "parameters";
517 new->grp.attrs = attrs;
519 /* Tack new one on the end. */
520 new->attrs[num].param = kp;
521 new->attrs[num].mattr.show = param_attr_show;
522 new->attrs[num].mattr.store = param_attr_store;
523 new->attrs[num].mattr.attr.name = (char *)name;
524 new->attrs[num].mattr.attr.mode = kp->perm;
525 new->num = num+1;
527 /* Fix up all the pointers, since krealloc can move us */
528 for (num = 0; num < new->num; num++)
529 new->grp.attrs[num] = &new->attrs[num].mattr.attr;
530 new->grp.attrs[num] = NULL;
532 mk->mp = new;
533 return 0;
535 fail_free_new:
536 kfree(new);
537 fail:
538 mk->mp = NULL;
539 return err;
542 #ifdef CONFIG_MODULES
543 static void free_module_param_attrs(struct module_kobject *mk)
545 kfree(mk->mp->grp.attrs);
546 kfree(mk->mp);
547 mk->mp = NULL;
551 * module_param_sysfs_setup - setup sysfs support for one module
552 * @mod: module
553 * @kparam: module parameters (array)
554 * @num_params: number of module parameters
556 * Adds sysfs entries for module parameters under
557 * /sys/module/[mod->name]/parameters/
559 int module_param_sysfs_setup(struct module *mod,
560 struct kernel_param *kparam,
561 unsigned int num_params)
563 int i, err;
564 bool params = false;
566 for (i = 0; i < num_params; i++) {
567 if (kparam[i].perm == 0)
568 continue;
569 err = add_sysfs_param(&mod->mkobj, &kparam[i], kparam[i].name);
570 if (err)
571 return err;
572 params = true;
575 if (!params)
576 return 0;
578 /* Create the param group. */
579 err = sysfs_create_group(&mod->mkobj.kobj, &mod->mkobj.mp->grp);
580 if (err)
581 free_module_param_attrs(&mod->mkobj);
582 return err;
586 * module_param_sysfs_remove - remove sysfs support for one module
587 * @mod: module
589 * Remove sysfs entries for module parameters and the corresponding
590 * kobject.
592 void module_param_sysfs_remove(struct module *mod)
594 if (mod->mkobj.mp) {
595 sysfs_remove_group(&mod->mkobj.kobj, &mod->mkobj.mp->grp);
596 /* We are positive that no one is using any param
597 * attrs at this point. Deallocate immediately. */
598 free_module_param_attrs(&mod->mkobj);
601 #endif
603 void destroy_params(const struct kernel_param *params, unsigned num)
605 /* FIXME: This should free kmalloced charp parameters. It doesn't. */
608 static void __init kernel_add_sysfs_param(const char *name,
609 struct kernel_param *kparam,
610 unsigned int name_skip)
612 struct module_kobject *mk;
613 struct kobject *kobj;
614 int err;
616 kobj = kset_find_obj(module_kset, name);
617 if (kobj) {
618 /* We already have one. Remove params so we can add more. */
619 mk = to_module_kobject(kobj);
620 /* We need to remove it before adding parameters. */
621 sysfs_remove_group(&mk->kobj, &mk->mp->grp);
622 } else {
623 mk = kzalloc(sizeof(struct module_kobject), GFP_KERNEL);
624 BUG_ON(!mk);
626 mk->mod = THIS_MODULE;
627 mk->kobj.kset = module_kset;
628 err = kobject_init_and_add(&mk->kobj, &module_ktype, NULL,
629 "%s", name);
630 if (err) {
631 kobject_put(&mk->kobj);
632 printk(KERN_ERR "Module '%s' failed add to sysfs, "
633 "error number %d\n", name, err);
634 printk(KERN_ERR "The system will be unstable now.\n");
635 return;
637 /* So that exit path is even. */
638 kobject_get(&mk->kobj);
641 /* These should not fail at boot. */
642 err = add_sysfs_param(mk, kparam, kparam->name + name_skip);
643 BUG_ON(err);
644 err = sysfs_create_group(&mk->kobj, &mk->mp->grp);
645 BUG_ON(err);
646 kobject_uevent(&mk->kobj, KOBJ_ADD);
647 kobject_put(&mk->kobj);
651 * param_sysfs_builtin - add contents in /sys/parameters for built-in modules
653 * Add module_parameters to sysfs for "modules" built into the kernel.
655 * The "module" name (KBUILD_MODNAME) is stored before a dot, the
656 * "parameter" name is stored behind a dot in kernel_param->name. So,
657 * extract the "module" name for all built-in kernel_param-eters,
658 * and for all who have the same, call kernel_add_sysfs_param.
660 static void __init param_sysfs_builtin(void)
662 struct kernel_param *kp;
663 unsigned int name_len;
664 char modname[MODULE_NAME_LEN];
666 for (kp = __start___param; kp < __stop___param; kp++) {
667 char *dot;
669 if (kp->perm == 0)
670 continue;
672 dot = strchr(kp->name, '.');
673 if (!dot) {
674 /* This happens for core_param() */
675 strcpy(modname, "kernel");
676 name_len = 0;
677 } else {
678 name_len = dot - kp->name + 1;
679 strlcpy(modname, kp->name, name_len);
681 kernel_add_sysfs_param(modname, kp, name_len);
686 /* module-related sysfs stuff */
688 static ssize_t module_attr_show(struct kobject *kobj,
689 struct attribute *attr,
690 char *buf)
692 struct module_attribute *attribute;
693 struct module_kobject *mk;
694 int ret;
696 attribute = to_module_attr(attr);
697 mk = to_module_kobject(kobj);
699 if (!attribute->show)
700 return -EIO;
702 ret = attribute->show(attribute, mk->mod, buf);
704 return ret;
707 static ssize_t module_attr_store(struct kobject *kobj,
708 struct attribute *attr,
709 const char *buf, size_t len)
711 struct module_attribute *attribute;
712 struct module_kobject *mk;
713 int ret;
715 attribute = to_module_attr(attr);
716 mk = to_module_kobject(kobj);
718 if (!attribute->store)
719 return -EIO;
721 ret = attribute->store(attribute, mk->mod, buf, len);
723 return ret;
726 static struct sysfs_ops module_sysfs_ops = {
727 .show = module_attr_show,
728 .store = module_attr_store,
731 static int uevent_filter(struct kset *kset, struct kobject *kobj)
733 struct kobj_type *ktype = get_ktype(kobj);
735 if (ktype == &module_ktype)
736 return 1;
737 return 0;
740 static struct kset_uevent_ops module_uevent_ops = {
741 .filter = uevent_filter,
744 struct kset *module_kset;
745 int module_sysfs_initialized;
747 struct kobj_type module_ktype = {
748 .sysfs_ops = &module_sysfs_ops,
752 * param_sysfs_init - wrapper for built-in params support
754 static int __init param_sysfs_init(void)
756 module_kset = kset_create_and_add("module", &module_uevent_ops, NULL);
757 if (!module_kset) {
758 printk(KERN_WARNING "%s (%d): error creating kset\n",
759 __FILE__, __LINE__);
760 return -ENOMEM;
762 module_sysfs_initialized = 1;
764 param_sysfs_builtin();
766 return 0;
768 subsys_initcall(param_sysfs_init);
770 #endif /* CONFIG_SYSFS */
772 EXPORT_SYMBOL(param_set_byte);
773 EXPORT_SYMBOL(param_get_byte);
774 EXPORT_SYMBOL(param_set_short);
775 EXPORT_SYMBOL(param_get_short);
776 EXPORT_SYMBOL(param_set_ushort);
777 EXPORT_SYMBOL(param_get_ushort);
778 EXPORT_SYMBOL(param_set_int);
779 EXPORT_SYMBOL(param_get_int);
780 EXPORT_SYMBOL(param_set_uint);
781 EXPORT_SYMBOL(param_get_uint);
782 EXPORT_SYMBOL(param_set_long);
783 EXPORT_SYMBOL(param_get_long);
784 EXPORT_SYMBOL(param_set_ulong);
785 EXPORT_SYMBOL(param_get_ulong);
786 EXPORT_SYMBOL(param_set_charp);
787 EXPORT_SYMBOL(param_get_charp);
788 EXPORT_SYMBOL(param_set_bool);
789 EXPORT_SYMBOL(param_get_bool);
790 EXPORT_SYMBOL(param_set_invbool);
791 EXPORT_SYMBOL(param_get_invbool);
792 EXPORT_SYMBOL(param_array_set);
793 EXPORT_SYMBOL(param_array_get);
794 EXPORT_SYMBOL(param_set_copystring);
795 EXPORT_SYMBOL(param_get_string);