params.c 21.4 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
/* Helpers for initial module or kernel cmdline parsing
   Copyright (C) 2001 Rusty Russell.

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
18
#include <linux/module.h>
L
Linus Torvalds 已提交
19 20 21 22 23 24
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/err.h>
T
Tim Schmielau 已提交
25
#include <linux/slab.h>
26
#include <linux/ctype.h>
L
Linus Torvalds 已提交
27

28 29 30
/* Protects all parameters, and incidentally kmalloced_param list. */
static DEFINE_MUTEX(param_lock);

31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
/* This just allows us to keep track of which parameters are kmalloced. */
struct kmalloced_param {
	struct list_head list;
	char val[];
};
static LIST_HEAD(kmalloced_params);

static void *kmalloc_parameter(unsigned int size)
{
	struct kmalloced_param *p;

	p = kmalloc(sizeof(*p) + size, GFP_KERNEL);
	if (!p)
		return NULL;

	list_add(&p->list, &kmalloced_params);
	return p->val;
}

/* Does nothing if parameter wasn't kmalloced above. */
static void maybe_kfree_parameter(void *param)
{
	struct kmalloced_param *p;

	list_for_each_entry(p, &kmalloced_params, list) {
		if (p->val == param) {
			list_del(&p->list);
			kfree(p);
			break;
		}
	}
}

64
static char dash2underscore(char c)
L
Linus Torvalds 已提交
65 66 67 68 69 70
{
	if (c == '-')
		return '_';
	return c;
}

71
bool parameqn(const char *a, const char *b, size_t n)
L
Linus Torvalds 已提交
72
{
73 74 75 76 77 78 79 80 81 82 83 84
	size_t i;

	for (i = 0; i < n; i++) {
		if (dash2underscore(a[i]) != dash2underscore(b[i]))
			return false;
	}
	return true;
}

bool parameq(const char *a, const char *b)
{
	return parameqn(a, b, strlen(a)+1);
L
Linus Torvalds 已提交
85 86 87 88
}

static int parse_one(char *param,
		     char *val,
89
		     const struct kernel_param *params,
L
Linus Torvalds 已提交
90 91 92 93
		     unsigned num_params,
		     int (*handle_unknown)(char *param, char *val))
{
	unsigned int i;
94
	int err;
L
Linus Torvalds 已提交
95 96 97 98

	/* Find parameter */
	for (i = 0; i < num_params; i++) {
		if (parameq(param, params[i].name)) {
L
Lucas De Marchi 已提交
99
			/* No one handled NULL, so do it here. */
100
			if (!val && params[i].ops->set != param_set_bool)
101
				return -EINVAL;
102
			pr_debug("They are equal!  Calling %p\n",
103
			       params[i].ops->set);
104 105 106 107
			mutex_lock(&param_lock);
			err = params[i].ops->set(val, &params[i]);
			mutex_unlock(&param_lock);
			return err;
L
Linus Torvalds 已提交
108 109 110 111
		}
	}

	if (handle_unknown) {
112
		pr_debug("Unknown argument: calling %p\n", handle_unknown);
L
Linus Torvalds 已提交
113 114 115
		return handle_unknown(param, val);
	}

116
	pr_debug("Unknown argument `%s'\n", param);
L
Linus Torvalds 已提交
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
	return -ENOENT;
}

/* You can use " around spaces, but can't escape ". */
/* Hyphens and underscores equivalent in parameter names. */
static char *next_arg(char *args, char **param, char **val)
{
	unsigned int i, equals = 0;
	int in_quote = 0, quoted = 0;
	char *next;

	if (*args == '"') {
		args++;
		in_quote = 1;
		quoted = 1;
	}

	for (i = 0; args[i]; i++) {
135
		if (isspace(args[i]) && !in_quote)
L
Linus Torvalds 已提交
136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166
			break;
		if (equals == 0) {
			if (args[i] == '=')
				equals = i;
		}
		if (args[i] == '"')
			in_quote = !in_quote;
	}

	*param = args;
	if (!equals)
		*val = NULL;
	else {
		args[equals] = '\0';
		*val = args + equals + 1;

		/* Don't include quotes in value. */
		if (**val == '"') {
			(*val)++;
			if (args[i-1] == '"')
				args[i-1] = '\0';
		}
		if (quoted && args[i-1] == '"')
			args[i-1] = '\0';
	}

	if (args[i]) {
		args[i] = '\0';
		next = args + i + 1;
	} else
		next = args + i;
167 168

	/* Chew up trailing spaces. */
169
	return skip_spaces(next);
L
Linus Torvalds 已提交
170 171 172 173 174
}

