]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - kernel/params.c
Merge branch 'locking/urgent' into locking/core, to pick up fixes before applying...
[mirror_ubuntu-bionic-kernel.git] / kernel / params.c
CommitLineData
1da177e4
LT
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*/
1da177e4
LT
18#include <linux/kernel.h>
19#include <linux/string.h>
20#include <linux/errno.h>
21#include <linux/module.h>
63a12d9d 22#include <linux/moduleparam.h>
1da177e4
LT
23#include <linux/device.h>
24#include <linux/err.h>
4e57b681 25#include <linux/slab.h>
26d052bf 26#include <linux/ctype.h>
1da177e4 27
cf2fde7b 28#ifdef CONFIG_SYSFS
b51d23e4 29/* Protects all built-in parameters, modules use their own param_lock */
907b29eb
RR
30static DEFINE_MUTEX(param_lock);
31
b51d23e4 32/* Use the module's mutex, or if built-in use the built-in mutex */
20bdc2cf 33#ifdef CONFIG_MODULES
b51d23e4 34#define KPARAM_MUTEX(mod) ((mod) ? &(mod)->param_lock : &param_lock)
20bdc2cf
SR
35#else
36#define KPARAM_MUTEX(mod) (&param_lock)
37#endif
cf2fde7b
RR
38
39static inline void check_kparam_locked(struct module *mod)
40{
41 BUG_ON(!mutex_is_locked(KPARAM_MUTEX(mod)));
42}
43#else
44static inline void check_kparam_locked(struct module *mod)
45{
46}
47#endif /* !CONFIG_SYSFS */
b51d23e4 48
a1054322
RR
49/* This just allows us to keep track of which parameters are kmalloced. */
50struct kmalloced_param {
51 struct list_head list;
52 char val[];
53};
a1054322 54static LIST_HEAD(kmalloced_params);
b51d23e4 55static DEFINE_SPINLOCK(kmalloced_params_lock);
a1054322
RR
56
57static 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
b51d23e4 65 spin_lock(&kmalloced_params_lock);
a1054322 66 list_add(&p->list, &kmalloced_params);
b51d23e4
DS
67 spin_unlock(&kmalloced_params_lock);
68
a1054322
RR
69 return p->val;
70}
71
72/* Does nothing if parameter wasn't kmalloced above. */
73static void maybe_kfree_parameter(void *param)
74{
75 struct kmalloced_param *p;
76
b51d23e4 77 spin_lock(&kmalloced_params_lock);
a1054322
RR
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 }
b51d23e4 85 spin_unlock(&kmalloced_params_lock);
a1054322
RR
86}
87
b1e4d20c 88static char dash2underscore(char c)
1da177e4
LT
89{
90 if (c == '-')
91 return '_';
92 return c;
93}
94
b1e4d20c 95bool parameqn(const char *a, const char *b, size_t n)
1da177e4 96{
b1e4d20c
MS
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
106bool parameq(const char *a, const char *b)
107{
108 return parameqn(a, b, strlen(a)+1);
1da177e4
LT
109}
110
7a486d37
RR
111static void param_check_unsafe(const struct kernel_param *kp)
112{
113 if (kp->flags & KERNEL_PARAM_FL_UNSAFE) {
114 pr_warn("Setting dangerous option %s - tainting kernel\n",
115 kp->name);
116 add_taint(TAINT_USER, LOCKDEP_STILL_OK);
117 }
118}
119
1da177e4
LT
120static int parse_one(char *param,
121 char *val,
9fb48c74 122 const char *doing,
914dcaa8 123 const struct kernel_param *params,
1da177e4 124 unsigned num_params,
026cee00
PM
125 s16 min_level,
126 s16 max_level,
ecc86170 127 void *arg,
9fb48c74 128 int (*handle_unknown)(char *param, char *val,
ecc86170 129 const char *doing, void *arg))
1da177e4
LT
130{
131 unsigned int i;
907b29eb 132 int err;
1da177e4
LT
133
134 /* Find parameter */
135 for (i = 0; i < num_params; i++) {
136 if (parameq(param, params[i].name)) {
026cee00
PM
137 if (params[i].level < min_level
138 || params[i].level > max_level)
139 return 0;
25985edc 140 /* No one handled NULL, so do it here. */
ab013c5f 141 if (!val &&
6a4c2643 142 !(params[i].ops->flags & KERNEL_PARAM_OPS_FL_NOARG))
2e9fb995 143 return -EINVAL;
9fb48c74
JC
144 pr_debug("handling %s with %p\n", param,
145 params[i].ops->set);
b51d23e4 146 kernel_param_lock(params[i].mod);
7a486d37 147 param_check_unsafe(&params[i]);
907b29eb 148 err = params[i].ops->set(val, &params[i]);
b51d23e4 149 kernel_param_unlock(params[i].mod);
907b29eb 150 return err;
1da177e4
LT
151 }
152 }
153
154 if (handle_unknown) {
9fb48c74 155 pr_debug("doing %s: %s='%s'\n", doing, param, val);
ecc86170 156 return handle_unknown(param, val, doing, arg);
1da177e4
LT
157 }
158
9fb48c74 159 pr_debug("Unknown argument '%s'\n", param);
1da177e4
LT
160 return -ENOENT;
161}
162
163/* You can use " around spaces, but can't escape ". */
164/* Hyphens and underscores equivalent in parameter names. */
165static char *next_arg(char *args, char **param, char **val)
166{
167 unsigned int i, equals = 0;
168 int in_quote = 0, quoted = 0;
169 char *next;
170
1da177e4
LT
171 if (*args == '"') {
172 args++;
173 in_quote = 1;
174 quoted = 1;
175 }
176
177 for (i = 0; args[i]; i++) {
26d052bf 178 if (isspace(args[i]) && !in_quote)
1da177e4
LT
179 break;
180 if (equals == 0) {
181 if (args[i] == '=')
182 equals = i;
183 }
184 if (args[i] == '"')
185 in_quote = !in_quote;
186 }
187
188 *param = args;
189 if (!equals)
190 *val = NULL;
191 else {
192 args[equals] = '\0';
193 *val = args + equals + 1;
194
195 /* Don't include quotes in value. */
196 if (**val == '"') {
197 (*val)++;
198 if (args[i-1] == '"')
199 args[i-1] = '\0';
200 }
1da177e4 201 }
b9cc4489
RR
202 if (quoted && args[i-1] == '"')
203 args[i-1] = '\0';
1da177e4
LT
204
205 if (args[i]) {
206 args[i] = '\0';
207 next = args + i + 1;
208 } else
209 next = args + i;
f36462f0
RR
210
211 /* Chew up trailing spaces. */
e7d2860b 212 return skip_spaces(next);
1da177e4
LT
213}
214
215/* Args looks like "foo=bar,bar2 baz=fuz wiz". */
51e158c1
RR
216char *parse_args(const char *doing,
217 char *args,
218 const struct kernel_param *params,
219 unsigned num,
220 s16 min_level,
221 s16 max_level,
ecc86170
LR
222 void *arg,
223 int (*unknown)(char *param, char *val,
224 const char *doing, void *arg))
1da177e4
LT
225{
226 char *param, *val;
227
f36462f0 228 /* Chew leading spaces */
e7d2860b 229 args = skip_spaces(args);
f36462f0 230
1ef9eaf2 231 if (*args)
9fb48c74
JC
232 pr_debug("doing %s, parsing ARGS: '%s'\n", doing, args);
233
1da177e4
LT
234 while (*args) {
235 int ret;
a416aba6 236 int irq_was_disabled;
1da177e4
LT
237
238 args = next_arg(args, &param, &val);
51e158c1
RR
239 /* Stop at -- */
240 if (!val && strcmp(param, "--") == 0)
241 return args;
a416aba6 242 irq_was_disabled = irqs_disabled();
9fb48c74 243 ret = parse_one(param, val, doing, params, num,
ecc86170 244 min_level, max_level, arg, unknown);
b5f3abf9
JC
245 if (irq_was_disabled && !irqs_disabled())
246 pr_warn("%s: option '%s' enabled irq's!\n",
247 doing, param);
248
1da177e4
LT
249 switch (ret) {
250 case -ENOENT:
b5f3abf9 251 pr_err("%s: Unknown parameter `%s'\n", doing, param);
51e158c1 252 return ERR_PTR(ret);
1da177e4 253 case -ENOSPC:
b5f3abf9 254 pr_err("%s: `%s' too large for parameter `%s'\n",
9fb48c74 255 doing, val ?: "", param);
51e158c1 256 return ERR_PTR(ret);
1da177e4
LT
257 case 0:
258 break;
259 default:
b5f3abf9 260 pr_err("%s: `%s' invalid for parameter `%s'\n",
9fb48c74 261 doing, val ?: "", param);
51e158c1 262 return ERR_PTR(ret);
1da177e4
LT
263 }
264 }
265
266 /* All parsed OK. */
51e158c1 267 return NULL;
1da177e4
LT
268}
269
270/* Lazy bastard, eh? */
88a88b32 271#define STANDARD_PARAM_DEF(name, type, format, strtolfn) \
9bbb9e5a 272 int param_set_##name(const char *val, const struct kernel_param *kp) \
1da177e4 273 { \
88a88b32 274 return strtolfn(val, 0, (type *)kp->arg); \
1da177e4 275 } \
9bbb9e5a 276 int param_get_##name(char *buffer, const struct kernel_param *kp) \
1da177e4 277 { \
f4940ab7
CG
278 return scnprintf(buffer, PAGE_SIZE, format, \
279 *((type *)kp->arg)); \
a14fe249 280 } \
9c27847d 281 const struct kernel_param_ops param_ops_##name = { \
9bbb9e5a
RR
282 .set = param_set_##name, \
283 .get = param_get_##name, \
284 }; \
a14fe249 285 EXPORT_SYMBOL(param_set_##name); \
9bbb9e5a
RR
286 EXPORT_SYMBOL(param_get_##name); \
287 EXPORT_SYMBOL(param_ops_##name)
288
1da177e4 289
88a88b32
FC
290STANDARD_PARAM_DEF(byte, unsigned char, "%hhu", kstrtou8);
291STANDARD_PARAM_DEF(short, short, "%hi", kstrtos16);
292STANDARD_PARAM_DEF(ushort, unsigned short, "%hu", kstrtou16);
293STANDARD_PARAM_DEF(int, int, "%i", kstrtoint);
294STANDARD_PARAM_DEF(uint, unsigned int, "%u", kstrtouint);
295STANDARD_PARAM_DEF(long, long, "%li", kstrtol);
296STANDARD_PARAM_DEF(ulong, unsigned long, "%lu", kstrtoul);
b4210b81 297STANDARD_PARAM_DEF(ullong, unsigned long long, "%llu", kstrtoull);
1da177e4 298
9bbb9e5a 299int param_set_charp(const char *val, const struct kernel_param *kp)
1da177e4 300{
1da177e4 301 if (strlen(val) > 1024) {
b5f3abf9 302 pr_err("%s: string parameter too long\n", kp->name);
1da177e4
LT
303 return -ENOSPC;
304 }
305
a1054322
RR
306 maybe_kfree_parameter(*(char **)kp->arg);
307
308 /* This is a hack. We can't kmalloc in early boot, and we
e180a6b7
RR
309 * don't need to; this mangled commandline is preserved. */
310 if (slab_is_available()) {
a1054322 311 *(char **)kp->arg = kmalloc_parameter(strlen(val)+1);
d553ad86 312 if (!*(char **)kp->arg)
e180a6b7 313 return -ENOMEM;
a1054322 314 strcpy(*(char **)kp->arg, val);
e180a6b7
RR
315 } else
316 *(const char **)kp->arg = val;
317
1da177e4
LT
318 return 0;
319}
a14fe249 320EXPORT_SYMBOL(param_set_charp);
1da177e4 321
9bbb9e5a 322int param_get_charp(char *buffer, const struct kernel_param *kp)
1da177e4 323{
f4940ab7 324 return scnprintf(buffer, PAGE_SIZE, "%s", *((char **)kp->arg));
1da177e4 325}
a14fe249 326EXPORT_SYMBOL(param_get_charp);
1da177e4 327
a1054322
RR
328static void param_free_charp(void *arg)
329{
330 maybe_kfree_parameter(*((char **)arg));
331}
332
9c27847d 333const struct kernel_param_ops param_ops_charp = {
9bbb9e5a
RR
334 .set = param_set_charp,
335 .get = param_get_charp,
a1054322 336 .free = param_free_charp,
9bbb9e5a
RR
337};
338EXPORT_SYMBOL(param_ops_charp);
339
fddd5201 340/* Actually could be a bool or an int, for historical reasons. */
9bbb9e5a 341int param_set_bool(const char *val, const struct kernel_param *kp)
1da177e4
LT
342{
343 /* No equals means "set"... */
344 if (!val) val = "1";
345
346 /* One of =[yYnN01] */
8b825281 347 return strtobool(val, kp->arg);
1da177e4 348}
a14fe249 349EXPORT_SYMBOL(param_set_bool);
1da177e4 350
9bbb9e5a 351int param_get_bool(char *buffer, const struct kernel_param *kp)
1da177e4
LT
352{
353 /* Y and N chosen as being relatively non-coder friendly */
8b825281 354 return sprintf(buffer, "%c", *(bool *)kp->arg ? 'Y' : 'N');
1da177e4 355}
a14fe249 356EXPORT_SYMBOL(param_get_bool);
1da177e4 357
9c27847d 358const struct kernel_param_ops param_ops_bool = {
6a4c2643 359 .flags = KERNEL_PARAM_OPS_FL_NOARG,
9bbb9e5a
RR
360 .set = param_set_bool,
361 .get = param_get_bool,
362};
363EXPORT_SYMBOL(param_ops_bool);
364
d19f05d8
LR
365int param_set_bool_enable_only(const char *val, const struct kernel_param *kp)
366{
367 int err = 0;
368 bool new_value;
369 bool orig_value = *(bool *)kp->arg;
370 struct kernel_param dummy_kp = *kp;
371
372 dummy_kp.arg = &new_value;
373
374 err = param_set_bool(val, &dummy_kp);
375 if (err)
376 return err;
377
378 /* Don't let them unset it once it's set! */
379 if (!new_value && orig_value)
380 return -EROFS;
381
382 if (new_value)
383 err = param_set_bool(val, kp);
384
385 return err;
386}
387EXPORT_SYMBOL_GPL(param_set_bool_enable_only);
388
389const struct kernel_param_ops param_ops_bool_enable_only = {
390 .flags = KERNEL_PARAM_OPS_FL_NOARG,
391 .set = param_set_bool_enable_only,
392 .get = param_get_bool,
393};
154be21c 394EXPORT_SYMBOL_GPL(param_ops_bool_enable_only);
d19f05d8 395
fddd5201 396/* This one must be bool. */
9bbb9e5a 397int param_set_invbool(const char *val, const struct kernel_param *kp)
1da177e4 398{
fddd5201
RR
399 int ret;
400 bool boolval;
22e48eaf 401 struct kernel_param dummy;
1da177e4 402
22e48eaf 403 dummy.arg = &boolval;
1da177e4
LT
404 ret = param_set_bool(val, &dummy);
405 if (ret == 0)
9a71af2c 406 *(bool *)kp->arg = !boolval;
1da177e4
LT
407 return ret;
408}
a14fe249 409EXPORT_SYMBOL(param_set_invbool);
1da177e4 410
9bbb9e5a 411int param_get_invbool(char *buffer, const struct kernel_param *kp)
1da177e4 412{
9a71af2c 413 return sprintf(buffer, "%c", (*(bool *)kp->arg) ? 'N' : 'Y');
1da177e4 414}
a14fe249 415EXPORT_SYMBOL(param_get_invbool);
1da177e4 416
9c27847d 417const struct kernel_param_ops param_ops_invbool = {
9bbb9e5a
RR
418 .set = param_set_invbool,
419 .get = param_get_invbool,
420};
421EXPORT_SYMBOL(param_ops_invbool);
422
69116f27
RR
423int param_set_bint(const char *val, const struct kernel_param *kp)
424{
5104b7d7
DS
425 /* Match bool exactly, by re-using it. */
426 struct kernel_param boolkp = *kp;
69116f27
RR
427 bool v;
428 int ret;
429
69116f27 430 boolkp.arg = &v;
69116f27
RR
431
432 ret = param_set_bool(val, &boolkp);
433 if (ret == 0)
434 *(int *)kp->arg = v;
435 return ret;
436}
437EXPORT_SYMBOL(param_set_bint);
438
9c27847d 439const struct kernel_param_ops param_ops_bint = {
6a4c2643 440 .flags = KERNEL_PARAM_OPS_FL_NOARG,
69116f27
RR
441 .set = param_set_bint,
442 .get = param_get_int,
443};
444EXPORT_SYMBOL(param_ops_bint);
445
9730b5b0 446/* We break the rule and mangle the string. */
b51d23e4
DS
447static int param_array(struct module *mod,
448 const char *name,
9871728b
AB
449 const char *val,
450 unsigned int min, unsigned int max,
451 void *elem, int elemsize,
9bbb9e5a 452 int (*set)(const char *, const struct kernel_param *kp),
026cee00 453 s16 level,
eb38a996 454 unsigned int *num)
1da177e4
LT
455{
456 int ret;
457 struct kernel_param kp;
458 char save;
459
460 /* Get the name right for errors. */
461 kp.name = name;
462 kp.arg = elem;
026cee00 463 kp.level = level;
1da177e4 464
1da177e4
LT
465 *num = 0;
466 /* We expect a comma-separated list of values. */
467 do {
468 int len;
469
470 if (*num == max) {
b5f3abf9 471 pr_err("%s: can only take %i arguments\n", name, max);
1da177e4
LT
472 return -EINVAL;
473 }
474 len = strcspn(val, ",");
475
476 /* nul-terminate and parse */
477 save = val[len];
478 ((char *)val)[len] = '\0';
cf2fde7b 479 check_kparam_locked(mod);
1da177e4
LT
480 ret = set(val, &kp);
481
482 if (ret != 0)
483 return ret;
484 kp.arg += elemsize;
485 val += len+1;
486 (*num)++;
487 } while (save == ',');
488
489 if (*num < min) {
b5f3abf9 490 pr_err("%s: needs at least %i arguments\n", name, min);
1da177e4
LT
491 return -EINVAL;
492 }
493 return 0;
494}
495
9bbb9e5a 496static int param_array_set(const char *val, const struct kernel_param *kp)
1da177e4 497{
22e48eaf 498 const struct kparam_array *arr = kp->arr;
31143a12 499 unsigned int temp_num;
1da177e4 500
b51d23e4 501 return param_array(kp->mod, kp->name, val, 1, arr->max, arr->elem,
026cee00 502 arr->elemsize, arr->ops->set, kp->level,
3c7d76e3 503 arr->num ?: &temp_num);
1da177e4
LT
504}
505
9bbb9e5a 506static int param_array_get(char *buffer, const struct kernel_param *kp)
1da177e4
LT
507{
508 int i, off, ret;
22e48eaf 509 const struct kparam_array *arr = kp->arr;
5104b7d7 510 struct kernel_param p = *kp;
1da177e4 511
1da177e4
LT
512 for (i = off = 0; i < (arr->num ? *arr->num : arr->max); i++) {
513 if (i)
514 buffer[off++] = ',';
515 p.arg = arr->elem + arr->elemsize * i;
cf2fde7b 516 check_kparam_locked(p.mod);
9bbb9e5a 517 ret = arr->ops->get(buffer + off, &p);
1da177e4
LT
518 if (ret < 0)
519 return ret;
520 off += ret;
521 }
522 buffer[off] = '\0';
523 return off;
524}
525
e6df34a4
RR
526static void param_array_free(void *arg)
527{
528 unsigned int i;
529 const struct kparam_array *arr = arg;
530
531 if (arr->ops->free)
532 for (i = 0; i < (arr->num ? *arr->num : arr->max); i++)
533 arr->ops->free(arr->elem + arr->elemsize * i);
534}
535
9c27847d 536const struct kernel_param_ops param_array_ops = {
9bbb9e5a
RR
537 .set = param_array_set,
538 .get = param_array_get,
e6df34a4 539 .free = param_array_free,
9bbb9e5a
RR
540};
541EXPORT_SYMBOL(param_array_ops);
542
543int param_set_copystring(const char *val, const struct kernel_param *kp)
1da177e4 544{
22e48eaf 545 const struct kparam_string *kps = kp->str;
1da177e4
LT
546
547 if (strlen(val)+1 > kps->maxlen) {
b5f3abf9 548 pr_err("%s: string doesn't fit in %u chars.\n",
1da177e4
LT
549 kp->name, kps->maxlen-1);
550 return -ENOSPC;
551 }
552 strcpy(kps->string, val);
553 return 0;
554}
a14fe249 555EXPORT_SYMBOL(param_set_copystring);
1da177e4 556
9bbb9e5a 557int param_get_string(char *buffer, const struct kernel_param *kp)
1da177e4 558{
22e48eaf 559 const struct kparam_string *kps = kp->str;
1da177e4
LT
560 return strlcpy(buffer, kps->string, kps->maxlen);
561}
a14fe249 562EXPORT_SYMBOL(param_get_string);
1da177e4 563
9c27847d 564const struct kernel_param_ops param_ops_string = {
9bbb9e5a
RR
565 .set = param_set_copystring,
566 .get = param_get_string,
567};
568EXPORT_SYMBOL(param_ops_string);
569
1da177e4 570/* sysfs output in /sys/modules/XYZ/parameters/ */
350f8258
EY
571#define to_module_attr(n) container_of(n, struct module_attribute, attr)
572#define to_module_kobject(n) container_of(n, struct module_kobject, kobj)
1da177e4 573
1da177e4
LT
574struct param_attribute
575{
576 struct module_attribute mattr;
9bbb9e5a 577 const struct kernel_param *param;
1da177e4
LT
578};
579
580struct module_param_attrs
581{
9b473de8 582 unsigned int num;
1da177e4
LT
583 struct attribute_group grp;
584 struct param_attribute attrs[0];
585};
586
ef665c1a 587#ifdef CONFIG_SYSFS
350f8258 588#define to_param_attr(n) container_of(n, struct param_attribute, mattr)
1da177e4
LT
589
590static ssize_t param_attr_show(struct module_attribute *mattr,
4befb026 591 struct module_kobject *mk, char *buf)
1da177e4
LT
592{
593 int count;
594 struct param_attribute *attribute = to_param_attr(mattr);
595
9bbb9e5a 596 if (!attribute->param->ops->get)
1da177e4
LT
597 return -EPERM;
598
b51d23e4 599 kernel_param_lock(mk->mod);
9bbb9e5a 600 count = attribute->param->ops->get(buf, attribute->param);
b51d23e4 601 kernel_param_unlock(mk->mod);
1da177e4
LT
602 if (count > 0) {
603 strcat(buf, "\n");
604 ++count;
605 }
606 return count;
607}
608
609/* sysfs always hands a nul-terminated string in buf. We rely on that. */
610static ssize_t param_attr_store(struct module_attribute *mattr,
b51d23e4 611 struct module_kobject *mk,
1da177e4
LT
612 const char *buf, size_t len)
613{
614 int err;
615 struct param_attribute *attribute = to_param_attr(mattr);
616
9bbb9e5a 617 if (!attribute->param->ops->set)
1da177e4
LT
618 return -EPERM;
619
b51d23e4 620 kernel_param_lock(mk->mod);
7a486d37 621 param_check_unsafe(attribute->param);
9bbb9e5a 622 err = attribute->param->ops->set(buf, attribute->param);
b51d23e4 623 kernel_param_unlock(mk->mod);
1da177e4
LT
624 if (!err)
625 return len;
626 return err;
627}
ef665c1a 628#endif
1da177e4
LT
629
630#ifdef CONFIG_MODULES
631#define __modinit
632#else
633#define __modinit __init
634#endif
635
ef665c1a 636#ifdef CONFIG_SYSFS
b51d23e4 637void kernel_param_lock(struct module *mod)
907b29eb 638{
b51d23e4 639 mutex_lock(KPARAM_MUTEX(mod));
907b29eb 640}
907b29eb 641
b51d23e4 642void kernel_param_unlock(struct module *mod)
907b29eb 643{
b51d23e4 644 mutex_unlock(KPARAM_MUTEX(mod));
907b29eb 645}
b51d23e4 646
b51d23e4
DS
647EXPORT_SYMBOL(kernel_param_lock);
648EXPORT_SYMBOL(kernel_param_unlock);
907b29eb 649
1da177e4 650/*
9b473de8
RR
651 * add_sysfs_param - add a parameter to sysfs
652 * @mk: struct module_kobject
653 * @kparam: the actual parameter definition to add to sysfs
654 * @name: name of parameter
1da177e4 655 *
9b473de8
RR
656 * Create a kobject if for a (per-module) parameter if mp NULL, and
657 * create file in sysfs. Returns an error on out of memory. Always cleans up
658 * if there's an error.
1da177e4 659 */
9b473de8 660static __modinit int add_sysfs_param(struct module_kobject *mk,
9bbb9e5a 661 const struct kernel_param *kp,
9b473de8 662 const char *name)
1da177e4 663{
18eb74fa
RR
664 struct module_param_attrs *new_mp;
665 struct attribute **new_attrs;
666 unsigned int i;
9b473de8
RR
667
668 /* We don't bother calling this with invisible parameters. */
669 BUG_ON(!kp->perm);
670
671 if (!mk->mp) {
18eb74fa
RR
672 /* First allocation. */
673 mk->mp = kzalloc(sizeof(*mk->mp), GFP_KERNEL);
674 if (!mk->mp)
675 return -ENOMEM;
676 mk->mp->grp.name = "parameters";
677 /* NULL-terminated attribute array. */
678 mk->mp->grp.attrs = kzalloc(sizeof(mk->mp->grp.attrs[0]),
679 GFP_KERNEL);
680 /* Caller will cleanup via free_module_param_attrs */
681 if (!mk->mp->grp.attrs)
682 return -ENOMEM;
9b473de8 683 }
1da177e4 684
18eb74fa
RR
685 /* Enlarge allocations. */
686 new_mp = krealloc(mk->mp,
687 sizeof(*mk->mp) +
688 sizeof(mk->mp->attrs[0]) * (mk->mp->num + 1),
689 GFP_KERNEL);
690 if (!new_mp)
691 return -ENOMEM;
692 mk->mp = new_mp;
693
694 /* Extra pointer for NULL terminator */
695 new_attrs = krealloc(mk->mp->grp.attrs,
696 sizeof(mk->mp->grp.attrs[0]) * (mk->mp->num + 2),
697 GFP_KERNEL);
698 if (!new_attrs)
699 return -ENOMEM;
700 mk->mp->grp.attrs = new_attrs;
9b473de8
RR
701
702 /* Tack new one on the end. */
c772be52 703 memset(&mk->mp->attrs[mk->mp->num], 0, sizeof(mk->mp->attrs[0]));
18eb74fa
RR
704 sysfs_attr_init(&mk->mp->attrs[mk->mp->num].mattr.attr);
705 mk->mp->attrs[mk->mp->num].param = kp;
706 mk->mp->attrs[mk->mp->num].mattr.show = param_attr_show;
b0a65b0c
KC
707 /* Do not allow runtime DAC changes to make param writable. */
708 if ((kp->perm & (S_IWUSR | S_IWGRP | S_IWOTH)) != 0)
709 mk->mp->attrs[mk->mp->num].mattr.store = param_attr_store;
574732c7
RR
710 else
711 mk->mp->attrs[mk->mp->num].mattr.store = NULL;
18eb74fa
RR
712 mk->mp->attrs[mk->mp->num].mattr.attr.name = (char *)name;
713 mk->mp->attrs[mk->mp->num].mattr.attr.mode = kp->perm;
714 mk->mp->num++;
9b473de8
RR
715
716 /* Fix up all the pointers, since krealloc can move us */
18eb74fa
RR
717 for (i = 0; i < mk->mp->num; i++)
718 mk->mp->grp.attrs[i] = &mk->mp->attrs[i].mattr.attr;
719 mk->mp->grp.attrs[mk->mp->num] = NULL;
9b473de8 720 return 0;
9b473de8 721}
1da177e4 722
d2441183 723#ifdef CONFIG_MODULES
9b473de8
RR
724static void free_module_param_attrs(struct module_kobject *mk)
725{
18eb74fa
RR
726 if (mk->mp)
727 kfree(mk->mp->grp.attrs);
9b473de8
RR
728 kfree(mk->mp);
729 mk->mp = NULL;
1da177e4
LT
730}
731
1da177e4
LT
732/*
733 * module_param_sysfs_setup - setup sysfs support for one module
734 * @mod: module
735 * @kparam: module parameters (array)
736 * @num_params: number of module parameters
737 *
9b473de8
RR
738 * Adds sysfs entries for module parameters under
739 * /sys/module/[mod->name]/parameters/
1da177e4
LT
740 */
741int module_param_sysfs_setup(struct module *mod,
9bbb9e5a 742 const struct kernel_param *kparam,
1da177e4
LT
743 unsigned int num_params)
744{
9b473de8
RR
745 int i, err;
746 bool params = false;
747
748 for (i = 0; i < num_params; i++) {
749 if (kparam[i].perm == 0)
750 continue;
751 err = add_sysfs_param(&mod->mkobj, &kparam[i], kparam[i].name);
18eb74fa
RR
752 if (err) {
753 free_module_param_attrs(&mod->mkobj);
9b473de8 754 return err;
18eb74fa 755 }
9b473de8
RR
756 params = true;
757 }
1da177e4 758
9b473de8
RR
759 if (!params)
760 return 0;
1da177e4 761
9b473de8
RR
762 /* Create the param group. */
763 err = sysfs_create_group(&mod->mkobj.kobj, &mod->mkobj.mp->grp);
764 if (err)
765 free_module_param_attrs(&mod->mkobj);
766 return err;
1da177e4
LT
767}
768
769/*
770 * module_param_sysfs_remove - remove sysfs support for one module
771 * @mod: module
772 *
773 * Remove sysfs entries for module parameters and the corresponding
774 * kobject.
775 */
776void module_param_sysfs_remove(struct module *mod)
777{
9b473de8
RR
778 if (mod->mkobj.mp) {
779 sysfs_remove_group(&mod->mkobj.kobj, &mod->mkobj.mp->grp);
1da177e4
LT
780 /* We are positive that no one is using any param
781 * attrs at this point. Deallocate immediately. */
9b473de8 782 free_module_param_attrs(&mod->mkobj);
1da177e4
LT
783 }
784}
785#endif
786
e180a6b7
RR
787void destroy_params(const struct kernel_param *params, unsigned num)
788{
e6df34a4
RR
789 unsigned int i;
790
791 for (i = 0; i < num; i++)
792 if (params[i].ops->free)
793 params[i].ops->free(params[i].arg);
e180a6b7
RR
794}
795
e94965ed 796static struct module_kobject * __init locate_module_kobject(const char *name)
1da177e4
LT
797{
798 struct module_kobject *mk;
9b473de8
RR
799 struct kobject *kobj;
800 int err;
1da177e4 801
9b473de8
RR
802 kobj = kset_find_obj(module_kset, name);
803 if (kobj) {
9b473de8 804 mk = to_module_kobject(kobj);
9b473de8
RR
805 } else {
806 mk = kzalloc(sizeof(struct module_kobject), GFP_KERNEL);
807 BUG_ON(!mk);
808
809 mk->mod = THIS_MODULE;
810 mk->kobj.kset = module_kset;
811 err = kobject_init_and_add(&mk->kobj, &module_ktype, NULL,
812 "%s", name);
88bfa324
KS
813#ifdef CONFIG_MODULES
814 if (!err)
815 err = sysfs_create_file(&mk->kobj, &module_uevent.attr);
816#endif
9b473de8
RR
817 if (err) {
818 kobject_put(&mk->kobj);
b5f3abf9 819 pr_crit("Adding module '%s' to sysfs failed (%d), the system may be unstable.\n",
e94965ed 820 name, err);
e94965ed 821 return NULL;
9b473de8 822 }
e94965ed
DT
823
824 /* So that we hold reference in both cases. */
9b473de8 825 kobject_get(&mk->kobj);
74c5b597 826 }
9b473de8 827
e94965ed
DT
828 return mk;
829}
830
831static void __init kernel_add_sysfs_param(const char *name,
63a12d9d 832 const struct kernel_param *kparam,
e94965ed
DT
833 unsigned int name_skip)
834{
835 struct module_kobject *mk;
836 int err;
837
838 mk = locate_module_kobject(name);
839 if (!mk)
840 return;
841
842 /* We need to remove old parameters before adding more. */
843 if (mk->mp)
844 sysfs_remove_group(&mk->kobj, &mk->mp->grp);
845
9b473de8
RR
846 /* These should not fail at boot. */
847 err = add_sysfs_param(mk, kparam, kparam->name + name_skip);
848 BUG_ON(err);
849 err = sysfs_create_group(&mk->kobj, &mk->mp->grp);
850 BUG_ON(err);
f30c53a8 851 kobject_uevent(&mk->kobj, KOBJ_ADD);
9b473de8 852 kobject_put(&mk->kobj);
1da177e4
LT
853}
854
855/*
b634d130 856 * param_sysfs_builtin - add sysfs parameters for built-in modules
1da177e4
LT
857 *
858 * Add module_parameters to sysfs for "modules" built into the kernel.
859 *
860 * The "module" name (KBUILD_MODNAME) is stored before a dot, the
861 * "parameter" name is stored behind a dot in kernel_param->name. So,
862 * extract the "module" name for all built-in kernel_param-eters,
9b473de8 863 * and for all who have the same, call kernel_add_sysfs_param.
1da177e4
LT
864 */
865static void __init param_sysfs_builtin(void)
866{
63a12d9d 867 const struct kernel_param *kp;
9b473de8
RR
868 unsigned int name_len;
869 char modname[MODULE_NAME_LEN];
1da177e4 870
9b473de8 871 for (kp = __start___param; kp < __stop___param; kp++) {
1da177e4
LT
872 char *dot;
873
9b473de8
RR
874 if (kp->perm == 0)
875 continue;
1da177e4 876
730b69d2 877 dot = strchr(kp->name, '.');
1da177e4 878 if (!dot) {
67e67cea
RR
879 /* This happens for core_param() */
880 strcpy(modname, "kernel");
881 name_len = 0;
882 } else {
883 name_len = dot - kp->name + 1;
884 strlcpy(modname, kp->name, name_len);
1da177e4 885 }
67e67cea 886 kernel_add_sysfs_param(modname, kp, name_len);
1da177e4 887 }
1da177e4
LT
888}
889
e94965ed 890ssize_t __modver_version_show(struct module_attribute *mattr,
4befb026 891 struct module_kobject *mk, char *buf)
e94965ed
DT
892{
893 struct module_version_attribute *vattr =
894 container_of(mattr, struct module_version_attribute, mattr);
895
f4940ab7 896 return scnprintf(buf, PAGE_SIZE, "%s\n", vattr->version);
e94965ed
DT
897}
898
b4bc8428
DT
899extern const struct module_version_attribute *__start___modver[];
900extern const struct module_version_attribute *__stop___modver[];
e94965ed
DT
901
902static void __init version_sysfs_builtin(void)
903{
b4bc8428 904 const struct module_version_attribute **p;
e94965ed
DT
905 struct module_kobject *mk;
906 int err;
907
b4bc8428
DT
908 for (p = __start___modver; p < __stop___modver; p++) {
909 const struct module_version_attribute *vattr = *p;
910
e94965ed
DT
911 mk = locate_module_kobject(vattr->module_name);
912 if (mk) {
913 err = sysfs_create_file(&mk->kobj, &vattr->mattr.attr);
74c3dea3 914 WARN_ON_ONCE(err);
e94965ed
DT
915 kobject_uevent(&mk->kobj, KOBJ_ADD);
916 kobject_put(&mk->kobj);
917 }
918 }
919}
1da177e4
LT
920
921/* module-related sysfs stuff */
1da177e4 922
1da177e4
LT
923static ssize_t module_attr_show(struct kobject *kobj,
924 struct attribute *attr,
925 char *buf)
926{
927 struct module_attribute *attribute;
928 struct module_kobject *mk;
929 int ret;
930
931 attribute = to_module_attr(attr);
932 mk = to_module_kobject(kobj);
933
934 if (!attribute->show)
70f2817a 935 return -EIO;
1da177e4 936
4befb026 937 ret = attribute->show(attribute, mk, buf);
1da177e4 938
1da177e4
LT
939 return ret;
940}
941
942static ssize_t module_attr_store(struct kobject *kobj,
943 struct attribute *attr,
944 const char *buf, size_t len)
945{
946 struct module_attribute *attribute;
947 struct module_kobject *mk;
948 int ret;
949
950 attribute = to_module_attr(attr);
951 mk = to_module_kobject(kobj);
952
953 if (!attribute->store)
70f2817a 954 return -EIO;
1da177e4 955
4befb026 956 ret = attribute->store(attribute, mk, buf, len);
1da177e4 957
1da177e4
LT
958 return ret;
959}
960
52cf25d0 961static const struct sysfs_ops module_sysfs_ops = {
1da177e4
LT
962 .show = module_attr_show,
963 .store = module_attr_store,
964};
965
270a6c4c
KS
966static int uevent_filter(struct kset *kset, struct kobject *kobj)
967{
968 struct kobj_type *ktype = get_ktype(kobj);
969
970 if (ktype == &module_ktype)
971 return 1;
972 return 0;
973}
974
9cd43611 975static const struct kset_uevent_ops module_uevent_ops = {
270a6c4c
KS
976 .filter = uevent_filter,
977};
978
7405c1e1 979struct kset *module_kset;
823bccfc 980int module_sysfs_initialized;
1da177e4 981
942e4431
LZ
982static void module_kobj_release(struct kobject *kobj)
983{
984 struct module_kobject *mk = to_module_kobject(kobj);
985 complete(mk->kobj_completion);
986}
987
7405c1e1 988struct kobj_type module_ktype = {
942e4431 989 .release = module_kobj_release,
1da177e4
LT
990 .sysfs_ops = &module_sysfs_ops,
991};
992
1da177e4
LT
993/*
994 * param_sysfs_init - wrapper for built-in params support
995 */
996static int __init param_sysfs_init(void)
997{
7405c1e1
GKH
998 module_kset = kset_create_and_add("module", &module_uevent_ops, NULL);
999 if (!module_kset) {
1000 printk(KERN_WARNING "%s (%d): error creating kset\n",
1001 __FILE__, __LINE__);
1002 return -ENOMEM;
d8c7649e 1003 }
823bccfc 1004 module_sysfs_initialized = 1;
1da177e4 1005
e94965ed 1006 version_sysfs_builtin();
1da177e4
LT
1007 param_sysfs_builtin();
1008
1009 return 0;
1010}
d10be6d1 1011subsys_initcall(param_sysfs_init);
1da177e4 1012
7405c1e1 1013#endif /* CONFIG_SYSFS */