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 #include <linux/security.h> 16 17 #ifdef CONFIG_SYSFS 18 /* Protects all built-in parameters, modules use their own param_lock */ 19 static DEFINE_MUTEX(param_lock); 20 21 /* Use the module's mutex, or if built-in use the built-in mutex */ 22 #ifdef CONFIG_MODULES 23 #define KPARAM_MUTEX(mod) ((mod) ? &(mod)->param_lock : ¶m_lock) 24 #else 25 #define KPARAM_MUTEX(mod) (¶m_lock) 26 #endif 27 28 static inline void check_kparam_locked(struct module *mod) 29 { 30 BUG_ON(!mutex_is_locked(KPARAM_MUTEX(mod))); 31 } 32 #else 33 static inline void check_kparam_locked(struct module *mod) 34 { 35 } 36 #endif /* !CONFIG_SYSFS */ 37 38 /* This just allows us to keep track of which parameters are kmalloced. */ 39 struct kmalloced_param { 40 struct list_head list; 41 char val[]; 42 }; 43 static LIST_HEAD(kmalloced_params); 44 static DEFINE_SPINLOCK(kmalloced_params_lock); 45 46 static void *kmalloc_parameter(unsigned int size) 47 { 48 struct kmalloced_param *p; 49 50 p = kmalloc(sizeof(*p) + size, GFP_KERNEL); 51 if (!p) 52 return NULL; 53 54 spin_lock(&kmalloced_params_lock); 55 list_add(&p->list, &kmalloced_params); 56 spin_unlock(&kmalloced_params_lock); 57 58 return p->val; 59 } 60 61 /* Does nothing if parameter wasn't kmalloced above. */ 62 static void maybe_kfree_parameter(void *param) 63 { 64 struct kmalloced_param *p; 65 66 spin_lock(&kmalloced_params_lock); 67 list_for_each_entry(p, &kmalloced_params, list) { 68 if (p->val == param) { 69 list_del(&p->list); 70 kfree(p); 71 break; 72 } 73 } 74 spin_unlock(&kmalloced_params_lock); 75 } 76 77 static char dash2underscore(char c) 78 { 79 if (c == '-') 80 return '_'; 81 return c; 82 } 83 84 bool parameqn(const char *a, const char *b, size_t n) 85 { 86 size_t i; 87 88 for (i = 0; i < n; i++) { 89 if (dash2underscore(a[i]) != dash2underscore(b[i])) 90 return false; 91 } 92 return true; 93 } 94 95 bool parameq(const char *a, const char *b) 96 { 97 return parameqn(a, b, strlen(a)+1); 98 } 99 100 static bool param_check_unsafe(const struct kernel_param *kp) 101 { 102 if (kp->flags & KERNEL_PARAM_FL_HWPARAM && 103 security_locked_down(LOCKDOWN_MODULE_PARAMETERS)) 104 return false; 105 106 if (kp->flags & KERNEL_PARAM_FL_UNSAFE) { 107 pr_notice("Setting dangerous option %s - tainting kernel\n", 108 kp->name); 109 add_taint(TAINT_USER, LOCKDEP_STILL_OK); 110 } 111 112 return true; 113 } 114 115 static int parse_one(char *param, 116 char *val, 117 const char *doing, 118 const struct kernel_param *params, 119 unsigned num_params, 120 s16 min_level, 121 s16 max_level, 122 void *arg, 123 int (*handle_unknown)(char *param, char *val, 124 const char *doing, void *arg)) 125 { 126 unsigned int i; 127 int err; 128 129 /* Find parameter */ 130 for (i = 0; i < num_params; i++) { 131 if (parameq(param, params[i].name)) { 132 if (params[i].level < min_level 133 || params[i].level > max_level) 134 return 0; 135 /* No one handled NULL, so do it here. */ 136 if (!val && 137 !(params[i].ops->flags & KERNEL_PARAM_OPS_FL_NOARG)) 138 return -EINVAL; 139 pr_debug("handling %s with %p\n", param, 140 params[i].ops->set); 141 kernel_param_lock(params[i].mod); 142 if (param_check_unsafe(¶ms[i])) 143 err = params[i].ops->set(val, ¶ms[i]); 144 else 145 err = -EPERM; 146 kernel_param_unlock(params[i].mod); 147 return err; 148 } 149 } 150 151 if (handle_unknown) { 152 pr_debug("doing %s: %s='%s'\n", doing, param, val); 153 return handle_unknown(param, val, doing, arg); 154 } 155 156 pr_debug("Unknown argument '%s'\n", param); 157 return -ENOENT; 158 } 159 160 /* Args looks like "foo=bar,bar2 baz=fuz wiz". */ 161 char *parse_args(const char *doing, 162 char *args, 163 const struct kernel_param *params, 164 unsigned num, 165 s16 min_level, 166 s16 max_level, 167 void *arg, 168 int (*unknown)(char *param, char *val, 169 const char *doing, void *arg)) 170 { 171 char *param, *val, *err = NULL; 172 173 /* Chew leading spaces */ 174 args = skip_spaces(args); 175 176 if (*args) 177 pr_debug("doing %s, parsing ARGS: '%s'\n", doing, args); 178 179 while (*args) { 180 int ret; 181 int irq_was_disabled; 182 183 args = next_arg(args, ¶m, &val); 184 /* Stop at -- */ 185 if (!val && strcmp(param, "--") == 0) 186 return err ?: args; 187 irq_was_disabled = irqs_disabled(); 188 ret = parse_one(param, val, doing, params, num, 189 min_level, max_level, arg, unknown); 190 if (irq_was_disabled && !irqs_disabled()) 191 pr_warn("%s: option '%s' enabled irq's!\n", 192 doing, param); 193 194 switch (ret) { 195 case 0: 196 continue; 197 case -ENOENT: 198 pr_err("%s: Unknown parameter `%s'\n", doing, param); 199 break; 200 case -ENOSPC: 201 pr_err("%s: `%s' too large for parameter `%s'\n", 202 doing, val ?: "", param); 203 break; 204 default: 205 pr_err("%s: `%s' invalid for parameter `%s'\n", 206 doing, val ?: "", param); 207 break; 208 } 209 210 err = ERR_PTR(ret); 211 } 212 213 return err; 214 } 215 216 /* Lazy bastard, eh? */ 217 #define STANDARD_PARAM_DEF(name, type, format, strtolfn) \ 218 int param_set_##name(const char *val, const struct kernel_param *kp) \ 219 { \ 220 return strtolfn(val, 0, (type *)kp->arg); \ 221 } \ 222 int param_get_##name(char *buffer, const struct kernel_param *kp) \ 223 { \ 224 return scnprintf(buffer, PAGE_SIZE, format "\n", \ 225 *((type *)kp->arg)); \ 226 } \ 227 const struct kernel_param_ops param_ops_##name = { \ 228 .set = param_set_##name, \ 229 .get = param_get_##name, \ 230 }; \ 231 EXPORT_SYMBOL(param_set_##name); \ 232 EXPORT_SYMBOL(param_get_##name); \ 233 EXPORT_SYMBOL(param_ops_##name) 234 235 236 STANDARD_PARAM_DEF(byte, unsigned char, "%hhu", kstrtou8); 237 STANDARD_PARAM_DEF(short, short, "%hi", kstrtos16); 238 STANDARD_PARAM_DEF(ushort, unsigned short, "%hu", kstrtou16); 239 STANDARD_PARAM_DEF(int, int, "%i", kstrtoint); 240 STANDARD_PARAM_DEF(uint, unsigned int, "%u", kstrtouint); 241 STANDARD_PARAM_DEF(long, long, "%li", kstrtol); 242 STANDARD_PARAM_DEF(ulong, unsigned long, "%lu", kstrtoul); 243 STANDARD_PARAM_DEF(ullong, unsigned long long, "%llu", kstrtoull); 244 STANDARD_PARAM_DEF(hexint, unsigned int, "%#08x", kstrtouint); 245 246 int param_set_charp(const char *val, const struct kernel_param *kp) 247 { 248 if (strlen(val) > 1024) { 249 pr_err("%s: string parameter too long\n", kp->name); 250 return -ENOSPC; 251 } 252 253 maybe_kfree_parameter(*(char **)kp->arg); 254 255 /* This is a hack. We can't kmalloc in early boot, and we 256 * don't need to; this mangled commandline is preserved. */ 257 if (slab_is_available()) { 258 *(char **)kp->arg = kmalloc_parameter(strlen(val)+1); 259 if (!*(char **)kp->arg) 260 return -ENOMEM; 261 strcpy(*(char **)kp->arg, val); 262 } else 263 *(const char **)kp->arg = val; 264 265 return 0; 266 } 267 EXPORT_SYMBOL(param_set_charp); 268 269 int param_get_charp(char *buffer, const struct kernel_param *kp) 270 { 271 return scnprintf(buffer, PAGE_SIZE, "%s\n", *((char **)kp->arg)); 272 } 273 EXPORT_SYMBOL(param_get_charp); 274 275 void param_free_charp(void *arg) 276 { 277 maybe_kfree_parameter(*((char **)arg)); 278 } 279 EXPORT_SYMBOL(param_free_charp); 280 281 const struct kernel_param_ops param_ops_charp = { 282 .set = param_set_charp, 283 .get = param_get_charp, 284 .free = param_free_charp, 285 }; 286 EXPORT_SYMBOL(param_ops_charp); 287 288 /* Actually could be a bool or an int, for historical reasons. */ 289 int param_set_bool(const char *val, const struct kernel_param *kp) 290 { 291 /* No equals means "set"... */ 292 if (!val) val = "1"; 293 294 /* One of =[yYnN01] */ 295 return strtobool(val, kp->arg); 296 } 297 EXPORT_SYMBOL(param_set_bool); 298 299 int param_get_bool(char *buffer, const struct kernel_param *kp) 300 { 301 /* Y and N chosen as being relatively non-coder friendly */ 302 return sprintf(buffer, "%c\n", *(bool *)kp->arg ? 'Y' : 'N'); 303 } 304 EXPORT_SYMBOL(param_get_bool); 305 306 const struct kernel_param_ops param_ops_bool = { 307 .flags = KERNEL_PARAM_OPS_FL_NOARG, 308 .set = param_set_bool, 309 .get = param_get_bool, 310 }; 311 EXPORT_SYMBOL(param_ops_bool); 312 313 int param_set_bool_enable_only(const char *val, const struct kernel_param *kp) 314 { 315 int err = 0; 316 bool new_value; 317 bool orig_value = *(bool *)kp->arg; 318 struct kernel_param dummy_kp = *kp; 319 320 dummy_kp.arg = &new_value; 321 322 err = param_set_bool(val, &dummy_kp); 323 if (err) 324 return err; 325 326 /* Don't let them unset it once it's set! */ 327 if (!new_value && orig_value) 328 return -EROFS; 329 330 if (new_value) 331 err = param_set_bool(val, kp); 332 333 return err; 334 } 335 EXPORT_SYMBOL_GPL(param_set_bool_enable_only); 336 337 const struct kernel_param_ops param_ops_bool_enable_only = { 338 .flags = KERNEL_PARAM_OPS_FL_NOARG, 339 .set = param_set_bool_enable_only, 340 .get = param_get_bool, 341 }; 342 EXPORT_SYMBOL_GPL(param_ops_bool_enable_only); 343 344 /* This one must be bool. */ 345 int param_set_invbool(const char *val, const struct kernel_param *kp) 346 { 347 int ret; 348 bool boolval; 349 struct kernel_param dummy; 350 351 dummy.arg = &boolval; 352 ret = param_set_bool(val, &dummy); 353 if (ret == 0) 354 *(bool *)kp->arg = !boolval; 355 return ret; 356 } 357 EXPORT_SYMBOL(param_set_invbool); 358 359 int param_get_invbool(char *buffer, const struct kernel_param *kp) 360 { 361 return sprintf(buffer, "%c\n", (*(bool *)kp->arg) ? 'N' : 'Y'); 362 } 363 EXPORT_SYMBOL(param_get_invbool); 364 365 const struct kernel_param_ops param_ops_invbool = { 366 .set = param_set_invbool, 367 .get = param_get_invbool, 368 }; 369 EXPORT_SYMBOL(param_ops_invbool); 370 371 int param_set_bint(const char *val, const struct kernel_param *kp) 372 { 373 /* Match bool exactly, by re-using it. */ 374 struct kernel_param boolkp = *kp; 375 bool v; 376 int ret; 377 378 boolkp.arg = &v; 379 380 ret = param_set_bool(val, &boolkp); 381 if (ret == 0) 382 *(int *)kp->arg = v; 383 return ret; 384 } 385 EXPORT_SYMBOL(param_set_bint); 386 387 const struct kernel_param_ops param_ops_bint = { 388 .flags = KERNEL_PARAM_OPS_FL_NOARG, 389 .set = param_set_bint, 390 .get = param_get_int, 391 }; 392 EXPORT_SYMBOL(param_ops_bint); 393 394 /* We break the rule and mangle the string. */ 395 static int param_array(struct module *mod, 396 const char *name, 397 const char *val, 398 unsigned int min, unsigned int max, 399 void *elem, int elemsize, 400 int (*set)(const char *, const struct kernel_param *kp), 401 s16 level, 402 unsigned int *num) 403 { 404 int ret; 405 struct kernel_param kp; 406 char save; 407 408 /* Get the name right for errors. */ 409 kp.name = name; 410 kp.arg = elem; 411 kp.level = level; 412 413 *num = 0; 414 /* We expect a comma-separated list of values. */ 415 do { 416 int len; 417 418 if (*num == max) { 419 pr_err("%s: can only take %i arguments\n", name, max); 420 return -EINVAL; 421 } 422 len = strcspn(val, ","); 423 424 /* nul-terminate and parse */ 425 save = val[len]; 426 ((char *)val)[len] = '\0'; 427 check_kparam_locked(mod); 428 ret = set(val, &kp); 429 430 if (ret != 0) 431 return ret; 432 kp.arg += elemsize; 433 val += len+1; 434 (*num)++; 435 } while (save == ','); 436 437 if (*num < min) { 438 pr_err("%s: needs at least %i arguments\n", name, min); 439 return -EINVAL; 440 } 441 return 0; 442 } 443 444 static int param_array_set(const char *val, const struct kernel_param *kp) 445 { 446 const struct kparam_array *arr = kp->arr; 447 unsigned int temp_num; 448 449 return param_array(kp->mod, kp->name, val, 1, arr->max, arr->elem, 450 arr->elemsize, arr->ops->set, kp->level, 451 arr->num ?: &temp_num); 452 } 453 454 static int param_array_get(char *buffer, const struct kernel_param *kp) 455 { 456 int i, off, ret; 457 const struct kparam_array *arr = kp->arr; 458 struct kernel_param p = *kp; 459 460 for (i = off = 0; i < (arr->num ? *arr->num : arr->max); i++) { 461 /* Replace \n with comma */ 462 if (i) 463 buffer[off - 1] = ','; 464 p.arg = arr->elem + arr->elemsize * i; 465 check_kparam_locked(p.mod); 466 ret = arr->ops->get(buffer + off, &p); 467 if (ret < 0) 468 return ret; 469 off += ret; 470 } 471 buffer[off] = '\0'; 472 return off; 473 } 474 475 static void param_array_free(void *arg) 476 { 477 unsigned int i; 478 const struct kparam_array *arr = arg; 479 480 if (arr->ops->free) 481 for (i = 0; i < (arr->num ? *arr->num : arr->max); i++) 482 arr->ops->free(arr->elem + arr->elemsize * i); 483 } 484 485 const struct kernel_param_ops param_array_ops = { 486 .set = param_array_set, 487 .get = param_array_get, 488 .free = param_array_free, 489 }; 490 EXPORT_SYMBOL(param_array_ops); 491 492 int param_set_copystring(const char *val, const struct kernel_param *kp) 493 { 494 const struct kparam_string *kps = kp->str; 495 496 if (strlen(val)+1 > kps->maxlen) { 497 pr_err("%s: string doesn't fit in %u chars.\n", 498 kp->name, kps->maxlen-1); 499 return -ENOSPC; 500 } 501 strcpy(kps->string, val); 502 return 0; 503 } 504 EXPORT_SYMBOL(param_set_copystring); 505 506 int param_get_string(char *buffer, const struct kernel_param *kp) 507 { 508 const struct kparam_string *kps = kp->str; 509 return scnprintf(buffer, PAGE_SIZE, "%s\n", kps->string); 510 } 511 EXPORT_SYMBOL(param_get_string); 512 513 const struct kernel_param_ops param_ops_string = { 514 .set = param_set_copystring, 515 .get = param_get_string, 516 }; 517 EXPORT_SYMBOL(param_ops_string); 518 519 /* sysfs output in /sys/modules/XYZ/parameters/ */ 520 #define to_module_attr(n) container_of(n, struct module_attribute, attr) 521 #define to_module_kobject(n) container_of(n, struct module_kobject, kobj) 522 523 struct param_attribute 524 { 525 struct module_attribute mattr; 526 const struct kernel_param *param; 527 }; 528 529 struct module_param_attrs 530 { 531 unsigned int num; 532 struct attribute_group grp; 533 struct param_attribute attrs[]; 534 }; 535 536 #ifdef CONFIG_SYSFS 537 #define to_param_attr(n) container_of(n, struct param_attribute, mattr) 538 539 static ssize_t param_attr_show(struct module_attribute *mattr, 540 struct module_kobject *mk, char *buf) 541 { 542 int count; 543 struct param_attribute *attribute = to_param_attr(mattr); 544 545 if (!attribute->param->ops->get) 546 return -EPERM; 547 548 kernel_param_lock(mk->mod); 549 count = attribute->param->ops->get(buf, attribute->param); 550 kernel_param_unlock(mk->mod); 551 return count; 552 } 553 554 /* sysfs always hands a nul-terminated string in buf. We rely on that. */ 555 static ssize_t param_attr_store(struct module_attribute *mattr, 556 struct module_kobject *mk, 557 const char *buf, size_t len) 558 { 559 int err; 560 struct param_attribute *attribute = to_param_attr(mattr); 561 562 if (!attribute->param->ops->set) 563 return -EPERM; 564 565 kernel_param_lock(mk->mod); 566 if (param_check_unsafe(attribute->param)) 567 err = attribute->param->ops->set(buf, attribute->param); 568 else 569 err = -EPERM; 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