/* Args looks like "foo=bar,bar2 baz=fuz wiz". */
int parse_args(const char *name,
	       char *args,
175
	       const struct kernel_param *params,
L
Linus Torvalds 已提交
176 177 178 179 180
	       unsigned num,
	       int (*unknown)(char *param, char *val))
{
	char *param, *val;

181
	pr_debug("Parsing ARGS: %s\n", args);
L
Linus Torvalds 已提交
182

183
	/* Chew leading spaces */
184
	args = skip_spaces(args);
185

L
Linus Torvalds 已提交
186 187
	while (*args) {
		int ret;
188
		int irq_was_disabled;
L
Linus Torvalds 已提交
189 190

		args = next_arg(args, &param, &val);
191
		irq_was_disabled = irqs_disabled();
L
Linus Torvalds 已提交
192
		ret = parse_one(param, val, params, num, unknown);
193 194 195 196
		if (irq_was_disabled && !irqs_disabled()) {
			printk(KERN_WARNING "parse_args(): option '%s' enabled "
					"irq's!\n", param);
		}
L
Linus Torvalds 已提交
197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222
		switch (ret) {
		case -ENOENT:
			printk(KERN_ERR "%s: Unknown parameter `%s'\n",
			       name, param);
			return ret;
		case -ENOSPC:
			printk(KERN_ERR
			       "%s: `%s' too large for parameter `%s'\n",
			       name, val ?: "", param);
			return ret;
		case 0:
			break;
		default:
			printk(KERN_ERR
			       "%s: `%s' invalid for parameter `%s'\n",
			       name, val ?: "", param);
			return ret;
		}
	}

	/* All parsed OK. */
	return 0;
}

/* Lazy bastard, eh? */
#define STANDARD_PARAM_DEF(name, type, format, tmptype, strtolfn)      	\
223
	int param_set_##name(const char *val, const struct kernel_param *kp) \
L
Linus Torvalds 已提交
224 225
	{								\
		tmptype l;						\
226
		int ret;						\
L
Linus Torvalds 已提交
227
									\
228
		ret = strtolfn(val, 0, &l);				\
229 230
		if (ret < 0 || ((type)l != l))				\
			return ret < 0 ? ret : -EINVAL;			\
L
Linus Torvalds 已提交
231 232 233
		*((type *)kp->arg) = l;					\
		return 0;						\
	}								\
234
	int param_get_##name(char *buffer, const struct kernel_param *kp) \
L
Linus Torvalds 已提交
235 236
	{								\
		return sprintf(buffer, format, *((type *)kp->arg));	\
237
	}								\
238 239 240 241
	struct kernel_param_ops param_ops_##name = {			\
		.set = param_set_##name,				\
		.get = param_get_##name,				\
	};								\
