blob: aca07e1a050f651c34cacacb8c37a4755ddb60ab [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* 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*/
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#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>
Tim Schmielau4e57b682005-10-30 15:03:48 -080025#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026
27#if 0
28#define DEBUGP printk
29#else
30#define DEBUGP(fmt, a...)
31#endif
32
Eric Sesterhennb9e20a92006-03-28 01:56:24 -080033static inline char dash2underscore(char c)
Linus Torvalds1da177e2005-04-16 15:20:36 -070034{
35 if (c == '-')
36 return '_';
37 return c;
38}
39
40static inline int parameq(const char *input, const char *paramname)
41{
42 unsigned int i;
43 for (i = 0; dash2underscore(input[i]) == paramname[i]; i++)
44 if (input[i] == '\0')
45 return 1;
46 return 0;
47}
48
49static int parse_one(char *param,
50 char *val,
51 struct kernel_param *params,
52 unsigned num_params,
53 int (*handle_unknown)(char *param, char *val))
54{
55 unsigned int i;
56
57 /* Find parameter */
58 for (i = 0; i < num_params; i++) {
59 if (parameq(param, params[i].name)) {
60 DEBUGP("They are equal! Calling %p\n",
61 params[i].set);
62 return params[i].set(val, &params[i]);
63 }
64 }
65
66 if (handle_unknown) {
67 DEBUGP("Unknown argument: calling %p\n", handle_unknown);
68 return handle_unknown(param, val);
69 }
70
71 DEBUGP("Unknown argument `%s'\n", param);
72 return -ENOENT;
73}
74
75/* You can use " around spaces, but can't escape ". */
76/* Hyphens and underscores equivalent in parameter names. */
77static char *next_arg(char *args, char **param, char **val)
78{
79 unsigned int i, equals = 0;
80 int in_quote = 0, quoted = 0;
81 char *next;
82
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 if (*args == '"') {
84 args++;
85 in_quote = 1;
86 quoted = 1;
87 }
88
89 for (i = 0; args[i]; i++) {
90 if (args[i] == ' ' && !in_quote)
91 break;
92 if (equals == 0) {
93 if (args[i] == '=')
94 equals = i;
95 }
96 if (args[i] == '"')
97 in_quote = !in_quote;
98 }
99
100 *param = args;
101 if (!equals)
102 *val = NULL;
103 else {
104 args[equals] = '\0';
105 *val = args + equals + 1;
106
107 /* Don't include quotes in value. */
108 if (**val == '"') {
109 (*val)++;
110 if (args[i-1] == '"')
111 args[i-1] = '\0';
112 }
113 if (quoted && args[i-1] == '"')
114 args[i-1] = '\0';
115 }
116
117 if (args[i]) {
118 args[i] = '\0';
119 next = args + i + 1;
120 } else
121 next = args + i;
Rusty Russellf36462f2005-09-27 21:45:34 -0700122
123 /* Chew up trailing spaces. */
124 while (*next == ' ')
125 next++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 return next;
127}
128
129/* Args looks like "foo=bar,bar2 baz=fuz wiz". */
130int parse_args(const char *name,
131 char *args,
132 struct kernel_param *params,
133 unsigned num,
134 int (*unknown)(char *param, char *val))
135{
136 char *param, *val;
137
138 DEBUGP("Parsing ARGS: %s\n", args);
139
Rusty Russellf36462f2005-09-27 21:45:34 -0700140 /* Chew leading spaces */
141 while (*args == ' ')
142 args++;
143
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 while (*args) {
145 int ret;
Ard van Breemena416aba2007-01-05 16:36:20 -0800146 int irq_was_disabled;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147
148 args = next_arg(args, &param, &val);
Ard van Breemena416aba2007-01-05 16:36:20 -0800149 irq_was_disabled = irqs_disabled();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 ret = parse_one(param, val, params, num, unknown);
Ard van Breemena416aba2007-01-05 16:36:20 -0800151 if (irq_was_disabled && !irqs_disabled()) {
152 printk(KERN_WARNING "parse_args(): option '%s' enabled "
153 "irq's!\n", param);
154 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 switch (ret) {
156 case -ENOENT:
157 printk(KERN_ERR "%s: Unknown parameter `%s'\n",
158 name, param);
159 return ret;
160 case -ENOSPC:
161 printk(KERN_ERR
162 "%s: `%s' too large for parameter `%s'\n",
163 name, val ?: "", param);
164 return ret;
165 case 0:
166 break;
167 default:
168 printk(KERN_ERR
169 "%s: `%s' invalid for parameter `%s'\n",
170 name, val ?: "", param);
171 return ret;
172 }
173 }
174
175 /* All parsed OK. */
176 return 0;
177}
178
179/* Lazy bastard, eh? */
180#define STANDARD_PARAM_DEF(name, type, format, tmptype, strtolfn) \
181 int param_set_##name(const char *val, struct kernel_param *kp) \
182 { \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 tmptype l; \
Yi Yang06b2a762008-02-08 04:21:57 -0800184 int ret; \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 \
186 if (!val) return -EINVAL; \
Yi Yang06b2a762008-02-08 04:21:57 -0800187 ret = strtolfn(val, 0, &l); \
188 if (ret == -EINVAL || ((type)l != l)) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 return -EINVAL; \
190 *((type *)kp->arg) = l; \
191 return 0; \
192 } \
193 int param_get_##name(char *buffer, struct kernel_param *kp) \
194 { \
195 return sprintf(buffer, format, *((type *)kp->arg)); \
196 }
197
Yi Yang06b2a762008-02-08 04:21:57 -0800198STANDARD_PARAM_DEF(byte, unsigned char, "%c", unsigned long, strict_strtoul);
199STANDARD_PARAM_DEF(short, short, "%hi", long, strict_strtol);
200STANDARD_PARAM_DEF(ushort, unsigned short, "%hu", unsigned long, strict_strtoul);
201STANDARD_PARAM_DEF(int, int, "%i", long, strict_strtol);
202STANDARD_PARAM_DEF(uint, unsigned int, "%u", unsigned long, strict_strtoul);
203STANDARD_PARAM_DEF(long, long, "%li", long, strict_strtol);
204STANDARD_PARAM_DEF(ulong, unsigned long, "%lu", unsigned long, strict_strtoul);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205
206int param_set_charp(const char *val, struct kernel_param *kp)
207{
208 if (!val) {
209 printk(KERN_ERR "%s: string parameter expected\n",
210 kp->name);
211 return -EINVAL;
212 }
213
214 if (strlen(val) > 1024) {
215 printk(KERN_ERR "%s: string parameter too long\n",
216 kp->name);
217 return -ENOSPC;
218 }
219
220 *(char **)kp->arg = (char *)val;
221 return 0;
222}
223
224int param_get_charp(char *buffer, struct kernel_param *kp)
225{
226 return sprintf(buffer, "%s", *((char **)kp->arg));
227}
228
229int param_set_bool(const char *val, struct kernel_param *kp)
230{
231 /* No equals means "set"... */
232 if (!val) val = "1";
233
234 /* One of =[yYnN01] */
235 switch (val[0]) {
236 case 'y': case 'Y': case '1':
237 *(int *)kp->arg = 1;
238 return 0;
239 case 'n': case 'N': case '0':
240 *(int *)kp->arg = 0;
241 return 0;
242 }
243 return -EINVAL;
244}
245
246int param_get_bool(char *buffer, struct kernel_param *kp)
247{
248 /* Y and N chosen as being relatively non-coder friendly */
249 return sprintf(buffer, "%c", (*(int *)kp->arg) ? 'Y' : 'N');
250}
251
252int param_set_invbool(const char *val, struct kernel_param *kp)
253{
254 int boolval, ret;
Jan Beulich22e48ea2007-10-16 23:29:34 -0700255 struct kernel_param dummy;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
Jan Beulich22e48ea2007-10-16 23:29:34 -0700257 dummy.arg = &boolval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 ret = param_set_bool(val, &dummy);
259 if (ret == 0)
260 *(int *)kp->arg = !boolval;
261 return ret;
262}
263
264int param_get_invbool(char *buffer, struct kernel_param *kp)
265{
Jan Beulich22e48ea2007-10-16 23:29:34 -0700266 return sprintf(buffer, "%c", (*(int *)kp->arg) ? 'N' : 'Y');
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267}
268
Bert Wesarg9730b5b2007-05-08 00:28:50 -0700269/* We break the rule and mangle the string. */
Adrian Bunk98717282006-03-25 03:07:06 -0800270static int param_array(const char *name,
271 const char *val,
272 unsigned int min, unsigned int max,
273 void *elem, int elemsize,
274 int (*set)(const char *, struct kernel_param *kp),
Richard Knutssoneb38a992008-02-06 01:37:50 -0800275 unsigned int *num)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276{
277 int ret;
278 struct kernel_param kp;
279 char save;
280
281 /* Get the name right for errors. */
282 kp.name = name;
283 kp.arg = elem;
284
285 /* No equals sign? */
286 if (!val) {
287 printk(KERN_ERR "%s: expects arguments\n", name);
288 return -EINVAL;
289 }
290
291 *num = 0;
292 /* We expect a comma-separated list of values. */
293 do {
294 int len;
295
296 if (*num == max) {
297 printk(KERN_ERR "%s: can only take %i arguments\n",
298 name, max);
299 return -EINVAL;
300 }
301 len = strcspn(val, ",");
302
303 /* nul-terminate and parse */
304 save = val[len];
305 ((char *)val)[len] = '\0';
306 ret = set(val, &kp);
307
308 if (ret != 0)
309 return ret;
310 kp.arg += elemsize;
311 val += len+1;
312 (*num)++;
313 } while (save == ',');
314
315 if (*num < min) {
316 printk(KERN_ERR "%s: needs at least %i arguments\n",
317 name, min);
318 return -EINVAL;
319 }
320 return 0;
321}
322
323int param_array_set(const char *val, struct kernel_param *kp)
324{
Jan Beulich22e48ea2007-10-16 23:29:34 -0700325 const struct kparam_array *arr = kp->arr;
Bert Wesarg31143a12005-04-16 15:25:42 -0700326 unsigned int temp_num;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327
328 return param_array(kp->name, val, 1, arr->max, arr->elem,
Bert Wesarg31143a12005-04-16 15:25:42 -0700329 arr->elemsize, arr->set, arr->num ?: &temp_num);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330}
331
332int param_array_get(char *buffer, struct kernel_param *kp)
333{
334 int i, off, ret;
Jan Beulich22e48ea2007-10-16 23:29:34 -0700335 const struct kparam_array *arr = kp->arr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 struct kernel_param p;
337
338 p = *kp;
339 for (i = off = 0; i < (arr->num ? *arr->num : arr->max); i++) {
340 if (i)
341 buffer[off++] = ',';
342 p.arg = arr->elem + arr->elemsize * i;
343 ret = arr->get(buffer + off, &p);
344 if (ret < 0)
345 return ret;
346 off += ret;
347 }
348 buffer[off] = '\0';
349 return off;
350}
351
352int param_set_copystring(const char *val, struct kernel_param *kp)
353{
Jan Beulich22e48ea2007-10-16 23:29:34 -0700354 const struct kparam_string *kps = kp->str;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355
Randy Dunlapfe20e582007-04-11 23:28:41 -0700356 if (!val) {
357 printk(KERN_ERR "%s: missing param set value\n", kp->name);
358 return -EINVAL;
359 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 if (strlen(val)+1 > kps->maxlen) {
361 printk(KERN_ERR "%s: string doesn't fit in %u chars.\n",
362 kp->name, kps->maxlen-1);
363 return -ENOSPC;
364 }
365 strcpy(kps->string, val);
366 return 0;
367}
368
369int param_get_string(char *buffer, struct kernel_param *kp)
370{
Jan Beulich22e48ea2007-10-16 23:29:34 -0700371 const struct kparam_string *kps = kp->str;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 return strlcpy(buffer, kps->string, kps->maxlen);
373}
374
375/* sysfs output in /sys/modules/XYZ/parameters/ */
376
377extern struct kernel_param __start___param[], __stop___param[];
378
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379struct param_attribute
380{
381 struct module_attribute mattr;
382 struct kernel_param *param;
383};
384
385struct module_param_attrs
386{
387 struct attribute_group grp;
388 struct param_attribute attrs[0];
389};
390
Randy Dunlapef665c12007-02-13 15:19:06 -0800391#ifdef CONFIG_SYSFS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392#define to_param_attr(n) container_of(n, struct param_attribute, mattr);
393
394static ssize_t param_attr_show(struct module_attribute *mattr,
395 struct module *mod, char *buf)
396{
397 int count;
398 struct param_attribute *attribute = to_param_attr(mattr);
399
400 if (!attribute->param->get)
401 return -EPERM;
402
403 count = attribute->param->get(buf, attribute->param);
404 if (count > 0) {
405 strcat(buf, "\n");
406 ++count;
407 }
408 return count;
409}
410
411/* sysfs always hands a nul-terminated string in buf. We rely on that. */
412static ssize_t param_attr_store(struct module_attribute *mattr,
413 struct module *owner,
414 const char *buf, size_t len)
415{
416 int err;
417 struct param_attribute *attribute = to_param_attr(mattr);
418
419 if (!attribute->param->set)
420 return -EPERM;
421
422 err = attribute->param->set(buf, attribute->param);
423 if (!err)
424 return len;
425 return err;
426}
Randy Dunlapef665c12007-02-13 15:19:06 -0800427#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428
429#ifdef CONFIG_MODULES
430#define __modinit
431#else
432#define __modinit __init
433#endif
434
Randy Dunlapef665c12007-02-13 15:19:06 -0800435#ifdef CONFIG_SYSFS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436/*
437 * param_sysfs_setup - setup sysfs support for one module or KBUILD_MODNAME
438 * @mk: struct module_kobject (contains parent kobject)
439 * @kparam: array of struct kernel_param, the actual parameter definitions
440 * @num_params: number of entries in array
441 * @name_skip: offset where the parameter name start in kparam[].name. Needed for built-in "modules"
442 *
443 * Create a kobject for a (per-module) group of parameters, and create files
444 * in sysfs. A pointer to the param_kobject is returned on success,
445 * NULL if there's no parameter to export, or other ERR_PTR(err).
446 */
447static __modinit struct module_param_attrs *
448param_sysfs_setup(struct module_kobject *mk,
449 struct kernel_param *kparam,
450 unsigned int num_params,
451 unsigned int name_skip)
452{
453 struct module_param_attrs *mp;
454 unsigned int valid_attrs = 0;
455 unsigned int i, size[2];
456 struct param_attribute *pattr;
457 struct attribute **gattr;
458 int err;
459
460 for (i=0; i<num_params; i++) {
461 if (kparam[i].perm)
462 valid_attrs++;
463 }
464
465 if (!valid_attrs)
466 return NULL;
467
468 size[0] = ALIGN(sizeof(*mp) +
469 valid_attrs * sizeof(mp->attrs[0]),
470 sizeof(mp->grp.attrs[0]));
471 size[1] = (valid_attrs + 1) * sizeof(mp->grp.attrs[0]);
472
James Bottomleyd4acd722007-10-31 09:38:04 -0500473 mp = kzalloc(size[0] + size[1], GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 if (!mp)
475 return ERR_PTR(-ENOMEM);
476
477 mp->grp.name = "parameters";
478 mp->grp.attrs = (void *)mp + size[0];
479
480 pattr = &mp->attrs[0];
481 gattr = &mp->grp.attrs[0];
482 for (i = 0; i < num_params; i++) {
483 struct kernel_param *kp = &kparam[i];
484 if (kp->perm) {
485 pattr->param = kp;
486 pattr->mattr.show = param_attr_show;
487 pattr->mattr.store = param_attr_store;
488 pattr->mattr.attr.name = (char *)&kp->name[name_skip];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 pattr->mattr.attr.mode = kp->perm;
490 *(gattr++) = &(pattr++)->mattr.attr;
491 }
492 }
493 *gattr = NULL;
494
495 if ((err = sysfs_create_group(&mk->kobj, &mp->grp))) {
496 kfree(mp);
497 return ERR_PTR(err);
498 }
499 return mp;
500}
501
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502#ifdef CONFIG_MODULES
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503/*
504 * module_param_sysfs_setup - setup sysfs support for one module
505 * @mod: module
506 * @kparam: module parameters (array)
507 * @num_params: number of module parameters
508 *
509 * Adds sysfs entries for module parameters, and creates a link from
510 * /sys/module/[mod->name]/parameters to /sys/parameters/[mod->name]/
511 */
512int module_param_sysfs_setup(struct module *mod,
513 struct kernel_param *kparam,
514 unsigned int num_params)
515{
516 struct module_param_attrs *mp;
517
518 mp = param_sysfs_setup(&mod->mkobj, kparam, num_params, 0);
519 if (IS_ERR(mp))
520 return PTR_ERR(mp);
521
522 mod->param_attrs = mp;
523 return 0;
524}
525
526/*
527 * module_param_sysfs_remove - remove sysfs support for one module
528 * @mod: module
529 *
530 * Remove sysfs entries for module parameters and the corresponding
531 * kobject.
532 */
533void module_param_sysfs_remove(struct module *mod)
534{
535 if (mod->param_attrs) {
536 sysfs_remove_group(&mod->mkobj.kobj,
537 &mod->param_attrs->grp);
538 /* We are positive that no one is using any param
539 * attrs at this point. Deallocate immediately. */
540 kfree(mod->param_attrs);
541 mod->param_attrs = NULL;
542 }
543}
544#endif
545
546/*
547 * kernel_param_sysfs_setup - wrapper for built-in params support
548 */
549static void __init kernel_param_sysfs_setup(const char *name,
550 struct kernel_param *kparam,
551 unsigned int num_params,
552 unsigned int name_skip)
553{
554 struct module_kobject *mk;
Randy Dunlapd8c76492006-09-29 01:58:55 -0700555 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556
Pekka J Enbergdd392712005-09-06 15:18:31 -0700557 mk = kzalloc(sizeof(struct module_kobject), GFP_KERNEL);
558 BUG_ON(!mk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559
560 mk->mod = THIS_MODULE;
Greg Kroah-Hartman7405c1e2007-11-01 10:39:50 -0700561 mk->kobj.kset = module_kset;
Greg Kroah-Hartmane43b9192007-12-17 23:05:35 -0700562 ret = kobject_init_and_add(&mk->kobj, &module_ktype, NULL, "%s", name);
Greg Kroah-Hartman74c5b592007-07-30 11:26:38 -0700563 if (ret) {
Greg Kroah-Hartmane43b9192007-12-17 23:05:35 -0700564 kobject_put(&mk->kobj);
Greg Kroah-Hartman74c5b592007-07-30 11:26:38 -0700565 printk(KERN_ERR "Module '%s' failed to be added to sysfs, "
566 "error number %d\n", name, ret);
567 printk(KERN_ERR "The system will be unstable now.\n");
568 return;
569 }
Kay Sieversf30c53a2007-01-15 20:22:02 +0100570 param_sysfs_setup(mk, kparam, num_params, name_skip);
Kay Sieversf30c53a2007-01-15 20:22:02 +0100571 kobject_uevent(&mk->kobj, KOBJ_ADD);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572}
573
574/*
575 * param_sysfs_builtin - add contents in /sys/parameters for built-in modules
576 *
577 * Add module_parameters to sysfs for "modules" built into the kernel.
578 *
579 * The "module" name (KBUILD_MODNAME) is stored before a dot, the
580 * "parameter" name is stored behind a dot in kernel_param->name. So,
581 * extract the "module" name for all built-in kernel_param-eters,
582 * and for all who have the same, call kernel_param_sysfs_setup.
583 */
584static void __init param_sysfs_builtin(void)
585{
586 struct kernel_param *kp, *kp_begin = NULL;
587 unsigned int i, name_len, count = 0;
Rusty Russell730b69d2008-10-22 10:00:22 -0500588 char modname[MODULE_NAME_LEN] = "";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589
590 for (i=0; i < __stop___param - __start___param; i++) {
591 char *dot;
592
593 kp = &__start___param[i];
594
Rusty Russell730b69d2008-10-22 10:00:22 -0500595 dot = strchr(kp->name, '.');
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 if (!dot) {
Jan Kiszka22800a22007-11-14 17:00:08 -0800597 DEBUGP("couldn't find period in first %d characters "
Denis Cheng8686c992008-01-21 17:08:25 +0800598 "of %s\n", MODULE_NAME_LEN, kp->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 continue;
600 }
601 name_len = dot - kp->name;
602
603 /* new kbuild_modname? */
604 if (strlen(modname) != name_len
605 || strncmp(modname, kp->name, name_len) != 0) {
606 /* add a new kobject for previous kernel_params. */
607 if (count)
608 kernel_param_sysfs_setup(modname,
609 kp_begin,
610 count,
611 strlen(modname)+1);
612
613 strncpy(modname, kp->name, name_len);
614 modname[name_len] = '\0';
615 count = 0;
616 kp_begin = kp;
617 }
618 count++;
619 }
620
621 /* last kernel_params need to be registered as well */
622 if (count)
623 kernel_param_sysfs_setup(modname, kp_begin, count,
624 strlen(modname)+1);
625}
626
627
628/* module-related sysfs stuff */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629
630#define to_module_attr(n) container_of(n, struct module_attribute, attr);
631#define to_module_kobject(n) container_of(n, struct module_kobject, kobj);
632
633static ssize_t module_attr_show(struct kobject *kobj,
634 struct attribute *attr,
635 char *buf)
636{
637 struct module_attribute *attribute;
638 struct module_kobject *mk;
639 int ret;
640
641 attribute = to_module_attr(attr);
642 mk = to_module_kobject(kobj);
643
644 if (!attribute->show)
Dmitry Torokhov70f28172005-04-29 01:27:34 -0500645 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 ret = attribute->show(attribute, mk->mod, buf);
648
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 return ret;
650}
651
652static ssize_t module_attr_store(struct kobject *kobj,
653 struct attribute *attr,
654 const char *buf, size_t len)
655{
656 struct module_attribute *attribute;
657 struct module_kobject *mk;
658 int ret;
659
660 attribute = to_module_attr(attr);
661 mk = to_module_kobject(kobj);
662
663 if (!attribute->store)
Dmitry Torokhov70f28172005-04-29 01:27:34 -0500664 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 ret = attribute->store(attribute, mk->mod, buf, len);
667
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 return ret;
669}
670
671static struct sysfs_ops module_sysfs_ops = {
672 .show = module_attr_show,
673 .store = module_attr_store,
674};
675
Kay Sievers270a6c42007-01-18 13:26:15 +0100676static int uevent_filter(struct kset *kset, struct kobject *kobj)
677{
678 struct kobj_type *ktype = get_ktype(kobj);
679
680 if (ktype == &module_ktype)
681 return 1;
682 return 0;
683}
684
685static struct kset_uevent_ops module_uevent_ops = {
686 .filter = uevent_filter,
687};
688
Greg Kroah-Hartman7405c1e2007-11-01 10:39:50 -0700689struct kset *module_kset;
Greg Kroah-Hartman823bccf2007-04-13 13:15:19 -0700690int module_sysfs_initialized;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691
Greg Kroah-Hartman7405c1e2007-11-01 10:39:50 -0700692struct kobj_type module_ktype = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 .sysfs_ops = &module_sysfs_ops,
694};
695
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696/*
697 * param_sysfs_init - wrapper for built-in params support
698 */
699static int __init param_sysfs_init(void)
700{
Greg Kroah-Hartman7405c1e2007-11-01 10:39:50 -0700701 module_kset = kset_create_and_add("module", &module_uevent_ops, NULL);
702 if (!module_kset) {
703 printk(KERN_WARNING "%s (%d): error creating kset\n",
704 __FILE__, __LINE__);
705 return -ENOMEM;
Randy Dunlapd8c76492006-09-29 01:58:55 -0700706 }
Greg Kroah-Hartman823bccf2007-04-13 13:15:19 -0700707 module_sysfs_initialized = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708
709 param_sysfs_builtin();
710
711 return 0;
712}
Mark Huangd10be6d2006-09-29 01:59:34 -0700713subsys_initcall(param_sysfs_init);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714
Greg Kroah-Hartman7405c1e2007-11-01 10:39:50 -0700715#endif /* CONFIG_SYSFS */
Randy Dunlapef665c12007-02-13 15:19:06 -0800716
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717EXPORT_SYMBOL(param_set_byte);
718EXPORT_SYMBOL(param_get_byte);
719EXPORT_SYMBOL(param_set_short);
720EXPORT_SYMBOL(param_get_short);
721EXPORT_SYMBOL(param_set_ushort);
722EXPORT_SYMBOL(param_get_ushort);
723EXPORT_SYMBOL(param_set_int);
724EXPORT_SYMBOL(param_get_int);
725EXPORT_SYMBOL(param_set_uint);
726EXPORT_SYMBOL(param_get_uint);
727EXPORT_SYMBOL(param_set_long);
728EXPORT_SYMBOL(param_get_long);
729EXPORT_SYMBOL(param_set_ulong);
730EXPORT_SYMBOL(param_get_ulong);
731EXPORT_SYMBOL(param_set_charp);
732EXPORT_SYMBOL(param_get_charp);
733EXPORT_SYMBOL(param_set_bool);
734EXPORT_SYMBOL(param_get_bool);
735EXPORT_SYMBOL(param_set_invbool);
736EXPORT_SYMBOL(param_get_invbool);
737EXPORT_SYMBOL(param_array_set);
738EXPORT_SYMBOL(param_array_get);
739EXPORT_SYMBOL(param_set_copystring);
740EXPORT_SYMBOL(param_get_string);