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 */
  30static 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
  39static inline void check_kparam_locked(struct module *mod)
  40{
  41	BUG_ON(!mutex_is_locked(KPARAM_MUTEX(mod)));
  42}
  43#else
  44static 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. */
  50struct kmalloced_param {
  51	struct list_head list;
  52	char val[];
  53};
  54static LIST_HEAD(kmalloced_params);
  55static DEFINE_SPINLOCK(kmalloced_params_lock);
  56
  57static 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. */
  73static 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
  88static char dash2underscore(char c)
  89{
  90	if (c == '-')
  91		return '_';
  92	return c;
  93}
  94
  95bool 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
 106bool parameq(const char *a, const char *b)
 107{
 108	return parameqn(a, b, strlen(a)+1);
 109}
 110
 111static 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
 120static 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. */
 165static 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". */
 216char *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
 291STANDARD_PARAM_DEF(byte, unsigned char, "%hhu", kstrtou8);
 292STANDARD_PARAM_DEF(short, short, "%hi", kstrtos16);
 293STANDARD_PARAM_DEF(ushort, unsigned short, "%hu", kstrtou16);
 294STANDARD_PARAM_DEF(int, int, "%i", kstrtoint);
 295STANDARD_PARAM_DEF(uint, unsigned int, "%u", kstrtouint);
 296STANDARD_PARAM_DEF(long, long, "%li", kstrtol);
 297STANDARD_PARAM_DEF(ulong, unsigned long, "%lu", kstrtoul);
 298STANDARD_PARAM_DEF(ullong, unsigned long long, "%llu", kstrtoull);
 299
 300int 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}
 321EXPORT_SYMBOL(param_set_charp);
 322
 323int param_get_charp(char *buffer, const struct kernel_param *kp)
 324{
 325	return scnprintf(buffer, PAGE_SIZE, "%s", *((char **)kp->arg));
 326}
 327EXPORT_SYMBOL(param_get_charp);
 328
 329void param_free_charp(void *arg)
 330{
 331	maybe_kfree_parameter(*((char **)arg));
 332}
 333EXPORT_SYMBOL(param_free_charp);
 334
 335const struct kernel_param_ops param_ops_charp = {
 336	.set = param_set_charp,
 337	.get = param_get_charp,
 338	.free = param_free_charp,
 339};
 340EXPORT_SYMBOL(param_ops_charp);
 341
 342/* Actually could be a bool or an int, for historical reasons. */
 343int 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}
 351EXPORT_SYMBOL(param_set_bool);
 352
 353int 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}
 358EXPORT_SYMBOL(param_get_bool);
 359
 360const 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};
 365EXPORT_SYMBOL(param_ops_bool);
 366
 367int 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}
 389EXPORT_SYMBOL_GPL(param_set_bool_enable_only);
 390
 391const 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};
 396EXPORT_SYMBOL_GPL(param_ops_bool_enable_only);
 397
 398/* This one must be bool. */
 399int 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}
 411EXPORT_SYMBOL(param_set_invbool);
 412
 413int param_get_invbool(char *buffer, const struct kernel_param *kp)
 414{
 415	return sprintf(buffer, "%c", (*(bool *)kp->arg) ? 'N' : 'Y');
 416}
 417EXPORT_SYMBOL(param_get_invbool);
 418
 419const struct kernel_param_ops param_ops_invbool = {
 420	.set = param_set_invbool,
 421	.get = param_get_invbool,
 422};
 423EXPORT_SYMBOL(param_ops_invbool);
 424
 425int 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}
 439EXPORT_SYMBOL(param_set_bint);
 440
 441const 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};
 446EXPORT_SYMBOL(param_ops_bint);
 447
 448/* We break the rule and mangle the string. */
 449static 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
 498static 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
 508static 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
 528static 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
 538const struct kernel_param_ops param_array_ops = {
 539	.set = param_array_set,
 540	.get = param_array_get,
 541	.free = param_array_free,
 542};
 543EXPORT_SYMBOL(param_array_ops);
 544
 545int 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}
 557EXPORT_SYMBOL(param_set_copystring);
 558
 559int 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}
 564EXPORT_SYMBOL(param_get_string);
 565
 566const struct kernel_param_ops param_ops_string = {
 567	.set = param_set_copystring,
 568	.get = param_get_string,
 569};
 570EXPORT_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
 576struct param_attribute
 577{
 578	struct module_attribute mattr;
 579	const struct kernel_param *param;
 580};
 581
 582struct 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
 592static 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. */
 612static 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
 639void kernel_param_lock(struct module *mod)
 640{
 641	mutex_lock(KPARAM_MUTEX(mod));
 642}
 643
 644void kernel_param_unlock(struct module *mod)
 645{
 646	mutex_unlock(KPARAM_MUTEX(mod));
 647}
 648
 649EXPORT_SYMBOL(kernel_param_lock);
 650EXPORT_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 */
 662static __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
 726static 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 */
 743int 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 */
 778void 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
 789void 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
 798static 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
 833static 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 */
 867static 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
 892ssize_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
 901extern const struct module_version_attribute *__start___modver[];
 902extern const struct module_version_attribute *__stop___modver[];
 903
 904static 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
 925static 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
 944static 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
 963static const struct sysfs_ops module_sysfs_ops = {
 964	.show = module_attr_show,
 965	.store = module_attr_store,
 966};
 967
 968static 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
 977static const struct kset_uevent_ops module_uevent_ops = {
 978	.filter = uevent_filter,
 979};
 980
 981struct kset *module_kset;
 982int module_sysfs_initialized;
 983
 984static void module_kobj_release(struct kobject *kobj)
 985{
 986	struct module_kobject *mk = to_module_kobject(kobj);
 987	complete(mk->kobj_completion);
 988}
 989
 990struct 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 */
 998static 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}
1013subsys_initcall(param_sysfs_init);
1014
1015#endif /* CONFIG_SYSFS */