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/config.h> 19 #include <linux/moduleparam.h> 20 #include <linux/kernel.h> 21 #include <linux/string.h> 22 #include <linux/errno.h> 23 #include <linux/module.h> 24 #include <linux/device.h> 25 #include <linux/err.h> 26 27 #if 0 28 #define DEBUGP printk 29 #else 30 #define DEBUGP(fmt, a...) 31 #endif 32 33 static inline int dash2underscore(char c) 34 { 35 if (c == '-') 36 return '_'; 37 return c; 38 } 39 40 static inline int parameq(const char *input, const char *paramname) 41 { 42 unsigned int i; 43 for (i = 0; dash2underscore(input[i]) == paramname[i]; i++) 44 if (input[i] == '\0') 45 return 1; 46 return 0; 47 } 48 49 static int parse_one(char *param, 50 char *val, 51 struct kernel_param *params, 52 unsigned num_params, 53 int (*handle_unknown)(char *param, char *val)) 54 { 55 unsigned int i; 56 57 /* Find parameter */ 58 for (i = 0; i < num_params; i++) { 59 if (parameq(param, params[i].name)) { 60 DEBUGP("They are equal! Calling %p\n", 61 params[i].set); 62 return params[i].set(val, ¶ms[i]); 63 } 64 } 65 66 if (handle_unknown) { 67 DEBUGP("Unknown argument: calling %p\n", handle_unknown); 68 return handle_unknown(param, val); 69 } 70 71 DEBUGP("Unknown argument `%s'\n", param); 72 return -ENOENT; 73 } 74 75 /* You can use " around spaces, but can't escape ". */ 76 /* Hyphens and underscores equivalent in parameter names. */ 77 static char *next_arg(char *args, char **param, char **val) 78 { 79 unsigned int i, equals = 0; 80 int in_quote = 0, quoted = 0; 81 char *next; 82 83 /* Chew any extra spaces */ 84 while (*args == ' ') args++; 85 if (*args == '"') { 86 args++; 87 in_quote = 1; 88 quoted = 1; 89 } 90 91 for (i = 0; args[i]; i++) { 92 if (args[i] == ' ' && !in_quote) 93 break; 94 if (equals == 0) { 95 if (args[i] == '=') 96 equals = i; 97 } 98 if (args[i] == '"') 99 in_quote = !in_quote; 100 } 101 102 *param = args; 103 if (!equals) 104 *val = NULL; 105 else { 106 args[equals] = '\0'; 107 *val = args + equals + 1; 108 109 /* Don't include quotes in value. */ 110 if (**val == '"') { 111 (*val)++; 112 if (args[i-1] == '"') 113 args[i-1] = '\0'; 114 } 115 if (quoted && args[i-1] == '"') 116 args[i-1] = '\0'; 117 } 118 119 if (args[i]) { 120 args[i] = '\0'; 121 next = args + i + 1; 122 } else 123 next = args + i; 124 return next; 125 } 126 127 /* Args looks like "foo=bar,bar2 baz=fuz wiz". */ 128 int parse_args(const char *name, 129 char *args, 130 struct kernel_param *params, 131 unsigned num, 132 int (*unknown)(char *param, char *val)) 133 { 134 char *param, *val; 135 136 DEBUGP("Parsing ARGS: %s\n", args); 137 138 while (*args) { 139 int ret; 140 141 args = next_arg(args, ¶m, &val); 142 ret = parse_one(param, val, params, num, unknown); 143 switch (ret) { 144 case -ENOENT: 145 printk(KERN_ERR "%s: Unknown parameter `%s'\n", 146 name, param); 147 return ret; 148 case -ENOSPC: 149 printk(KERN_ERR 150 "%s: `%s' too large for parameter `%s'\n", 151 name, val ?: "", param); 152 return ret; 153 case 0: 154 break; 155 default: 156 printk(KERN_ERR 157 "%s: `%s' invalid for parameter `%s'\n", 158 name, val ?: "", param); 159 return ret; 160 } 161 } 162 163 /* All parsed OK. */ 164 return 0; 165 } 166 167 /* Lazy bastard, eh? */ 168 #define STANDARD_PARAM_DEF(name, type, format, tmptype, strtolfn) \ 169 int param_set_##name(const char *val, struct kernel_param *kp) \ 170 { \ 171 char *endp; \ 172 tmptype l; \ 173 \ 174 if (!val) return -EINVAL; \ 175 l = strtolfn(val, &endp, 0); \ 176 if (endp == val || ((type)l != l)) \ 177 return -EINVAL; \ 178 *((type *)kp->arg) = l; \ 179 return 0; \ 180 } \ 181 int param_get_##name(char *buffer, struct kernel_param *kp) \ 182 { \ 183 return sprintf(buffer, format, *((type *)kp->arg)); \ 184 } 185 186 STANDARD_PARAM_DEF(byte, unsigned char, "%c", unsigned long, simple_strtoul); 187 STANDARD_PARAM_DEF(short, short, "%hi", long, simple_strtol); 188 STANDARD_PARAM_DEF(ushort, unsigned short, "%hu", unsigned long, simple_strtoul); 189 STANDARD_PARAM_DEF(int, int, "%i", long, simple_strtol); 190 STANDARD_PARAM_DEF(uint, unsigned int, "%u", unsigned long, simple_strtoul); 191 STANDARD_PARAM_DEF(long, long, "%li", long, simple_strtol); 192 STANDARD_PARAM_DEF(ulong, unsigned long, "%lu", unsigned long, simple_strtoul); 193 194 int param_set_charp(const char *val, struct kernel_param *kp) 195 { 196 if (!val) { 197 printk(KERN_ERR "%s: string parameter expected\n", 198 kp->name); 199 return -EINVAL; 200 } 201 202 if (strlen(val) > 1024) { 203 printk(KERN_ERR "%s: string parameter too long\n", 204 kp->name); 205 return -ENOSPC; 206 } 207 208 *(char **)kp->arg = (char *)val; 209 return 0; 210 } 211 212 int param_get_charp(char *buffer, struct kernel_param *kp) 213 { 214 return sprintf(buffer, "%s", *((char **)kp->arg)); 215 } 216 217 int param_set_bool(const char *val, struct kernel_param *kp) 218 { 219 /* No equals means "set"... */ 220 if (!val) val = "1"; 221 222 /* One of =[yYnN01] */ 223 switch (val[0]) { 224 case 'y': case 'Y': case '1': 225 *(int *)kp->arg = 1; 226 return 0; 227 case 'n': case 'N': case '0': 228 *(int *)kp->arg = 0; 229 return 0; 230 } 231 return -EINVAL; 232 } 233 234 int param_get_bool(char *buffer, struct kernel_param *kp) 235 { 236 /* Y and N chosen as being relatively non-coder friendly */ 237 return sprintf(buffer, "%c", (*(int *)kp->arg) ? 'Y' : 'N'); 238 } 239 240 int param_set_invbool(const char *val, struct kernel_param *kp) 241 { 242 int boolval, ret; 243 struct kernel_param dummy = { .arg = &boolval }; 244 245 ret = param_set_bool(val, &dummy); 246 if (ret == 0) 247 *(int *)kp->arg = !boolval; 248 return ret; 249 } 250 251 int param_get_invbool(char *buffer, struct kernel_param *kp) 252 { 253 int val; 254 struct kernel_param dummy = { .arg = &val }; 255 256 val = !*(int *)kp->arg; 257 return param_get_bool(buffer, &dummy); 258 } 259 260 /* We cheat here and temporarily mangle the string. */ 261 int param_array(const char *name, 262 const char *val, 263 unsigned int min, unsigned int max, 264 void *elem, int elemsize, 265 int (*set)(const char *, struct kernel_param *kp), 266 int *num) 267 { 268 int ret; 269 struct kernel_param kp; 270 char save; 271 272 /* Get the name right for errors. */ 273 kp.name = name; 274 kp.arg = elem; 275 276 /* No equals sign? */ 277 if (!val) { 278 printk(KERN_ERR "%s: expects arguments\n", name); 279 return -EINVAL; 280 } 281 282 *num = 0; 283 /* We expect a comma-separated list of values. */ 284 do { 285 int len; 286 287 if (*num == max) { 288 printk(KERN_ERR "%s: can only take %i arguments\n", 289 name, max); 290 return -EINVAL; 291 } 292 len = strcspn(val, ","); 293 294 /* nul-terminate and parse */ 295 save = val[len]; 296 ((char *)val)[len] = '\0'; 297 ret = set(val, &kp); 298 299 if (ret != 0) 300 return ret; 301 kp.arg += elemsize; 302 val += len+1; 303 (*num)++; 304 } while (save == ','); 305 306 if (*num < min) { 307 printk(KERN_ERR "%s: needs at least %i arguments\n", 308 name, min); 309 return -EINVAL; 310 } 311 return 0; 312 } 313 314 int param_array_set(const char *val, struct kernel_param *kp) 315 { 316 struct kparam_array *arr = kp->arg; 317 unsigned int temp_num; 318 319 return param_array(kp->name, val, 1, arr->max, arr->elem, 320 arr->elemsize, arr->set, arr->num ?: &temp_num); 321 } 322 323 int param_array_get(char *buffer, struct kernel_param *kp) 324 { 325 int i, off, ret; 326 struct kparam_array *arr = kp->arg; 327 struct kernel_param p; 328 329 p = *kp; 330 for (i = off = 0; i < (arr->num ? *arr->num : arr->max); i++) { 331 if (i) 332 buffer[off++] = ','; 333 p.arg = arr->elem + arr->elemsize * i; 334 ret = arr->get(buffer + off, &p); 335 if (ret < 0) 336 return ret; 337 off += ret; 338 } 339 buffer[off] = '\0'; 340 return off; 341 } 342 343 int param_set_copystring(const char *val, struct kernel_param *kp) 344 { 345 struct kparam_string *kps = kp->arg; 346 347 if (strlen(val)+1 > kps->maxlen) { 348 printk(KERN_ERR "%s: string doesn't fit in %u chars.\n", 349 kp->name, kps->maxlen-1); 350 return -ENOSPC; 351 } 352 strcpy(kps->string, val); 353 return 0; 354 } 355 356 int param_get_string(char *buffer, struct kernel_param *kp) 357 { 358 struct kparam_string *kps = kp->arg; 359 return strlcpy(buffer, kps->string, kps->maxlen); 360 } 361 362 /* sysfs output in /sys/modules/XYZ/parameters/ */ 363 364 extern struct kernel_param __start___param[], __stop___param[]; 365 366 #define MAX_KBUILD_MODNAME KOBJ_NAME_LEN 367 368 struct param_attribute 369 { 370 struct module_attribute mattr; 371 struct kernel_param *param; 372 }; 373 374 struct module_param_attrs 375 { 376 struct attribute_group grp; 377 struct param_attribute attrs[0]; 378 }; 379 380 #define to_param_attr(n) container_of(n, struct param_attribute, mattr); 381 382 static ssize_t param_attr_show(struct module_attribute *mattr, 383 struct module *mod, char *buf) 384 { 385 int count; 386 struct param_attribute *attribute = to_param_attr(mattr); 387 388 if (!attribute->param->get) 389 return -EPERM; 390 391 count = attribute->param->get(buf, attribute->param); 392 if (count > 0) { 393 strcat(buf, "\n"); 394 ++count; 395 } 396 return count; 397 } 398 399 /* sysfs always hands a nul-terminated string in buf. We rely on that. */ 400 static ssize_t param_attr_store(struct module_attribute *mattr, 401 struct module *owner, 402 const char *buf, size_t len) 403 { 404 int err; 405 struct param_attribute *attribute = to_param_attr(mattr); 406 407 if (!attribute->param->set) 408 return -EPERM; 409 410 err = attribute->param->set(buf, attribute->param); 411 if (!err) 412 return len; 413 return err; 414 } 415 416 #ifdef CONFIG_MODULES 417 #define __modinit 418 #else 419 #define __modinit __init 420 #endif 421 422 /* 423 * param_sysfs_setup - setup sysfs support for one module or KBUILD_MODNAME 424 * @mk: struct module_kobject (contains parent kobject) 425 * @kparam: array of struct kernel_param, the actual parameter definitions 426 * @num_params: number of entries in array 427 * @name_skip: offset where the parameter name start in kparam[].name. Needed for built-in "modules" 428 * 429 * Create a kobject for a (per-module) group of parameters, and create files 430 * in sysfs. A pointer to the param_kobject is returned on success, 431 * NULL if there's no parameter to export, or other ERR_PTR(err). 432 */ 433 static __modinit struct module_param_attrs * 434 param_sysfs_setup(struct module_kobject *mk, 435 struct kernel_param *kparam, 436 unsigned int num_params, 437 unsigned int name_skip) 438 { 439 struct module_param_attrs *mp; 440 unsigned int valid_attrs = 0; 441 unsigned int i, size[2]; 442 struct param_attribute *pattr; 443 struct attribute **gattr; 444 int err; 445 446 for (i=0; i<num_params; i++) { 447 if (kparam[i].perm) 448 valid_attrs++; 449 } 450 451 if (!valid_attrs) 452 return NULL; 453 454 size[0] = ALIGN(sizeof(*mp) + 455 valid_attrs * sizeof(mp->attrs[0]), 456 sizeof(mp->grp.attrs[0])); 457 size[1] = (valid_attrs + 1) * sizeof(mp->grp.attrs[0]); 458 459 mp = kmalloc(size[0] + size[1], GFP_KERNEL); 460 if (!mp) 461 return ERR_PTR(-ENOMEM); 462 463 mp->grp.name = "parameters"; 464 mp->grp.attrs = (void *)mp + size[0]; 465 466 pattr = &mp->attrs[0]; 467 gattr = &mp->grp.attrs[0]; 468 for (i = 0; i < num_params; i++) { 469 struct kernel_param *kp = &kparam[i]; 470 if (kp->perm) { 471 pattr->param = kp; 472 pattr->mattr.show = param_attr_show; 473 pattr->mattr.store = param_attr_store; 474 pattr->mattr.attr.name = (char *)&kp->name[name_skip]; 475 pattr->mattr.attr.owner = mk->mod; 476 pattr->mattr.attr.mode = kp->perm; 477 *(gattr++) = &(pattr++)->mattr.attr; 478 } 479 } 480 *gattr = NULL; 481 482 if ((err = sysfs_create_group(&mk->kobj, &mp->grp))) { 483 kfree(mp); 484 return ERR_PTR(err); 485 } 486 return mp; 487 } 488 489 490 #ifdef CONFIG_MODULES 491 492 /* 493 * module_param_sysfs_setup - setup sysfs support for one module 494 * @mod: module 495 * @kparam: module parameters (array) 496 * @num_params: number of module parameters 497 * 498 * Adds sysfs entries for module parameters, and creates a link from 499 * /sys/module/[mod->name]/parameters to /sys/parameters/[mod->name]/ 500 */ 501 int module_param_sysfs_setup(struct module *mod, 502 struct kernel_param *kparam, 503 unsigned int num_params) 504 { 505 struct module_param_attrs *mp; 506 507 mp = param_sysfs_setup(&mod->mkobj, kparam, num_params, 0); 508 if (IS_ERR(mp)) 509 return PTR_ERR(mp); 510 511 mod->param_attrs = mp; 512 return 0; 513 } 514 515 /* 516 * module_param_sysfs_remove - remove sysfs support for one module 517 * @mod: module 518 * 519 * Remove sysfs entries for module parameters and the corresponding 520 * kobject. 521 */ 522 void module_param_sysfs_remove(struct module *mod) 523 { 524 if (mod->param_attrs) { 525 sysfs_remove_group(&mod->mkobj.kobj, 526 &mod->param_attrs->grp); 527 /* We are positive that no one is using any param 528 * attrs at this point. Deallocate immediately. */ 529 kfree(mod->param_attrs); 530 mod->param_attrs = NULL; 531 } 532 } 533 #endif 534 535 /* 536 * kernel_param_sysfs_setup - wrapper for built-in params support 537 */ 538 static void __init kernel_param_sysfs_setup(const char *name, 539 struct kernel_param *kparam, 540 unsigned int num_params, 541 unsigned int name_skip) 542 { 543 struct module_kobject *mk; 544 545 mk = kmalloc(sizeof(struct module_kobject), GFP_KERNEL); 546 memset(mk, 0, sizeof(struct module_kobject)); 547 548 mk->mod = THIS_MODULE; 549 kobj_set_kset_s(mk, module_subsys); 550 kobject_set_name(&mk->kobj, name); 551 kobject_register(&mk->kobj); 552 553 /* no need to keep the kobject if no parameter is exported */ 554 if (!param_sysfs_setup(mk, kparam, num_params, name_skip)) { 555 kobject_unregister(&mk->kobj); 556 kfree(mk); 557 } 558 } 559 560 /* 561 * param_sysfs_builtin - add contents in /sys/parameters for built-in modules 562 * 563 * Add module_parameters to sysfs for "modules" built into the kernel. 564 * 565 * The "module" name (KBUILD_MODNAME) is stored before a dot, the 566 * "parameter" name is stored behind a dot in kernel_param->name. So, 567 * extract the "module" name for all built-in kernel_param-eters, 568 * and for all who have the same, call kernel_param_sysfs_setup. 569 */ 570 static void __init param_sysfs_builtin(void) 571 { 572 struct kernel_param *kp, *kp_begin = NULL; 573 unsigned int i, name_len, count = 0; 574 char modname[MAX_KBUILD_MODNAME + 1] = ""; 575 576 for (i=0; i < __stop___param - __start___param; i++) { 577 char *dot; 578 579 kp = &__start___param[i]; 580 581 /* We do not handle args without periods. */ 582 dot = memchr(kp->name, '.', MAX_KBUILD_MODNAME); 583 if (!dot) { 584 DEBUGP("couldn't find period in %s\n", kp->name); 585 continue; 586 } 587 name_len = dot - kp->name; 588 589 /* new kbuild_modname? */ 590 if (strlen(modname) != name_len 591 || strncmp(modname, kp->name, name_len) != 0) { 592 /* add a new kobject for previous kernel_params. */ 593 if (count) 594 kernel_param_sysfs_setup(modname, 595 kp_begin, 596 count, 597 strlen(modname)+1); 598 599 strncpy(modname, kp->name, name_len); 600 modname[name_len] = '\0'; 601 count = 0; 602 kp_begin = kp; 603 } 604 count++; 605 } 606 607 /* last kernel_params need to be registered as well */ 608 if (count) 609 kernel_param_sysfs_setup(modname, kp_begin, count, 610 strlen(modname)+1); 611 } 612 613 614 /* module-related sysfs stuff */ 615 #ifdef CONFIG_MODULES 616 617 #define to_module_attr(n) container_of(n, struct module_attribute, attr); 618 #define to_module_kobject(n) container_of(n, struct module_kobject, kobj); 619 620 static ssize_t module_attr_show(struct kobject *kobj, 621 struct attribute *attr, 622 char *buf) 623 { 624 struct module_attribute *attribute; 625 struct module_kobject *mk; 626 int ret; 627 628 attribute = to_module_attr(attr); 629 mk = to_module_kobject(kobj); 630 631 if (!attribute->show) 632 return -EIO; 633 634 if (!try_module_get(mk->mod)) 635 return -ENODEV; 636 637 ret = attribute->show(attribute, mk->mod, buf); 638 639 module_put(mk->mod); 640 641 return ret; 642 } 643 644 static ssize_t module_attr_store(struct kobject *kobj, 645 struct attribute *attr, 646 const char *buf, size_t len) 647 { 648 struct module_attribute *attribute; 649 struct module_kobject *mk; 650 int ret; 651 652 attribute = to_module_attr(attr); 653 mk = to_module_kobject(kobj); 654 655 if (!attribute->store) 656 return -EIO; 657 658 if (!try_module_get(mk->mod)) 659 return -ENODEV; 660 661 ret = attribute->store(attribute, mk->mod, buf, len); 662 663 module_put(mk->mod); 664 665 return ret; 666 } 667 668 static struct sysfs_ops module_sysfs_ops = { 669 .show = module_attr_show, 670 .store = module_attr_store, 671 }; 672 673 #else 674 static struct sysfs_ops module_sysfs_ops = { 675 .show = NULL, 676 .store = NULL, 677 }; 678 #endif 679 680 static struct kobj_type module_ktype = { 681 .sysfs_ops = &module_sysfs_ops, 682 }; 683 684 decl_subsys(module, &module_ktype, NULL); 685 686 /* 687 * param_sysfs_init - wrapper for built-in params support 688 */ 689 static int __init param_sysfs_init(void) 690 { 691 subsystem_register(&module_subsys); 692 693 param_sysfs_builtin(); 694 695 return 0; 696 } 697 __initcall(param_sysfs_init); 698 699 EXPORT_SYMBOL(param_set_byte); 700 EXPORT_SYMBOL(param_get_byte); 701 EXPORT_SYMBOL(param_set_short); 702 EXPORT_SYMBOL(param_get_short); 703 EXPORT_SYMBOL(param_set_ushort); 704 EXPORT_SYMBOL(param_get_ushort); 705 EXPORT_SYMBOL(param_set_int); 706 EXPORT_SYMBOL(param_get_int); 707 EXPORT_SYMBOL(param_set_uint); 708 EXPORT_SYMBOL(param_get_uint); 709 EXPORT_SYMBOL(param_set_long); 710 EXPORT_SYMBOL(param_get_long); 711 EXPORT_SYMBOL(param_set_ulong); 712 EXPORT_SYMBOL(param_get_ulong); 713 EXPORT_SYMBOL(param_set_charp); 714 EXPORT_SYMBOL(param_get_charp); 715 EXPORT_SYMBOL(param_set_bool); 716 EXPORT_SYMBOL(param_get_bool); 717 EXPORT_SYMBOL(param_set_invbool); 718 EXPORT_SYMBOL(param_get_invbool); 719 EXPORT_SYMBOL(param_array_set); 720 EXPORT_SYMBOL(param_array_get); 721 EXPORT_SYMBOL(param_set_copystring); 722 EXPORT_SYMBOL(param_get_string); 723