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>
27 #define DEBUGP(fmt, a...)
30 static inline int dash2underscore(char c)
37 static inline int parameq(const char *input, const char *paramname)
40 for (i = 0; dash2underscore(input[i]) == paramname[i]; i++)
46 static int parse_one(char *param,
48 struct kernel_param *params,
50 int (*handle_unknown)(char *param, char *val))
55 for (i = 0; i < num_params; i++) {
56 if (parameq(param, params[i].name)) {
57 DEBUGP("They are equal! Calling %p\n",
59 return params[i].set(val, ¶ms[i]);
64 DEBUGP("Unknown argument: calling %p\n", handle_unknown);
65 return handle_unknown(param, val);
68 DEBUGP("Unknown argument `%s'\n", param);
72 /* You can use " around spaces, but can't escape ". */
73 /* Hyphens and underscores equivalent in parameter names. */
74 static char *next_arg(char *args, char **param, char **val)
76 unsigned int i, equals = 0;
79 /* Chew any extra spaces */
80 while (*args == ' ') args++;
82 for (i = 0; args[i]; i++) {
83 if (args[i] == ' ' && !in_quote)
98 *val = args + equals + 1;
100 /* Don't include quotes in value. */
103 if (args[i-1] == '"')
115 /* Args looks like "foo=bar,bar2 baz=fuz wiz". */
116 int parse_args(const char *name,
118 struct kernel_param *params,
120 int (*unknown)(char *param, char *val))
124 DEBUGP("Parsing ARGS: %s\n", args);
129 args = next_arg(args, ¶m, &val);
130 ret = parse_one(param, val, params, num, unknown);
133 printk(KERN_ERR "%s: Unknown parameter `%s'\n",
138 "%s: `%s' too large for parameter `%s'\n",
139 name, val ?: "", param);
145 "%s: `%s' invalid for parameter `%s'\n",
146 name, val ?: "", param);
155 /* Lazy bastard, eh? */
156 #define STANDARD_PARAM_DEF(name, type, format, tmptype, strtolfn) \
157 int param_set_##name(const char *val, struct kernel_param *kp) \
162 if (!val) return -EINVAL; \
163 l = strtolfn(val, &endp, 0); \
164 if (endp == val || *endp || ((type)l != l)) \
166 *((type *)kp->arg) = l; \
169 int param_get_##name(char *buffer, struct kernel_param *kp) \
171 return sprintf(buffer, format, *((type *)kp->arg)); \
174 STANDARD_PARAM_DEF(short, short, "%hi", long, simple_strtol);
175 STANDARD_PARAM_DEF(ushort, unsigned short, "%hu", unsigned long, simple_strtoul);
176 STANDARD_PARAM_DEF(int, int, "%i", long, simple_strtol);
177 STANDARD_PARAM_DEF(uint, unsigned int, "%u", unsigned long, simple_strtoul);
178 STANDARD_PARAM_DEF(long, long, "%li", long, simple_strtol);
179 STANDARD_PARAM_DEF(ulong, unsigned long, "%lu", unsigned long, simple_strtoul);
181 int param_set_charp(const char *val, struct kernel_param *kp)
184 printk(KERN_ERR "%s: string parameter expected\n",
189 if (strlen(val) > 1024) {
190 printk(KERN_ERR "%s: string parameter too long\n",
195 *(char **)kp->arg = (char *)val;
199 int param_get_charp(char *buffer, struct kernel_param *kp)
201 return sprintf(buffer, "%s", *((char **)kp->arg));
204 int param_set_bool(const char *val, struct kernel_param *kp)
206 /* No equals means "set"... */
209 /* One of =[yYnN01] */
211 case 'y': case 'Y': case '1':
214 case 'n': case 'N': case '0':
221 int param_get_bool(char *buffer, struct kernel_param *kp)
223 /* Y and N chosen as being relatively non-coder friendly */
224 return sprintf(buffer, "%c", (*(int *)kp->arg) ? 'Y' : 'N');
227 int param_set_invbool(const char *val, struct kernel_param *kp)
230 struct kernel_param dummy = { .arg = &boolval };
232 ret = param_set_bool(val, &dummy);
234 *(int *)kp->arg = !boolval;
238 int param_get_invbool(char *buffer, struct kernel_param *kp)
241 struct kernel_param dummy = { .arg = &val };
243 val = !*(int *)kp->arg;
244 return param_get_bool(buffer, &dummy);
247 /* We cheat here and temporarily mangle the string. */
248 int param_array(const char *name,
250 unsigned int min, unsigned int max,
251 void *elem, int elemsize,
252 int (*set)(const char *, struct kernel_param *kp),
256 struct kernel_param kp;
259 /* Get the name right for errors. */
263 /* No equals sign? */
265 printk(KERN_ERR "%s: expects arguments\n", name);
270 /* We expect a comma-separated list of values. */
275 printk(KERN_ERR "%s: can only take %i arguments\n",
279 len = strcspn(val, ",");
281 /* nul-terminate and parse */
283 ((char *)val)[len] = '\0';
291 } while (save == ',');
294 printk(KERN_ERR "%s: needs at least %i arguments\n",
301 int param_array_set(const char *val, struct kernel_param *kp)
303 struct kparam_array *arr = kp->arg;
305 return param_array(kp->name, val, 1, arr->max, arr->elem,
306 arr->elemsize, arr->set, arr->num);
309 int param_array_get(char *buffer, struct kernel_param *kp)
312 struct kparam_array *arr = kp->arg;
313 struct kernel_param p;
316 for (i = off = 0; i < *arr->num; i++) {
319 p.arg = arr->elem + arr->elemsize * i;
320 ret = arr->get(buffer + off, &p);
329 int param_set_copystring(const char *val, struct kernel_param *kp)
331 struct kparam_string *kps = kp->arg;
333 if (strlen(val)+1 > kps->maxlen) {
334 printk(KERN_ERR "%s: string doesn't fit in %u chars.\n",
335 kp->name, kps->maxlen-1);
338 strcpy(kps->string, val);
342 EXPORT_SYMBOL(param_set_short);
343 EXPORT_SYMBOL(param_get_short);
344 EXPORT_SYMBOL(param_set_ushort);
345 EXPORT_SYMBOL(param_get_ushort);
346 EXPORT_SYMBOL(param_set_int);
347 EXPORT_SYMBOL(param_get_int);
348 EXPORT_SYMBOL(param_set_uint);
349 EXPORT_SYMBOL(param_get_uint);
350 EXPORT_SYMBOL(param_set_long);
351 EXPORT_SYMBOL(param_get_long);
352 EXPORT_SYMBOL(param_set_ulong);
353 EXPORT_SYMBOL(param_get_ulong);
354 EXPORT_SYMBOL(param_set_charp);
355 EXPORT_SYMBOL(param_get_charp);
356 EXPORT_SYMBOL(param_set_bool);
357 EXPORT_SYMBOL(param_get_bool);
358 EXPORT_SYMBOL(param_set_invbool);
359 EXPORT_SYMBOL(param_get_invbool);
360 EXPORT_SYMBOL(param_array_set);
361 EXPORT_SYMBOL(param_array_get);
362 EXPORT_SYMBOL(param_set_copystring);