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