Contents of /alx-src/tags/kernel26-2.6.12-alx-r9/kernel/params.c
Parent Directory | Revision Log
Revision 630 -
(show annotations)
(download)
Wed Mar 4 11:03:09 2009 UTC (15 years, 6 months ago) by niro
File MIME type: text/plain
File size: 17175 byte(s)
Wed Mar 4 11:03:09 2009 UTC (15 years, 6 months ago) by niro
File MIME type: text/plain
File size: 17175 byte(s)
Tag kernel26-2.6.12-alx-r9
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/config.h> |
19 | #include <linux/moduleparam.h> |
20 | #include <linux/kernel.h> |
21 | #include <linux/string.h> |
22 | #include <linux/errno.h> |
23 | #include <linux/module.h> |
24 | #include <linux/device.h> |
25 | #include <linux/err.h> |
26 | |
27 | #if 0 |
28 | #define DEBUGP printk |
29 | #else |
30 | #define DEBUGP(fmt, a...) |
31 | #endif |
32 | |
33 | static inline int dash2underscore(char c) |
34 | { |
35 | if (c == '-') |
36 | return '_'; |
37 | return c; |
38 | } |
39 | |
40 | static 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 | |
49 | static 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, ¶ms[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. */ |
77 | static 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 | |
83 | /* Chew any extra spaces */ |
84 | while (*args == ' ') args++; |
85 | if (*args == '"') { |
86 | args++; |
87 | in_quote = 1; |
88 | quoted = 1; |
89 | } |
90 | |
91 | for (i = 0; args[i]; i++) { |
92 | if (args[i] == ' ' && !in_quote) |
93 | break; |
94 | if (equals == 0) { |
95 | if (args[i] == '=') |
96 | equals = i; |
97 | } |
98 | if (args[i] == '"') |
99 | in_quote = !in_quote; |
100 | } |
101 | |
102 | *param = args; |
103 | if (!equals) |
104 | *val = NULL; |
105 | else { |
106 | args[equals] = '\0'; |
107 | *val = args + equals + 1; |
108 | |
109 | /* Don't include quotes in value. */ |
110 | if (**val == '"') { |
111 | (*val)++; |
112 | if (args[i-1] == '"') |
113 | args[i-1] = '\0'; |
114 | } |
115 | if (quoted && args[i-1] == '"') |
116 | args[i-1] = '\0'; |
117 | } |
118 | |
119 | if (args[i]) { |
120 | args[i] = '\0'; |
121 | next = args + i + 1; |
122 | } else |
123 | next = args + i; |
124 | return next; |
125 | } |
126 | |
127 | /* Args looks like "foo=bar,bar2 baz=fuz wiz". */ |
128 | int parse_args(const char *name, |
129 | char *args, |
130 | struct kernel_param *params, |
131 | unsigned num, |
132 | int (*unknown)(char *param, char *val)) |
133 | { |
134 | char *param, *val; |
135 | |
136 | DEBUGP("Parsing ARGS: %s\n", args); |
137 | |
138 | while (*args) { |
139 | int ret; |
140 | |
141 | args = next_arg(args, ¶m, &val); |
142 | ret = parse_one(param, val, params, num, unknown); |
143 | switch (ret) { |
144 | case -ENOENT: |
145 | printk(KERN_ERR "%s: Unknown parameter `%s'\n", |
146 | name, param); |
147 | return ret; |
148 | case -ENOSPC: |
149 | printk(KERN_ERR |
150 | "%s: `%s' too large for parameter `%s'\n", |
151 | name, val ?: "", param); |
152 | return ret; |
153 | case 0: |
154 | break; |
155 | default: |
156 | printk(KERN_ERR |
157 | "%s: `%s' invalid for parameter `%s'\n", |
158 | name, val ?: "", param); |
159 | return ret; |
160 | } |
161 | } |
162 | |
163 | /* All parsed OK. */ |
164 | return 0; |
165 | } |
166 | |
167 | /* Lazy bastard, eh? */ |
168 | #define STANDARD_PARAM_DEF(name, type, format, tmptype, strtolfn) \ |
169 | int param_set_##name(const char *val, struct kernel_param *kp) \ |
170 | { \ |
171 | char *endp; \ |
172 | tmptype l; \ |
173 | \ |
174 | if (!val) return -EINVAL; \ |
175 | l = strtolfn(val, &endp, 0); \ |
176 | if (endp == val || ((type)l != l)) \ |
177 | return -EINVAL; \ |
178 | *((type *)kp->arg) = l; \ |
179 | return 0; \ |
180 | } \ |
181 | int param_get_##name(char *buffer, struct kernel_param *kp) \ |
182 | { \ |
183 | return sprintf(buffer, format, *((type *)kp->arg)); \ |
184 | } |
185 | |
186 | STANDARD_PARAM_DEF(byte, unsigned char, "%c", unsigned long, simple_strtoul); |
187 | STANDARD_PARAM_DEF(short, short, "%hi", long, simple_strtol); |
188 | STANDARD_PARAM_DEF(ushort, unsigned short, "%hu", unsigned long, simple_strtoul); |
189 | STANDARD_PARAM_DEF(int, int, "%i", long, simple_strtol); |
190 | STANDARD_PARAM_DEF(uint, unsigned int, "%u", unsigned long, simple_strtoul); |
191 | STANDARD_PARAM_DEF(long, long, "%li", long, simple_strtol); |
192 | STANDARD_PARAM_DEF(ulong, unsigned long, "%lu", unsigned long, simple_strtoul); |
193 | |
194 | int param_set_charp(const char *val, struct kernel_param *kp) |
195 | { |
196 | if (!val) { |
197 | printk(KERN_ERR "%s: string parameter expected\n", |
198 | kp->name); |
199 | return -EINVAL; |
200 | } |
201 | |
202 | if (strlen(val) > 1024) { |
203 | printk(KERN_ERR "%s: string parameter too long\n", |
204 | kp->name); |
205 | return -ENOSPC; |
206 | } |
207 | |
208 | *(char **)kp->arg = (char *)val; |
209 | return 0; |
210 | } |
211 | |
212 | int param_get_charp(char *buffer, struct kernel_param *kp) |
213 | { |
214 | return sprintf(buffer, "%s", *((char **)kp->arg)); |
215 | } |
216 | |
217 | int param_set_bool(const char *val, struct kernel_param *kp) |
218 | { |
219 | /* No equals means "set"... */ |
220 | if (!val) val = "1"; |
221 | |
222 | /* One of =[yYnN01] */ |
223 | switch (val[0]) { |
224 | case 'y': case 'Y': case '1': |
225 | *(int *)kp->arg = 1; |
226 | return 0; |
227 | case 'n': case 'N': case '0': |
228 | *(int *)kp->arg = 0; |
229 | return 0; |
230 | } |
231 | return -EINVAL; |
232 | } |
233 | |
234 | int param_get_bool(char *buffer, struct kernel_param *kp) |
235 | { |
236 | /* Y and N chosen as being relatively non-coder friendly */ |
237 | return sprintf(buffer, "%c", (*(int *)kp->arg) ? 'Y' : 'N'); |
238 | } |
239 | |
240 | int param_set_invbool(const char *val, struct kernel_param *kp) |
241 | { |
242 | int boolval, ret; |
243 | struct kernel_param dummy = { .arg = &boolval }; |
244 | |
245 | ret = param_set_bool(val, &dummy); |
246 | if (ret == 0) |
247 | *(int *)kp->arg = !boolval; |
248 | return ret; |
249 | } |
250 | |
251 | int param_get_invbool(char *buffer, struct kernel_param *kp) |
252 | { |
253 | int val; |
254 | struct kernel_param dummy = { .arg = &val }; |
255 | |
256 | val = !*(int *)kp->arg; |
257 | return param_get_bool(buffer, &dummy); |
258 | } |
259 | |
260 | /* We cheat here and temporarily mangle the string. */ |
261 | int param_array(const char *name, |
262 | const char *val, |
263 | unsigned int min, unsigned int max, |
264 | void *elem, int elemsize, |
265 | int (*set)(const char *, struct kernel_param *kp), |
266 | int *num) |
267 | { |
268 | int ret; |
269 | struct kernel_param kp; |
270 | char save; |
271 | |
272 | /* Get the name right for errors. */ |
273 | kp.name = name; |
274 | kp.arg = elem; |
275 | |
276 | /* No equals sign? */ |
277 | if (!val) { |
278 | printk(KERN_ERR "%s: expects arguments\n", name); |
279 | return -EINVAL; |
280 | } |
281 | |
282 | *num = 0; |
283 | /* We expect a comma-separated list of values. */ |
284 | do { |
285 | int len; |
286 | |
287 | if (*num == max) { |
288 | printk(KERN_ERR "%s: can only take %i arguments\n", |
289 | name, max); |
290 | return -EINVAL; |
291 | } |
292 | len = strcspn(val, ","); |
293 | |
294 | /* nul-terminate and parse */ |
295 | save = val[len]; |
296 | ((char *)val)[len] = '\0'; |
297 | ret = set(val, &kp); |
298 | |
299 | if (ret != 0) |
300 | return ret; |
301 | kp.arg += elemsize; |
302 | val += len+1; |
303 | (*num)++; |
304 | } while (save == ','); |
305 | |
306 | if (*num < min) { |
307 | printk(KERN_ERR "%s: needs at least %i arguments\n", |
308 | name, min); |
309 | return -EINVAL; |
310 | } |
311 | return 0; |
312 | } |
313 | |
314 | int param_array_set(const char *val, struct kernel_param *kp) |
315 | { |
316 | struct kparam_array *arr = kp->arg; |
317 | unsigned int temp_num; |
318 | |
319 | return param_array(kp->name, val, 1, arr->max, arr->elem, |
320 | arr->elemsize, arr->set, arr->num ?: &temp_num); |
321 | } |
322 | |
323 | int param_array_get(char *buffer, struct kernel_param *kp) |
324 | { |
325 | int i, off, ret; |
326 | struct kparam_array *arr = kp->arg; |
327 | struct kernel_param p; |
328 | |
329 | p = *kp; |
330 | for (i = off = 0; i < (arr->num ? *arr->num : arr->max); i++) { |
331 | if (i) |
332 | buffer[off++] = ','; |
333 | p.arg = arr->elem + arr->elemsize * i; |
334 | ret = arr->get(buffer + off, &p); |
335 | if (ret < 0) |
336 | return ret; |
337 | off += ret; |
338 | } |
339 | buffer[off] = '\0'; |
340 | return off; |
341 | } |
342 | |
343 | int param_set_copystring(const char *val, struct kernel_param *kp) |
344 | { |
345 | struct kparam_string *kps = kp->arg; |
346 | |
347 | if (strlen(val)+1 > kps->maxlen) { |
348 | printk(KERN_ERR "%s: string doesn't fit in %u chars.\n", |
349 | kp->name, kps->maxlen-1); |
350 | return -ENOSPC; |
351 | } |
352 | strcpy(kps->string, val); |
353 | return 0; |
354 | } |
355 | |
356 | int param_get_string(char *buffer, struct kernel_param *kp) |
357 | { |
358 | struct kparam_string *kps = kp->arg; |
359 | return strlcpy(buffer, kps->string, kps->maxlen); |
360 | } |
361 | |
362 | /* sysfs output in /sys/modules/XYZ/parameters/ */ |
363 | |
364 | extern struct kernel_param __start___param[], __stop___param[]; |
365 | |
366 | #define MAX_KBUILD_MODNAME KOBJ_NAME_LEN |
367 | |
368 | struct param_attribute |
369 | { |
370 | struct module_attribute mattr; |
371 | struct kernel_param *param; |
372 | }; |
373 | |
374 | struct module_param_attrs |
375 | { |
376 | struct attribute_group grp; |
377 | struct param_attribute attrs[0]; |
378 | }; |
379 | |
380 | #define to_param_attr(n) container_of(n, struct param_attribute, mattr); |
381 | |
382 | static ssize_t param_attr_show(struct module_attribute *mattr, |
383 | struct module *mod, char *buf) |
384 | { |
385 | int count; |
386 | struct param_attribute *attribute = to_param_attr(mattr); |
387 | |
388 | if (!attribute->param->get) |
389 | return -EPERM; |
390 | |
391 | count = attribute->param->get(buf, attribute->param); |
392 | if (count > 0) { |
393 | strcat(buf, "\n"); |
394 | ++count; |
395 | } |
396 | return count; |
397 | } |
398 | |
399 | /* sysfs always hands a nul-terminated string in buf. We rely on that. */ |
400 | static ssize_t param_attr_store(struct module_attribute *mattr, |
401 | struct module *owner, |
402 | const char *buf, size_t len) |
403 | { |
404 | int err; |
405 | struct param_attribute *attribute = to_param_attr(mattr); |
406 | |
407 | if (!attribute->param->set) |
408 | return -EPERM; |
409 | |
410 | err = attribute->param->set(buf, attribute->param); |
411 | if (!err) |
412 | return len; |
413 | return err; |
414 | } |
415 | |
416 | #ifdef CONFIG_MODULES |
417 | #define __modinit |
418 | #else |
419 | #define __modinit __init |
420 | #endif |
421 | |
422 | /* |
423 | * param_sysfs_setup - setup sysfs support for one module or KBUILD_MODNAME |
424 | * @mk: struct module_kobject (contains parent kobject) |
425 | * @kparam: array of struct kernel_param, the actual parameter definitions |
426 | * @num_params: number of entries in array |
427 | * @name_skip: offset where the parameter name start in kparam[].name. Needed for built-in "modules" |
428 | * |
429 | * Create a kobject for a (per-module) group of parameters, and create files |
430 | * in sysfs. A pointer to the param_kobject is returned on success, |
431 | * NULL if there's no parameter to export, or other ERR_PTR(err). |
432 | */ |
433 | static __modinit struct module_param_attrs * |
434 | param_sysfs_setup(struct module_kobject *mk, |
435 | struct kernel_param *kparam, |
436 | unsigned int num_params, |
437 | unsigned int name_skip) |
438 | { |
439 | struct module_param_attrs *mp; |
440 | unsigned int valid_attrs = 0; |
441 | unsigned int i, size[2]; |
442 | struct param_attribute *pattr; |
443 | struct attribute **gattr; |
444 | int err; |
445 | |
446 | for (i=0; i<num_params; i++) { |
447 | if (kparam[i].perm) |
448 | valid_attrs++; |
449 | } |
450 | |
451 | if (!valid_attrs) |
452 | return NULL; |
453 | |
454 | size[0] = ALIGN(sizeof(*mp) + |
455 | valid_attrs * sizeof(mp->attrs[0]), |
456 | sizeof(mp->grp.attrs[0])); |
457 | size[1] = (valid_attrs + 1) * sizeof(mp->grp.attrs[0]); |
458 | |
459 | mp = kmalloc(size[0] + size[1], GFP_KERNEL); |
460 | if (!mp) |
461 | return ERR_PTR(-ENOMEM); |
462 | |
463 | mp->grp.name = "parameters"; |
464 | mp->grp.attrs = (void *)mp + size[0]; |
465 | |
466 | pattr = &mp->attrs[0]; |
467 | gattr = &mp->grp.attrs[0]; |
468 | for (i = 0; i < num_params; i++) { |
469 | struct kernel_param *kp = &kparam[i]; |
470 | if (kp->perm) { |
471 | pattr->param = kp; |
472 | pattr->mattr.show = param_attr_show; |
473 | pattr->mattr.store = param_attr_store; |
474 | pattr->mattr.attr.name = (char *)&kp->name[name_skip]; |
475 | pattr->mattr.attr.owner = mk->mod; |
476 | pattr->mattr.attr.mode = kp->perm; |
477 | *(gattr++) = &(pattr++)->mattr.attr; |
478 | } |
479 | } |
480 | *gattr = NULL; |
481 | |
482 | if ((err = sysfs_create_group(&mk->kobj, &mp->grp))) { |
483 | kfree(mp); |
484 | return ERR_PTR(err); |
485 | } |
486 | return mp; |
487 | } |
488 | |
489 | |
490 | #ifdef CONFIG_MODULES |
491 | |
492 | /* |
493 | * module_param_sysfs_setup - setup sysfs support for one module |
494 | * @mod: module |
495 | * @kparam: module parameters (array) |
496 | * @num_params: number of module parameters |
497 | * |
498 | * Adds sysfs entries for module parameters, and creates a link from |
499 | * /sys/module/[mod->name]/parameters to /sys/parameters/[mod->name]/ |
500 | */ |
501 | int module_param_sysfs_setup(struct module *mod, |
502 | struct kernel_param *kparam, |
503 | unsigned int num_params) |
504 | { |
505 | struct module_param_attrs *mp; |
506 | |
507 | mp = param_sysfs_setup(&mod->mkobj, kparam, num_params, 0); |
508 | if (IS_ERR(mp)) |
509 | return PTR_ERR(mp); |
510 | |
511 | mod->param_attrs = mp; |
512 | return 0; |
513 | } |
514 | |
515 | /* |
516 | * module_param_sysfs_remove - remove sysfs support for one module |
517 | * @mod: module |
518 | * |
519 | * Remove sysfs entries for module parameters and the corresponding |
520 | * kobject. |
521 | */ |
522 | void module_param_sysfs_remove(struct module *mod) |
523 | { |
524 | if (mod->param_attrs) { |
525 | sysfs_remove_group(&mod->mkobj.kobj, |
526 | &mod->param_attrs->grp); |
527 | /* We are positive that no one is using any param |
528 | * attrs at this point. Deallocate immediately. */ |
529 | kfree(mod->param_attrs); |
530 | mod->param_attrs = NULL; |
531 | } |
532 | } |
533 | #endif |
534 | |
535 | /* |
536 | * kernel_param_sysfs_setup - wrapper for built-in params support |
537 | */ |
538 | static void __init kernel_param_sysfs_setup(const char *name, |
539 | struct kernel_param *kparam, |
540 | unsigned int num_params, |
541 | unsigned int name_skip) |
542 | { |
543 | struct module_kobject *mk; |
544 | |
545 | mk = kmalloc(sizeof(struct module_kobject), GFP_KERNEL); |
546 | memset(mk, 0, sizeof(struct module_kobject)); |
547 | |
548 | mk->mod = THIS_MODULE; |
549 | kobj_set_kset_s(mk, module_subsys); |
550 | kobject_set_name(&mk->kobj, name); |
551 | kobject_register(&mk->kobj); |
552 | |
553 | /* no need to keep the kobject if no parameter is exported */ |
554 | if (!param_sysfs_setup(mk, kparam, num_params, name_skip)) { |
555 | kobject_unregister(&mk->kobj); |
556 | kfree(mk); |
557 | } |
558 | } |
559 | |
560 | /* |
561 | * param_sysfs_builtin - add contents in /sys/parameters for built-in modules |
562 | * |
563 | * Add module_parameters to sysfs for "modules" built into the kernel. |
564 | * |
565 | * The "module" name (KBUILD_MODNAME) is stored before a dot, the |
566 | * "parameter" name is stored behind a dot in kernel_param->name. So, |
567 | * extract the "module" name for all built-in kernel_param-eters, |
568 | * and for all who have the same, call kernel_param_sysfs_setup. |
569 | */ |
570 | static void __init param_sysfs_builtin(void) |
571 | { |
572 | struct kernel_param *kp, *kp_begin = NULL; |
573 | unsigned int i, name_len, count = 0; |
574 | char modname[MAX_KBUILD_MODNAME + 1] = ""; |
575 | |
576 | for (i=0; i < __stop___param - __start___param; i++) { |
577 | char *dot; |
578 | |
579 | kp = &__start___param[i]; |
580 | |
581 | /* We do not handle args without periods. */ |
582 | dot = memchr(kp->name, '.', MAX_KBUILD_MODNAME); |
583 | if (!dot) { |
584 | DEBUGP("couldn't find period in %s\n", kp->name); |
585 | continue; |
586 | } |
587 | name_len = dot - kp->name; |
588 | |
589 | /* new kbuild_modname? */ |
590 | if (strlen(modname) != name_len |
591 | || strncmp(modname, kp->name, name_len) != 0) { |
592 | /* add a new kobject for previous kernel_params. */ |
593 | if (count) |
594 | kernel_param_sysfs_setup(modname, |
595 | kp_begin, |
596 | count, |
597 | strlen(modname)+1); |
598 | |
599 | strncpy(modname, kp->name, name_len); |
600 | modname[name_len] = '\0'; |
601 | count = 0; |
602 | kp_begin = kp; |
603 | } |
604 | count++; |
605 | } |
606 | |
607 | /* last kernel_params need to be registered as well */ |
608 | if (count) |
609 | kernel_param_sysfs_setup(modname, kp_begin, count, |
610 | strlen(modname)+1); |
611 | } |
612 | |
613 | |
614 | /* module-related sysfs stuff */ |
615 | #ifdef CONFIG_MODULES |
616 | |
617 | #define to_module_attr(n) container_of(n, struct module_attribute, attr); |
618 | #define to_module_kobject(n) container_of(n, struct module_kobject, kobj); |
619 | |
620 | static ssize_t module_attr_show(struct kobject *kobj, |
621 | struct attribute *attr, |
622 | char *buf) |
623 | { |
624 | struct module_attribute *attribute; |
625 | struct module_kobject *mk; |
626 | int ret; |
627 | |
628 | attribute = to_module_attr(attr); |
629 | mk = to_module_kobject(kobj); |
630 | |
631 | if (!attribute->show) |
632 | return -EPERM; |
633 | |
634 | if (!try_module_get(mk->mod)) |
635 | return -ENODEV; |
636 | |
637 | ret = attribute->show(attribute, mk->mod, buf); |
638 | |
639 | module_put(mk->mod); |
640 | |
641 | return ret; |
642 | } |
643 | |
644 | static ssize_t module_attr_store(struct kobject *kobj, |
645 | struct attribute *attr, |
646 | const char *buf, size_t len) |
647 | { |
648 | struct module_attribute *attribute; |
649 | struct module_kobject *mk; |
650 | int ret; |
651 | |
652 | attribute = to_module_attr(attr); |
653 | mk = to_module_kobject(kobj); |
654 | |
655 | if (!attribute->store) |
656 | return -EPERM; |
657 | |
658 | if (!try_module_get(mk->mod)) |
659 | return -ENODEV; |
660 | |
661 | ret = attribute->store(attribute, mk->mod, buf, len); |
662 | |
663 | module_put(mk->mod); |
664 | |
665 | return ret; |
666 | } |
667 | |
668 | static struct sysfs_ops module_sysfs_ops = { |
669 | .show = module_attr_show, |
670 | .store = module_attr_store, |
671 | }; |
672 | |
673 | #else |
674 | static struct sysfs_ops module_sysfs_ops = { |
675 | .show = NULL, |
676 | .store = NULL, |
677 | }; |
678 | #endif |
679 | |
680 | static struct kobj_type module_ktype = { |
681 | .sysfs_ops = &module_sysfs_ops, |
682 | }; |
683 | |
684 | decl_subsys(module, &module_ktype, NULL); |
685 | |
686 | /* |
687 | * param_sysfs_init - wrapper for built-in params support |
688 | */ |
689 | static int __init param_sysfs_init(void) |
690 | { |
691 | subsystem_register(&module_subsys); |
692 | |
693 | param_sysfs_builtin(); |
694 | |
695 | return 0; |
696 | } |
697 | __initcall(param_sysfs_init); |
698 | |
699 | EXPORT_SYMBOL(param_set_byte); |
700 | EXPORT_SYMBOL(param_get_byte); |
701 | EXPORT_SYMBOL(param_set_short); |
702 | EXPORT_SYMBOL(param_get_short); |
703 | EXPORT_SYMBOL(param_set_ushort); |
704 | EXPORT_SYMBOL(param_get_ushort); |
705 | EXPORT_SYMBOL(param_set_int); |
706 | EXPORT_SYMBOL(param_get_int); |
707 | EXPORT_SYMBOL(param_set_uint); |
708 | EXPORT_SYMBOL(param_get_uint); |
709 | EXPORT_SYMBOL(param_set_long); |
710 | EXPORT_SYMBOL(param_get_long); |
711 | EXPORT_SYMBOL(param_set_ulong); |
712 | EXPORT_SYMBOL(param_get_ulong); |
713 | EXPORT_SYMBOL(param_set_charp); |
714 | EXPORT_SYMBOL(param_get_charp); |
715 | EXPORT_SYMBOL(param_set_bool); |
716 | EXPORT_SYMBOL(param_get_bool); |
717 | EXPORT_SYMBOL(param_set_invbool); |
718 | EXPORT_SYMBOL(param_get_invbool); |
719 | EXPORT_SYMBOL(param_array_set); |
720 | EXPORT_SYMBOL(param_array_get); |
721 | EXPORT_SYMBOL(param_set_copystring); |
722 | EXPORT_SYMBOL(param_get_string); |