kernel/params.c

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