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