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