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