242
	EXPORT_SYMBOL(param_set_##name);				\
243 244 245
	EXPORT_SYMBOL(param_get_##name);				\
	EXPORT_SYMBOL(param_ops_##name)

L
Linus Torvalds 已提交
246

247 248 249 250 251 252 253
STANDARD_PARAM_DEF(byte, unsigned char, "%c", unsigned long, strict_strtoul);
STANDARD_PARAM_DEF(short, short, "%hi", long, strict_strtol);
STANDARD_PARAM_DEF(ushort, unsigned short, "%hu", unsigned long, strict_strtoul);
STANDARD_PARAM_DEF(int, int, "%i", long, strict_strtol);
STANDARD_PARAM_DEF(uint, unsigned int, "%u", unsigned long, strict_strtoul);
STANDARD_PARAM_DEF(long, long, "%li", long, strict_strtol);
STANDARD_PARAM_DEF(ulong, unsigned long, "%lu", unsigned long, strict_strtoul);
L
Linus Torvalds 已提交
254

255
int param_set_charp(const char *val, const struct kernel_param *kp)
L
Linus Torvalds 已提交
256 257 258 259 260 261 262
{
	if (strlen(val) > 1024) {
		printk(KERN_ERR "%s: string parameter too long\n",
		       kp->name);
		return -ENOSPC;
	}

263 264 265
	maybe_kfree_parameter(*(char **)kp->arg);

	/* This is a hack.  We can't kmalloc in early boot, and we
266 267
	 * don't need to; this mangled commandline is preserved. */
	if (slab_is_available()) {
268
		*(char **)kp->arg = kmalloc_parameter(strlen(val)+1);
R
Rusty Russell 已提交
269
		if (!*(char **)kp->arg)
270
			return -ENOMEM;
271
		strcpy(*(char **)kp->arg, val);
272 273 274
	} else
		*(const char **)kp->arg = val;

L
Linus Torvalds 已提交
275 276
	return 0;
}
277
EXPORT_SYMBOL(param_set_charp);
L
Linus Torvalds 已提交
278

279
int param_get_charp(char *buffer, const struct kernel_param *kp)
L
Linus Torvalds 已提交
280 281 282
{
	return sprintf(buffer, "%s", *((char **)kp->arg));
}
283
EXPORT_SYMBOL(param_get_charp);
L
Linus Torvalds 已提交
284

285 286 287 288 289
static void param_free_charp(void *arg)
{
	maybe_kfree_parameter(*((char **)arg));
}

290 291 292
struct kernel_param_ops param_ops_charp = {
	.set = param_set_charp,
	.get = param_get_charp,
293
	.free = param_free_charp,
294 295 296
};
EXPORT_SYMBOL(param_ops_charp);

297
/* Actually could be a bool or an int, for historical reasons. */
298
int param_set_bool(const char *val, const struct kernel_param *kp)
L
Linus Torvalds 已提交
299
{
300
	bool v;
301
	int ret;
302

L
Linus Torvalds 已提交
303 304 305 306
	/* No equals means "set"... */
	if (!val) val = "1";

	/* One of =[yYnN01] */
307 308 309
	ret = strtobool(val, &v);
	if (ret)
		return ret;
310 311 312 313 314 315

	if (kp->flags & KPARAM_ISBOOL)
		*(bool *)kp->arg = v;
	else
		*(int *)kp->arg = v;
	return 0;
L
Linus Torvalds 已提交
316
}
317
EXPORT_SYMBOL(param_set_bool);
L
Linus Torvalds 已提交
318

319
int param_get_bool(char *buffer, const struct kernel_param *kp)
L
Linus Torvalds 已提交
320
{
321 322 323 324 325 326
	bool val;
	if (kp->flags & KPARAM_ISBOOL)
		val = *(bool *)kp->arg;
	else
		val = *(int *)kp->arg;

L
Linus Torvalds 已提交
327
	/* Y and N chosen as being relatively non-coder friendly */
328
	return sprintf(buffer, "%c", val ? 'Y' : 'N');
L
Linus Torvalds 已提交
329
}
330
EXPORT_SYMBOL(param_get_bool);
L
Linus Torvalds 已提交
331

332 333 334 335 336 337
struct kernel_param_ops param_ops_bool = {
	.set = param_set_bool,
	.get = param_get_bool,
};
EXPORT_SYMBOL(param_ops_bool);

338
/* This one must be bool. */
339
int param_set_invbool(const char *val, const struct kernel_param *kp)
L
Linus Torvalds 已提交
340
{
341 342
	int ret;
	bool boolval;
343
	struct kernel_param dummy;
L
Linus Torvalds 已提交
344

345
	dummy.arg = &boolval;
346
	dummy.flags = KPARAM_ISBOOL;
L
Linus Torvalds 已提交
347 348
	ret = param_set_bool(val, &dummy);
	if (ret == 0)
349
		*(bool *)kp->arg = !boolval;
L
Linus Torvalds 已提交
350 351
	return ret;
}
352
EXPORT_SYMBOL(param_set_invbool);
L
Linus Torvalds 已提交
353

354
int param_get_invbool(char *buffer, const struct kernel_param *kp)
L
Linus Torvalds 已提交
355
{
356
	return sprintf(buffer, "%c", (*(bool *)kp->arg) ? 'N' : 'Y');
L
Linus Torvalds 已提交
357
}
358
EXPORT_SYMBOL(param_get_invbool);
L
Linus Torvalds 已提交
359

360 361 362 363 364 365
struct kernel_param_ops param_ops_invbool = {
	.set = param_set_invbool,
	.get = param_get_invbool,
};
EXPORT_SYMBOL(param_ops_invbool);

366
/* We break the rule and mangle the string. */
367 368 369 370
static int param_array(const char *name,
		       const char *val,
		       unsigned int min, unsigned int max,
		       void *elem, int elemsize,
371
		       int (*set)(const char *, const struct kernel_param *kp),
R
Rusty Russell 已提交
372
		       u16 flags,
373
		       unsigned int *num)
L
Linus Torvalds 已提交
374 375 376 377 378 379 380 381
{
	int ret;
	struct kernel_param kp;
	char save;

	/* Get the name right for errors. */
	kp.name = name;
	kp.arg = elem;
R
Rusty Russell 已提交
382
	kp.flags = flags;
L
Linus Torvalds 已提交
383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398

	*num = 0;
	/* We expect a comma-separated list of values. */
	do {
		int len;

		if (*num == max) {
			printk(KERN_ERR "%s: can only take %i arguments\n",
			       name, max);
			return -EINVAL;
		}
		len = strcspn(val, ",");

		/* nul-terminate and parse */
		save = val[len];
		((char *)val)[len] = '\0';
399
		BUG_ON(!mutex_is_locked(&param_lock));
L
Linus Torvalds 已提交
400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416
		ret = set(val, &kp);

		if (ret != 0)
			return ret;
		kp.arg += elemsize;
		val += len+1;
		(*num)++;
	} while (save == ',');

	if (*num < min) {
		printk(KERN_ERR "%s: needs at least %i arguments\n",
		       name, min);
		return -EINVAL;
	}
	return 0;
}

417
static int param_array_set(const char *val, const struct kernel_param *kp)
L
Linus Torvalds 已提交
418
{
419
	const struct kparam_array *arr = kp->arr;
420
	unsigned int temp_num;
L
Linus Torvalds 已提交
421 422

	return param_array(kp->name, val, 1, arr->max, arr->elem,
423
			   arr->elemsize, arr->ops->set, kp->flags,
R
Rusty Russell 已提交
424
			   arr->num ?: &temp_num);
L
Linus Torvalds 已提交
425 426
}

427
static int param_array_get(char *buffer, const struct kernel_param *kp)
L
Linus Torvalds 已提交
428 429
{
	int i, off, ret;
430
	const struct kparam_array *arr = kp->arr;
L
Linus Torvalds 已提交
431 432 433 434 435 436 437
	struct kernel_param p;

	p = *kp;
	for (i = off = 0; i < (arr->num ? *arr->num : arr->max); i++) {
		if (i)
			buffer[off++] = ',';
		p.arg = arr->elem + arr->elemsize * i;
438
		BUG_ON(!mutex_is_locked(&param_lock));
439
		ret = arr->ops->get(buffer + off, &p);
L
Linus Torvalds 已提交
440 441 442 443 444 445 446 447
		if (ret < 0)
			return ret;
		off += ret;
	}
	buffer[off] = '\0';
	return off;
}

448 449 450 451 452 453 454 455 456 457
static void param_array_free(void *arg)
{
	unsigned int i;
	const struct kparam_array *arr = arg;

	if (arr->ops->free)
		for (i = 0; i < (arr->num ? *arr->num : arr->max); i++)
			arr->ops->free(arr->elem + arr->elemsize * i);
}

458 459 460
struct kernel_param_ops param_array_ops = {
	.set = param_array_set,
	.get = param_array_get,
461
	.free = param_array_free,
462 463 464 465
};
EXPORT_SYMBOL(param_array_ops);

int param_set_copystring(const char *val, const struct kernel_param *kp)
L
Linus Torvalds 已提交
466
{
467
	const struct kparam_string *kps = kp->str;
L
Linus Torvalds 已提交
468 469 470 471 472 473 474 475 476

	if (strlen(val)+1 > kps->maxlen) {
		printk(KERN_ERR "%s: string doesn't fit in %u chars.\n",
		       kp->name, kps->maxlen-1);
		return -ENOSPC;
	}
	strcpy(kps->string, val);
	return 0;
}
477
EXPORT_SYMBOL(param_set_copystring);
L
Linus Torvalds 已提交
478

479
int param_get_string(char *buffer, const struct kernel_param *kp)
L
Linus Torvalds 已提交
480
{
481
	const struct kparam_string *kps = kp->str;
L
Linus Torvalds 已提交
482 483
	return strlcpy(buffer, kps->string, kps->maxlen);
}
484
EXPORT_SYMBOL(param_get_string);
L
Linus Torvalds 已提交
485

486 487 488 489 490 491
struct kernel_param_ops param_ops_string = {
	.set = param_set_copystring,
	.get = param_get_string,
};
EXPORT_SYMBOL(param_ops_string);

L
Linus Torvalds 已提交
492
/* sysfs output in /sys/modules/XYZ/parameters/ */
493 494
#define to_module_attr(n) container_of(n, struct module_attribute, attr)
#define to_module_kobject(n) container_of(n, struct module_kobject, kobj)
L
Linus Torvalds 已提交
495 496 497 498 499 500

extern struct kernel_param __start___param[], __stop___param[];

struct param_attribute
{
	struct module_attribute mattr;
501
	const struct kernel_param *param;
L
Linus Torvalds 已提交
502 503 504 505
};

struct module_param_attrs
{
506
	unsigned int num;
L
Linus Torvalds 已提交
507 508 509 510
	struct attribute_group grp;
	struct param_attribute attrs[0];
};

511
#ifdef CONFIG_SYSFS
512
#define to_param_attr(n) container_of(n, struct param_attribute, mattr)
L
Linus Torvalds 已提交
513 514

static ssize_t param_attr_show(struct module_attribute *mattr,
515
			       struct module_kobject *mk, char *buf)
L
Linus Torvalds 已提交
516 517 518 519
{
	int count;
	struct param_attribute *attribute = to_param_attr(mattr);

520
	if (!attribute->param->ops->get)
L
Linus Torvalds 已提交
521 522
		return -EPERM;

523
	mutex_lock(&param_lock);
524
	count = attribute->param->ops->get(buf, attribute->param);
525
	mutex_unlock(&param_lock);
L
Linus Torvalds 已提交
526 527 528 529 530 531 532 533 534
	if (count > 0) {
		strcat(buf, "\n");
		++count;
	}
	return count;
}

/* sysfs always hands a nul-terminated string in buf.  We rely on that. */
static ssize_t param_attr_store(struct module_attribute *mattr,
535
				struct module_kobject *km,
L
Linus Torvalds 已提交
536 537 538 539 540
				const char *buf, size_t len)
{
 	int err;
	struct param_attribute *attribute = to_param_attr(mattr);

541
	if (!attribute->param->ops->set)
L
Linus Torvalds 已提交
542 543
		return -EPERM;

544
	mutex_lock(&param_lock);
545
	err = attribute->param->ops->set(buf, attribute->param);
546
	mutex_unlock(&param_lock);
L
Linus Torvalds 已提交
547 548 549 550
	if (!err)
		return len;
	return err;
}
551
#endif
L
Linus Torvalds 已提交
552 553 554 555 556 557 558

#ifdef CONFIG_MODULES
#define __modinit
#else
#define __modinit __init
#endif

559
#ifdef CONFIG_SYSFS
560 561 562 563 564 565 566 567 568 569 570 571
void __kernel_param_lock(void)
{
	mutex_lock(&param_lock);
}
EXPORT_SYMBOL(__kernel_param_lock);

void __kernel_param_unlock(void)
{
	mutex_unlock(&param_lock);
}
EXPORT_SYMBOL(__kernel_param_unlock);

L
Linus Torvalds 已提交
572
/*
573 574 575 576
 * add_sysfs_param - add a parameter to sysfs
 * @mk: struct module_kobject
 * @kparam: the actual parameter definition to add to sysfs
 * @name: name of parameter
L
Linus Torvalds 已提交
577
 *
578 579 580
 * Create a kobject if for a (per-module) parameter if mp NULL, and
 * create file in sysfs.  Returns an error on out of memory.  Always cleans up
 * if there's an error.
L
Linus Torvalds 已提交
581
 */
582
static __modinit int add_sysfs_param(struct module_kobject *mk,
583
				     const struct kernel_param *kp,
584
				     const char *name)
L
Linus Torvalds 已提交
585
{
586 587 588 589 590 591 592 593 594 595 596 597 598
	struct module_param_attrs *new;
	struct attribute **attrs;
	int err, num;

	/* We don't bother calling this with invisible parameters. */
	BUG_ON(!kp->perm);

	if (!mk->mp) {
		num = 0;
		attrs = NULL;
	} else {
		num = mk->mp->num;
		attrs = mk->mp->grp.attrs;
L
Linus Torvalds 已提交
599 600
	}

601 602 603 604 605 606 607 608 609 610 611 612 613 614
	/* Enlarge. */
	new = krealloc(mk->mp,
		       sizeof(*mk->mp) + sizeof(mk->mp->attrs[0]) * (num+1),
		       GFP_KERNEL);
	if (!new) {
		kfree(mk->mp);
		err = -ENOMEM;
		goto fail;
	}
	attrs = krealloc(attrs, sizeof(new->grp.attrs[0])*(num+2), GFP_KERNEL);
	if (!attrs) {
		err = -ENOMEM;
		goto fail_free_new;
	}
L
Linus Torvalds 已提交
615

616 617 618 619 620 621 622 623
	/* Sysfs wants everything zeroed. */
	memset(new, 0, sizeof(*new));
	memset(&new->attrs[num], 0, sizeof(new->attrs[num]));
	memset(&attrs[num], 0, sizeof(attrs[num]));
	new->grp.name = "parameters";
	new->grp.attrs = attrs;

	/* Tack new one on the end. */
624
	sysfs_attr_init(&new->attrs[num].mattr.attr);
625 626 627 628 629 630 631 632 633 634 635 636 637 638
	new->attrs[num].param = kp;
	new->attrs[num].mattr.show = param_attr_show;
	new->attrs[num].mattr.store = param_attr_store;
	new->attrs[num].mattr.attr.name = (char *)name;
	new->attrs[num].mattr.attr.mode = kp->perm;
	new->num = num+1;

	/* Fix up all the pointers, since krealloc can move us */
	for (num = 0; num < new->num; num++)
		new->grp.attrs[num] = &new->attrs[num].mattr.attr;
	new->grp.attrs[num] = NULL;

	mk->mp = new;
	return 0;
L
Linus Torvalds 已提交
639

640 641 642 643 644 645
fail_free_new:
	kfree(new);
fail:
	mk->mp = NULL;
	return err;
}
L
Linus Torvalds 已提交
646

647
#ifdef CONFIG_MODULES
648 649 650 651 652
static void free_module_param_attrs(struct module_kobject *mk)
{
	kfree(mk->mp->grp.attrs);
	kfree(mk->mp);
	mk->mp = NULL;
L
Linus Torvalds 已提交
653 654 655 656 657 658 659 660
}

/*
 * module_param_sysfs_setup - setup sysfs support for one module
 * @mod: module
 * @kparam: module parameters (array)
 * @num_params: number of module parameters
 *
661 662
 * Adds sysfs entries for module parameters under
 * /sys/module/[mod->name]/parameters/
L
Linus Torvalds 已提交
663 664
 */
int module_param_sysfs_setup(struct module *mod,
665
			     const struct kernel_param *kparam,
L
Linus Torvalds 已提交
666 667
			     unsigned int num_params)
{
668 669 670 671 672 673 674 675 676 677 678
	int i, err;
	bool params = false;

	for (i = 0; i < num_params; i++) {
		if (kparam[i].perm == 0)
			continue;
		err = add_sysfs_param(&mod->mkobj, &kparam[i], kparam[i].name);
		if (err)
			return err;
		params = true;
	}
L
Linus Torvalds 已提交
679

680 681
	if (!params)
		return 0;
L
Linus Torvalds 已提交
682

683 684 685 686 687
	/* Create the param group. */
	err = sysfs_create_group(&mod->mkobj.kobj, &mod->mkobj.mp->grp);
	if (err)
		free_module_param_attrs(&mod->mkobj);
	return err;
L
Linus Torvalds 已提交
688 689 690 691 692 693 694 695 696 697 698
}

/*
 * module_param_sysfs_remove - remove sysfs support for one module
 * @mod: module
 *
 * Remove sysfs entries for module parameters and the corresponding
 * kobject.
 */
void module_param_sysfs_remove(struct module *mod)
{
699 700
	if (mod->mkobj.mp) {
		sysfs_remove_group(&mod->mkobj.kobj, &mod->mkobj.mp->grp);
L
Linus Torvalds 已提交
701 702
		/* We are positive that no one is using any param
		 * attrs at this point.  Deallocate immediately. */
703
		free_module_param_attrs(&mod->mkobj);
L
Linus Torvalds 已提交
704 705 706 707
	}
}
#endif

708 709
void destroy_params(const struct kernel_param *params, unsigned num)
{
710 711 712 713 714
	unsigned int i;

	for (i = 0; i < num; i++)
		if (params[i].ops->free)
			params[i].ops->free(params[i].arg);
715 716
}

717
static struct module_kobject * __init locate_module_kobject(const char *name)
L
Linus Torvalds 已提交
718 719
{
	struct module_kobject *mk;
720 721
	struct kobject *kobj;
	int err;
L
Linus Torvalds 已提交
722

723 724 725 726 727 728 729 730 731 732 733
	kobj = kset_find_obj(module_kset, name);
	if (kobj) {
		mk = to_module_kobject(kobj);
	} else {
		mk = kzalloc(sizeof(struct module_kobject), GFP_KERNEL);
		BUG_ON(!mk);

		mk->mod = THIS_MODULE;
		mk->kobj.kset = module_kset;
		err = kobject_init_and_add(&mk->kobj, &module_ktype, NULL,
					   "%s", name);
734 735 736 737
#ifdef CONFIG_MODULES
		if (!err)
			err = sysfs_create_file(&mk->kobj, &module_uevent.attr);
#endif
738 739
		if (err) {
			kobject_put(&mk->kobj);
740 741 742 743 744 745
			printk(KERN_ERR
				"Module '%s' failed add to sysfs, error number %d\n",
				name, err);
			printk(KERN_ERR
				"The system will be unstable now.\n");
			return NULL;
746
		}
747 748

		/* So that we hold reference in both cases. */
749
		kobject_get(&mk->kobj);
750
	}
751

752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769
	return mk;
}

static void __init kernel_add_sysfs_param(const char *name,
					  struct kernel_param *kparam,
					  unsigned int name_skip)
{
	struct module_kobject *mk;
	int err;

	mk = locate_module_kobject(name);
	if (!mk)
		return;

	/* We need to remove old parameters before adding more. */
	if (mk->mp)
		sysfs_remove_group(&mk->kobj, &mk->mp->grp);

770 771 772 773 774
	/* These should not fail at boot. */
	err = add_sysfs_param(mk, kparam, kparam->name + name_skip);
	BUG_ON(err);
	err = sysfs_create_group(&mk->kobj, &mk->mp->grp);
	BUG_ON(err);
775
	kobject_uevent(&mk->kobj, KOBJ_ADD);
776
	kobject_put(&mk->kobj);
L
Linus Torvalds 已提交
777 778 779 780 781 782 783 784 785 786
}

/*
 * param_sysfs_builtin - add contents in /sys/parameters for built-in modules
 *
 * Add module_parameters to sysfs for "modules" built into the kernel.
 *
 * The "module" name (KBUILD_MODNAME) is stored before a dot, the
 * "parameter" name is stored behind a dot in kernel_param->name. So,
 * extract the "module" name for all built-in kernel_param-eters,
787
 * and for all who have the same, call kernel_add_sysfs_param.
L
Linus Torvalds 已提交
788 789 790
 */
static void __init param_sysfs_builtin(void)
{
791 792 793
	struct kernel_param *kp;
	unsigned int name_len;
	char modname[MODULE_NAME_LEN];
L
Linus Torvalds 已提交
794

795
	for (kp = __start___param; kp < __stop___param; kp++) {
L
Linus Torvalds 已提交
796 797
		char *dot;

798 799
		if (kp->perm == 0)
			continue;
L
Linus Torvalds 已提交
800

801
		dot = strchr(kp->name, '.');
L
Linus Torvalds 已提交
802
		if (!dot) {
803 804 805 806 807 808
			/* This happens for core_param() */
			strcpy(modname, "kernel");
			name_len = 0;
		} else {
			name_len = dot - kp->name + 1;
			strlcpy(modname, kp->name, name_len);
L
Linus Torvalds 已提交
809
		}
810
		kernel_add_sysfs_param(modname, kp, name_len);
L
Linus Torvalds 已提交
811 812 813
	}
}

814
ssize_t __modver_version_show(struct module_attribute *mattr,
815
			      struct module_kobject *mk, char *buf)
816 817 818 819 820 821 822
{
	struct module_version_attribute *vattr =
		container_of(mattr, struct module_version_attribute, mattr);

	return sprintf(buf, "%s\n", vattr->version);
}

823 824
extern const struct module_version_attribute *__start___modver[];
extern const struct module_version_attribute *__stop___modver[];
825 826 827

static void __init version_sysfs_builtin(void)
{
828
	const struct module_version_attribute **p;
829 830 831
	struct module_kobject *mk;
	int err;

832 833 834
	for (p = __start___modver; p < __stop___modver; p++) {
		const struct module_version_attribute *vattr = *p;

835 836 837 838 839 840 841 842
		mk = locate_module_kobject(vattr->module_name);
		if (mk) {
			err = sysfs_create_file(&mk->kobj, &vattr->mattr.attr);
			kobject_uevent(&mk->kobj, KOBJ_ADD);
			kobject_put(&mk->kobj);
		}
	}
}
L
Linus Torvalds 已提交
843 844 845 846 847 848 849 850 851 852 853 854 855 856 857

/* module-related sysfs stuff */

static ssize_t module_attr_show(struct kobject *kobj,
				struct attribute *attr,
				char *buf)
{
	struct module_attribute *attribute;
	struct module_kobject *mk;
	int ret;

	attribute = to_module_attr(attr);
	mk = to_module_kobject(kobj);

	if (!attribute->show)
858
		return -EIO;
L
Linus Torvalds 已提交
859

860
	ret = attribute->show(attribute, mk, buf);
L
Linus Torvalds 已提交
861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876

	return ret;
}

static ssize_t module_attr_store(struct kobject *kobj,
				struct attribute *attr,
				const char *buf, size_t len)
{
	struct module_attribute *attribute;
	struct module_kobject *mk;
	int ret;

	attribute = to_module_attr(attr);
	mk = to_module_kobject(kobj);

	if (!attribute->store)
877
		return -EIO;
L
Linus Torvalds 已提交
878

879
	ret = attribute->store(attribute, mk, buf, len);
L
Linus Torvalds 已提交
880 881 882 883

	return ret;
}

884
static const struct sysfs_ops module_sysfs_ops = {
L
Linus Torvalds 已提交
885 886 887 888
	.show = module_attr_show,
	.store = module_attr_store,
};

K
Kay Sievers 已提交
889 890 891 892 893 894 895 896 897
static int uevent_filter(struct kset *kset, struct kobject *kobj)
{
	struct kobj_type *ktype = get_ktype(kobj);

	if (ktype == &module_ktype)
		return 1;
	return 0;
}

898
static const struct kset_uevent_ops module_uevent_ops = {
K
Kay Sievers 已提交
899 900 901
	.filter = uevent_filter,
};

902
struct kset *module_kset;
903
int module_sysfs_initialized;
L
Linus Torvalds 已提交
904

905
struct kobj_type module_ktype = {
L
Linus Torvalds 已提交
906 907 908 909 910 911 912 913
	.sysfs_ops =	&module_sysfs_ops,
};

/*
 * param_sysfs_init - wrapper for built-in params support
 */
static int __init param_sysfs_init(void)
{
914 915 916 917 918
	module_kset = kset_create_and_add("module", &module_uevent_ops, NULL);
	if (!module_kset) {
		printk(KERN_WARNING "%s (%d): error creating kset\n",
			__FILE__, __LINE__);
		return -ENOMEM;
919
	}
920
	module_sysfs_initialized = 1;
L
Linus Torvalds 已提交
921

922
	version_sysfs_builtin();
L
Linus Torvalds 已提交
923 924 925 926
	param_sysfs_builtin();

	return 0;
}
927
subsys_initcall(param_sysfs_init);
L
Linus Torvalds 已提交
928

929
#endif /* CONFIG_SYSFS */