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_notice("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 "\n", \ 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\n", *((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\n", *(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\n", (*(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 /* Replace \n with comma */ 464 if (i) 465 buffer[off - 1] = ','; 466 p.arg = arr->elem + arr->elemsize * i; 467 check_kparam_locked(p.mod); 468 ret = arr->ops->get(buffer + off, &p); 469 if (ret < 0) 470 return ret; 471 off += ret; 472 } 473 buffer[off] = '\0'; 474 return off; 475 } 476 477 static void param_array_free(void *arg) 478 { 479 unsigned int i; 480 const struct kparam_array *arr = arg; 481 482 if (arr->ops->free) 483 for (i = 0; i < (arr->num ? *arr->num : arr->max); i++) 484 arr->ops->free(arr->elem + arr->elemsize * i); 485 } 486 487 const struct kernel_param_ops param_array_ops = { 488 .set = param_array_set, 489 .get = param_array_get, 490 .free = param_array_free, 491 }; 492 EXPORT_SYMBOL(param_array_ops); 493 494 int param_set_copystring(const char *val, const struct kernel_param *kp) 495 { 496 const struct kparam_string *kps = kp->str; 497 498 if (strlen(val)+1 > kps->maxlen) { 499 pr_err("%s: string doesn't fit in %u chars.\n", 500 kp->name, kps->maxlen-1); 501 return -ENOSPC; 502 } 503 strcpy(kps->string, val); 504 return 0; 505 } 506 EXPORT_SYMBOL(param_set_copystring); 507 508 int param_get_string(char *buffer, const struct kernel_param *kp) 509 { 510 const struct kparam_string *kps = kp->str; 511 return scnprintf(buffer, PAGE_SIZE, "%s\n", kps->string); 512 } 513 EXPORT_SYMBOL(param_get_string); 514 515 const struct kernel_param_ops param_ops_string = { 516 .set = param_set_copystring, 517 .get = param_get_string, 518 }; 519 EXPORT_SYMBOL(param_ops_string); 520 521 /* sysfs output in /sys/modules/XYZ/parameters/ */ 522 #define to_module_attr(n) container_of(n, struct module_attribute, attr) 523 #define to_module_kobject(n) container_of(n, struct module_kobject, kobj) 524 525 struct param_attribute 526 { 527 struct module_attribute mattr; 528 const struct kernel_param *param; 529 }; 530 531 struct module_param_attrs 532 { 533 unsigned int num; 534 struct attribute_group grp; 535 struct param_attribute attrs[0]; 536 }; 537 538 #ifdef CONFIG_SYSFS 539 #define to_param_attr(n) container_of(n, struct param_attribute, mattr) 540 541 static ssize_t param_attr_show(struct module_attribute *mattr, 542 struct module_kobject *mk, char *buf) 543 { 544 int count; 545 struct param_attribute *attribute = to_param_attr(mattr); 546 547 if (!attribute->param->ops->get) 548 return -EPERM; 549 550 kernel_param_lock(mk->mod); 551 count = attribute->param->ops->get(buf, attribute->param); 552 kernel_param_unlock(mk->mod); 553 return count; 554 } 555 556 /* sysfs always hands a nul-terminated string in buf. We rely on that. */ 557 static ssize_t param_attr_store(struct module_attribute *mattr, 558 struct module_kobject *mk, 559 const char *buf, size_t len) 560 { 561 int err; 562 struct param_attribute *attribute = to_param_attr(mattr); 563 564 if (!attribute->param->ops->set) 565 return -EPERM; 566 567 kernel_param_lock(mk->mod); 568 param_check_unsafe(attribute->param); 569 err = attribute->param->ops->set(buf, attribute->param); 570 kernel_param_unlock(mk->mod); 571 if (!err) 572 return len; 573 return err; 574 } 575 #endif 576 577 #ifdef CONFIG_MODULES 578 #define __modinit 579 #else 580 #define __modinit __init 581 #endif 582 583 #ifdef CONFIG_SYSFS 584 void kernel_param_lock(struct module *mod) 585 { 586 mutex_lock(KPARAM_MUTEX(mod)); 587 } 588 589 void kernel_param_unlock(struct module *mod) 590 { 591 mutex_unlock(KPARAM_MUTEX(mod)); 592 } 593 594 EXPORT_SYMBOL(kernel_param_lock); 595 EXPORT_SYMBOL(kernel_param_unlock); 596 597 /* 598 * add_sysfs_param - add a parameter to sysfs 599 * @mk: struct module_kobject 600 * @kp: the actual parameter definition to add to sysfs 601 * @name: name of parameter 602 * 603 * Create a kobject if for a (per-module) parameter if mp NULL, and 604 * create file in sysfs. Returns an error on out of memory. Always cleans up 605 * if there's an error. 606 */ 607 static __modinit int add_sysfs_param(struct module_kobject *mk, 608 const struct kernel_param *kp, 609 const char *name) 610 { 611 struct module_param_attrs *new_mp; 612 struct attribute **new_attrs; 613 unsigned int i; 614 615 /* We don't bother calling this with invisible parameters. */ 616 BUG_ON(!kp->perm); 617 618 if (!mk->mp) { 619 /* First allocation. */ 620 mk->mp = kzalloc(sizeof(*mk->mp), GFP_KERNEL); 621 if (!mk->mp) 622 return -ENOMEM; 623 mk->mp->grp.name = "parameters"; 624 /* NULL-terminated attribute array. */ 625 mk->mp->grp.attrs = kzalloc(sizeof(mk->mp->grp.attrs[0]), 626 GFP_KERNEL); 627 /* Caller will cleanup via free_module_param_attrs */ 628 if (!mk->mp->grp.attrs) 629 return -ENOMEM; 630 } 631 632 /* Enlarge allocations. */ 633 new_mp = krealloc(mk->mp, 634 sizeof(*mk->mp) + 635 sizeof(mk->mp->attrs[0]) * (mk->mp->num + 1), 636 GFP_KERNEL); 637 if (!new_mp) 638 return -ENOMEM; 639 mk->mp = new_mp; 640 641 /* Extra pointer for NULL terminator */ 642 new_attrs = krealloc(mk->mp->grp.attrs, 643 sizeof(mk->mp->grp.attrs[0]) * (mk->mp->num + 2), 644 GFP_KERNEL); 645 if (!new_attrs) 646 return -ENOMEM; 647 mk->mp->grp.attrs = new_attrs; 648 649 /* Tack new one on the end. */ 650 memset(&mk->mp->attrs[mk->mp->num], 0, sizeof(mk->mp->attrs[0])); 651 sysfs_attr_init(&mk->mp->attrs[mk->mp->num].mattr.attr); 652 mk->mp->attrs[mk->mp->num].param = kp; 653 mk->mp->attrs[mk->mp->num].mattr.show = param_attr_show; 654 /* Do not allow runtime DAC changes to make param writable. */ 655 if ((kp->perm & (S_IWUSR | S_IWGRP | S_IWOTH)) != 0) 656 mk->mp->attrs[mk->mp->num].mattr.store = param_attr_store; 657 else 658 mk->mp->attrs[mk->mp->num].mattr.store = NULL; 659 mk->mp->attrs[mk->mp->num].mattr.attr.name = (char *)name; 660 mk->mp->attrs[mk->mp->num].mattr.attr.mode = kp->perm; 661 mk->mp->num++; 662 663 /* Fix up all the pointers, since krealloc can move us */ 664 for (i = 0; i < mk->mp->num; i++) 665 mk->mp->grp.attrs[i] = &mk->mp->attrs[i].mattr.attr; 666 mk->mp->grp.attrs[mk->mp->num] = NULL; 667 return 0; 668 } 669 670 #ifdef CONFIG_MODULES 671 static void free_module_param_attrs(struct module_kobject *mk) 672 { 673 if (mk->mp) 674 kfree(mk->mp->grp.attrs); 675 kfree(mk->mp); 676 mk->mp = NULL; 677 } 678 679 /* 680 * module_param_sysfs_setup - setup sysfs support for one module 681 * @mod: module 682 * @kparam: module parameters (array) 683 * @num_params: number of module parameters 684 * 685 * Adds sysfs entries for module parameters under 686 * /sys/module/[mod->name]/parameters/ 687 */ 688 int module_param_sysfs_setup(struct module *mod, 689 const struct kernel_param *kparam, 690 unsigned int num_params) 691 { 692 int i, err; 693 bool params = false; 694 695 for (i = 0; i < num_params; i++) { 696 if (kparam[i].perm == 0) 697 continue; 698 err = add_sysfs_param(&mod->mkobj, &kparam[i], kparam[i].name); 699 if (err) { 700 free_module_param_attrs(&mod->mkobj); 701 return err; 702 } 703 params = true; 704 } 705 706 if (!params) 707 return 0; 708 709 /* Create the param group. */ 710 err = sysfs_create_group(&mod->mkobj.kobj, &mod->mkobj.mp->grp); 711 if (err) 712 free_module_param_attrs(&mod->mkobj); 713 return err; 714 } 715 716 /* 717 * module_param_sysfs_remove - remove sysfs support for one module 718 * @mod: module 719 * 720 * Remove sysfs entries for module parameters and the corresponding 721 * kobject. 722 */ 723 void module_param_sysfs_remove(struct module *mod) 724 { 725 if (mod->mkobj.mp) { 726 sysfs_remove_group(&mod->mkobj.kobj, &mod->mkobj.mp->grp); 727 /* We are positive that no one is using any param 728 * attrs at this point. Deallocate immediately. */ 729 free_module_param_attrs(&mod->mkobj); 730 } 731 } 732 #endif 733 734 void destroy_params(const struct kernel_param *params, unsigned num) 735 { 736 unsigned int i; 737 738 for (i = 0; i < num; i++) 739 if (params[i].ops->free) 740 params[i].ops->free(params[i].arg); 741 } 742 743 static struct module_kobject * __init locate_module_kobject(const char *name) 744 { 745 struct module_kobject *mk; 746 struct kobject *kobj; 747 int err; 748 749 kobj = kset_find_obj(module_kset, name); 750 if (kobj) { 751 mk = to_module_kobject(kobj); 752 } else { 753 mk = kzalloc(sizeof(struct module_kobject), GFP_KERNEL); 754 BUG_ON(!mk); 755 756 mk->mod = THIS_MODULE; 757 mk->kobj.kset = module_kset; 758 err = kobject_init_and_add(&mk->kobj, &module_ktype, NULL, 759 "%s", name); 760 #ifdef CONFIG_MODULES 761 if (!err) 762 err = sysfs_create_file(&mk->kobj, &module_uevent.attr); 763 #endif 764 if (err) { 765 kobject_put(&mk->kobj); 766 pr_crit("Adding module '%s' to sysfs failed (%d), the system may be unstable.\n", 767 name, err); 768 return NULL; 769 } 770 771 /* So that we hold reference in both cases. */ 772 kobject_get(&mk->kobj); 773 } 774 775 return mk; 776 } 777 778 static void __init kernel_add_sysfs_param(const char *name, 779 const struct kernel_param *kparam, 780 unsigned int name_skip) 781 { 782 struct module_kobject *mk; 783 int err; 784 785 mk = locate_module_kobject(name); 786 if (!mk) 787 return; 788 789 /* We need to remove old parameters before adding more. */ 790 if (mk->mp) 791 sysfs_remove_group(&mk->kobj, &mk->mp->grp); 792 793 /* These should not fail at boot. */ 794 err = add_sysfs_param(mk, kparam, kparam->name + name_skip); 795 BUG_ON(err); 796 err = sysfs_create_group(&mk->kobj, &mk->mp->grp); 797 BUG_ON(err); 798 kobject_uevent(&mk->kobj, KOBJ_ADD); 799 kobject_put(&mk->kobj); 800 } 801 802 /* 803 * param_sysfs_builtin - add sysfs parameters for built-in modules 804 * 805 * Add module_parameters to sysfs for "modules" built into the kernel. 806 * 807 * The "module" name (KBUILD_MODNAME) is stored before a dot, the 808 * "parameter" name is stored behind a dot in kernel_param->name. So, 809 * extract the "module" name for all built-in kernel_param-eters, 810 * and for all who have the same, call kernel_add_sysfs_param. 811 */ 812 static void __init param_sysfs_builtin(void) 813 { 814 const struct kernel_param *kp; 815 unsigned int name_len; 816 char modname[MODULE_NAME_LEN]; 817 818 for (kp = __start___param; kp < __stop___param; kp++) { 819 char *dot; 820 821 if (kp->perm == 0) 822 continue; 823 824 dot = strchr(kp->name, '.'); 825 if (!dot) { 826 /* This happens for core_param() */ 827 strcpy(modname, "kernel"); 828 name_len = 0; 829 } else { 830 name_len = dot - kp->name + 1; 831 strlcpy(modname, kp->name, name_len); 832 } 833 kernel_add_sysfs_param(modname, kp, name_len); 834 } 835 } 836 837 ssize_t __modver_version_show(struct module_attribute *mattr, 838 struct module_kobject *mk, char *buf) 839 { 840 struct module_version_attribute *vattr = 841 container_of(mattr, struct module_version_attribute, mattr); 842 843 return scnprintf(buf, PAGE_SIZE, "%s\n", vattr->version); 844 } 845 846 extern const struct module_version_attribute *__start___modver[]; 847 extern const struct module_version_attribute *__stop___modver[]; 848 849 static void __init version_sysfs_builtin(void) 850 { 851 const struct module_version_attribute **p; 852 struct module_kobject *mk; 853 int err; 854 855 for (p = __start___modver; p < __stop___modver; p++) { 856 const struct module_version_attribute *vattr = *p; 857 858 mk = locate_module_kobject(vattr->module_name); 859 if (mk) { 860 err = sysfs_create_file(&mk->kobj, &vattr->mattr.attr); 861 WARN_ON_ONCE(err); 862 kobject_uevent(&mk->kobj, KOBJ_ADD); 863 kobject_put(&mk->kobj); 864 } 865 } 866 } 867 868 /* module-related sysfs stuff */ 869 870 static ssize_t module_attr_show(struct kobject *kobj, 871 struct attribute *attr, 872 char *buf) 873 { 874 struct module_attribute *attribute; 875 struct module_kobject *mk; 876 int ret; 877 878 attribute = to_module_attr(attr); 879 mk = to_module_kobject(kobj); 880 881 if (!attribute->show) 882 return -EIO; 883 884 ret = attribute->show(attribute, mk, buf); 885 886 return ret; 887 } 888 889 static ssize_t module_attr_store(struct kobject *kobj, 890 struct attribute *attr, 891 const char *buf, size_t len) 892 { 893 struct module_attribute *attribute; 894 struct module_kobject *mk; 895 int ret; 896 897 attribute = to_module_attr(attr); 898 mk = to_module_kobject(kobj); 899 900 if (!attribute->store) 901 return -EIO; 902 903 ret = attribute->store(attribute, mk, buf, len); 904 905 return ret; 906 } 907 908 static const struct sysfs_ops module_sysfs_ops = { 909 .show = module_attr_show, 910 .store = module_attr_store, 911 }; 912 913 static int uevent_filter(struct kset *kset, struct kobject *kobj) 914 { 915 struct kobj_type *ktype = get_ktype(kobj); 916 917 if (ktype == &module_ktype) 918 return 1; 919 return 0; 920 } 921 922 static const struct kset_uevent_ops module_uevent_ops = { 923 .filter = uevent_filter, 924 }; 925 926 struct kset *module_kset; 927 int module_sysfs_initialized; 928 929 static void module_kobj_release(struct kobject *kobj) 930 { 931 struct module_kobject *mk = to_module_kobject(kobj); 932 complete(mk->kobj_completion); 933 } 934 935 struct kobj_type module_ktype = { 936 .release = module_kobj_release, 937 .sysfs_ops = &module_sysfs_ops, 938 }; 939 940 /* 941 * param_sysfs_init - wrapper for built-in params support 942 */ 943 static int __init param_sysfs_init(void) 944 { 945 module_kset = kset_create_and_add("module", &module_uevent_ops, NULL); 946 if (!module_kset) { 947 printk(KERN_WARNING "%s (%d): error creating kset\n", 948 __FILE__, __LINE__); 949 return -ENOMEM; 950 } 951 module_sysfs_initialized = 1; 952 953 version_sysfs_builtin(); 954 param_sysfs_builtin(); 955 956 return 0; 957 } 958 subsys_initcall(param_sysfs_init); 959 960 #endif /* CONFIG_SYSFS */ 961