params.c 19.0 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
/* 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
*/
#include <linux/moduleparam.h>
#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 31 32 33

#if 0
#define DEBUGP printk
#else
#define DEBUGP(fmt, a...)
#endif

34
static inline char dash2underscore(char c)
L
Linus Torvalds 已提交
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
{
	if (c == '-')
		return '_';
	return c;
}

static inline int parameq(const char *input, const char *paramname)
{
	unsigned int i;
	for (i = 0; dash2underscore(input[i]) == paramname[i]; i++)
		if (input[i] == '\0')
			return 1;
	return 0;
}

static int parse_one(char *param,
		     char *val,
		     struct kernel_param *params, 
		     unsigned num_params,
		     int (*handle_unknown)(char *param, char *val))
{
	unsigned int i;

	/* Find parameter */
	for (i = 0; i < num_params; i++) {
		if (parameq(param, params[i].name)) {
61
			/* Noone handled NULL, so do it here. */
62
			if (!val && params[i].ops->set != param_set_bool)
63
				return -EINVAL;
L
Linus Torvalds 已提交
64
			DEBUGP("They are equal!  Calling %p\n",
65 66
			       params[i].ops->set);
			return params[i].ops->set(val, &params[i]);
L
Linus Torvalds 已提交
67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93
		}
	}

	if (handle_unknown) {
		DEBUGP("Unknown argument: calling %p\n", handle_unknown);
		return handle_unknown(param, val);
	}

	DEBUGP("Unknown argument `%s'\n", param);
	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++) {
94
		if (isspace(args[i]) && !in_quote)
L
Linus Torvalds 已提交
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
			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;
126 127

	/* Chew up trailing spaces. */
128
	return skip_spaces(next);
L
Linus Torvalds 已提交
129 130 131 132 133 134 135 136 137 138 139 140 141
}

/* Args looks like "foo=bar,bar2 baz=fuz wiz". */
int parse_args(const char *name,
	       char *args,
	       struct kernel_param *params,
	       unsigned num,
	       int (*unknown)(char *param, char *val))
{
	char *param, *val;

	DEBUGP("Parsing ARGS: %s\n", args);

142
	/* Chew leading spaces */
143
	args = skip_spaces(args);
144

L
Linus Torvalds 已提交
145 146
	while (*args) {
		int ret;
147
		int irq_was_disabled;
L
Linus Torvalds 已提交
148 149

		args = next_arg(args, &param, &val);
150
		irq_was_disabled = irqs_disabled();
L
Linus Torvalds 已提交
151
		ret = parse_one(param, val, params, num, unknown);
152 153 154 155
		if (irq_was_disabled && !irqs_disabled()) {
			printk(KERN_WARNING "parse_args(): option '%s' enabled "
					"irq's!\n", param);
		}
L
Linus Torvalds 已提交
156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
		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)      	\
182
	int param_set_##name(const char *val, const struct kernel_param *kp) \
L
Linus Torvalds 已提交
183 184
	{								\
		tmptype l;						\
185
		int ret;						\
L
Linus Torvalds 已提交
186
									\
187 188
		ret = strtolfn(val, 0, &l);				\
		if (ret == -EINVAL || ((type)l != l))			\
L
Linus Torvalds 已提交
189 190 191 192
			return -EINVAL;					\
		*((type *)kp->arg) = l;					\
		return 0;						\
	}								\
193
	int param_get_##name(char *buffer, const struct kernel_param *kp) \
L
Linus Torvalds 已提交
194 195
	{								\
		return sprintf(buffer, format, *((type *)kp->arg));	\
196
	}								\
197 198 199 200
	struct kernel_param_ops param_ops_##name = {			\
		.set = param_set_##name,				\
		.get = param_get_##name,				\
	};								\
201
	EXPORT_SYMBOL(param_set_##name);				\
202 203 204
	EXPORT_SYMBOL(param_get_##name);				\
	EXPORT_SYMBOL(param_ops_##name)

L
Linus Torvalds 已提交
205

206 207 208 209 210 211 212
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 已提交
213

214
int param_set_charp(const char *val, const struct kernel_param *kp)
L
Linus Torvalds 已提交
215 216 217 218 219 220 221
{
	if (strlen(val) > 1024) {
		printk(KERN_ERR "%s: string parameter too long\n",
		       kp->name);
		return -ENOSPC;
	}

222 223 224 225
	/* This is a hack.  We can't need to strdup in early boot, and we
	 * don't need to; this mangled commandline is preserved. */
	if (slab_is_available()) {
		*(char **)kp->arg = kstrdup(val, GFP_KERNEL);
R
Rusty Russell 已提交
226
		if (!*(char **)kp->arg)
227 228 229 230
			return -ENOMEM;
	} else
		*(const char **)kp->arg = val;

L
Linus Torvalds 已提交
231 232
	return 0;
}
233
EXPORT_SYMBOL(param_set_charp);
L
Linus Torvalds 已提交
234

235
int param_get_charp(char *buffer, const struct kernel_param *kp)
L
Linus Torvalds 已提交
236 237 238
{
	return sprintf(buffer, "%s", *((char **)kp->arg));
}
239
EXPORT_SYMBOL(param_get_charp);
L
Linus Torvalds 已提交
240

241 242 243 244 245 246
struct kernel_param_ops param_ops_charp = {
	.set = param_set_charp,
	.get = param_get_charp,
};
EXPORT_SYMBOL(param_ops_charp);

247
/* Actually could be a bool or an int, for historical reasons. */
248
int param_set_bool(const char *val, const struct kernel_param *kp)
L
Linus Torvalds 已提交
249
{
250 251
	bool v;

L
Linus Torvalds 已提交
252 253 254 255 256 257
	/* No equals means "set"... */
	if (!val) val = "1";

	/* One of =[yYnN01] */
	switch (val[0]) {
	case 'y': case 'Y': case '1':
258 259
		v = true;
		break;
L
Linus Torvalds 已提交
260
	case 'n': case 'N': case '0':
261 262 263 264
		v = false;
		break;
	default:
		return -EINVAL;
L
Linus Torvalds 已提交
265
	}
266 267 268 269 270 271

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

275
int param_get_bool(char *buffer, const struct kernel_param *kp)
L
Linus Torvalds 已提交
276
{
277 278 279 280 281 282
	bool val;
	if (kp->flags & KPARAM_ISBOOL)
		val = *(bool *)kp->arg;
	else
		val = *(int *)kp->arg;

L
Linus Torvalds 已提交
283
	/* Y and N chosen as being relatively non-coder friendly */
284
	return sprintf(buffer, "%c", val ? 'Y' : 'N');
L
Linus Torvalds 已提交
285
}
286
EXPORT_SYMBOL(param_get_bool);
L
Linus Torvalds 已提交
287

288 289 290 291 292 293
struct kernel_param_ops param_ops_bool = {
	.set = param_set_bool,
	.get = param_get_bool,
};
EXPORT_SYMBOL(param_ops_bool);

294
/* This one must be bool. */
295
int param_set_invbool(const char *val, const struct kernel_param *kp)
L
Linus Torvalds 已提交
296
{
297 298
	int ret;
	bool boolval;
299
	struct kernel_param dummy;
L
Linus Torvalds 已提交
300

301
	dummy.arg = &boolval;
302
	dummy.flags = KPARAM_ISBOOL;
L
Linus Torvalds 已提交
303 304
	ret = param_set_bool(val, &dummy);
	if (ret == 0)
305
		*(bool *)kp->arg = !boolval;
L
Linus Torvalds 已提交
306 307
	return ret;
}
308
EXPORT_SYMBOL(param_set_invbool);
L
Linus Torvalds 已提交
309

310
int param_get_invbool(char *buffer, const struct kernel_param *kp)
L
Linus Torvalds 已提交
311
{
312
	return sprintf(buffer, "%c", (*(bool *)kp->arg) ? 'N' : 'Y');
L
Linus Torvalds 已提交
313
}
314
EXPORT_SYMBOL(param_get_invbool);
L
Linus Torvalds 已提交
315

316 317 318 319 320 321
struct kernel_param_ops param_ops_invbool = {
	.set = param_set_invbool,
	.get = param_get_invbool,
};
EXPORT_SYMBOL(param_ops_invbool);

322
/* We break the rule and mangle the string. */
323 324 325 326
static int param_array(const char *name,
		       const char *val,
		       unsigned int min, unsigned int max,
		       void *elem, int elemsize,
327
		       int (*set)(const char *, const struct kernel_param *kp),
R
Rusty Russell 已提交
328
		       u16 flags,
329
		       unsigned int *num)
L
Linus Torvalds 已提交
330 331 332 333 334 335 336 337
{
	int ret;
	struct kernel_param kp;
	char save;

	/* Get the name right for errors. */
	kp.name = name;
	kp.arg = elem;
R
Rusty Russell 已提交
338
	kp.flags = flags;
L
Linus Torvalds 已提交
339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371

	*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';
		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;
}

372
static int param_array_set(const char *val, const struct kernel_param *kp)
L
Linus Torvalds 已提交
373
{
374
	const struct kparam_array *arr = kp->arr;
375
	unsigned int temp_num;
L
Linus Torvalds 已提交
376 377

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

382
static int param_array_get(char *buffer, const struct kernel_param *kp)
L
Linus Torvalds 已提交
383 384
{
	int i, off, ret;
385
	const struct kparam_array *arr = kp->arr;
L
Linus Torvalds 已提交
386 387 388 389 390 391 392
	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;
393
		ret = arr->ops->get(buffer + off, &p);
L
Linus Torvalds 已提交
394 395 396 397 398 399 400 401
		if (ret < 0)
			return ret;
		off += ret;
	}
	buffer[off] = '\0';
	return off;
}

402 403 404 405 406 407 408 409 410 411
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);
}

412 413 414
struct kernel_param_ops param_array_ops = {
	.set = param_array_set,
	.get = param_array_get,
415
	.free = param_array_free,
416 417 418 419
};
EXPORT_SYMBOL(param_array_ops);

int param_set_copystring(const char *val, const struct kernel_param *kp)
L
Linus Torvalds 已提交
420
{
421
	const struct kparam_string *kps = kp->str;
L
Linus Torvalds 已提交
422 423 424 425 426 427 428 429 430

	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;
}
431
EXPORT_SYMBOL(param_set_copystring);
L
Linus Torvalds 已提交
432

433
int param_get_string(char *buffer, const struct kernel_param *kp)
L
Linus Torvalds 已提交
434
{
435
	const struct kparam_string *kps = kp->str;
L
Linus Torvalds 已提交
436 437
	return strlcpy(buffer, kps->string, kps->maxlen);
}
438
EXPORT_SYMBOL(param_get_string);
L
Linus Torvalds 已提交
439

440 441 442 443 444 445
struct kernel_param_ops param_ops_string = {
	.set = param_set_copystring,
	.get = param_get_string,
};
EXPORT_SYMBOL(param_ops_string);

L
Linus Torvalds 已提交
446
/* sysfs output in /sys/modules/XYZ/parameters/ */
447 448
#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 已提交
449 450 451 452 453 454

extern struct kernel_param __start___param[], __stop___param[];

struct param_attribute
{
	struct module_attribute mattr;
455
	const struct kernel_param *param;
L
Linus Torvalds 已提交
456 457 458 459
};

struct module_param_attrs
{
460
	unsigned int num;
L
Linus Torvalds 已提交
461 462 463 464
	struct attribute_group grp;
	struct param_attribute attrs[0];
};

465
#ifdef CONFIG_SYSFS
466
#define to_param_attr(n) container_of(n, struct param_attribute, mattr)
L
Linus Torvalds 已提交
467 468 469 470 471 472 473

static ssize_t param_attr_show(struct module_attribute *mattr,
			       struct module *mod, char *buf)
{
	int count;
	struct param_attribute *attribute = to_param_attr(mattr);

474
	if (!attribute->param->ops->get)
L
Linus Torvalds 已提交
475 476
		return -EPERM;

477
	count = attribute->param->ops->get(buf, attribute->param);
L
Linus Torvalds 已提交
478 479 480 481 482 483 484 485 486 487 488 489 490 491 492
	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,
				struct module *owner,
				const char *buf, size_t len)
{
 	int err;
	struct param_attribute *attribute = to_param_attr(mattr);

493
	if (!attribute->param->ops->set)
L
Linus Torvalds 已提交
494 495
		return -EPERM;

496
	err = attribute->param->ops->set(buf, attribute->param);
L
Linus Torvalds 已提交
497 498 499 500
	if (!err)
		return len;
	return err;
}
501
#endif
L
Linus Torvalds 已提交
502 503 504 505 506 507 508

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

509
#ifdef CONFIG_SYSFS
L
Linus Torvalds 已提交
510
/*
511 512 513 514
 * 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 已提交
515
 *
516 517 518
 * 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 已提交
519
 */
520
static __modinit int add_sysfs_param(struct module_kobject *mk,
521
				     const struct kernel_param *kp,
522
				     const char *name)
L
Linus Torvalds 已提交
523
{
524 525 526 527 528 529 530 531 532 533 534 535 536
	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 已提交
537 538
	}

539 540 541 542 543 544 545 546 547 548 549 550 551 552
	/* 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 已提交
553

554 555 556 557 558 559 560 561
	/* 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. */
562
	sysfs_attr_init(&new->attrs[num].mattr.attr);
563 564 565 566 567 568 569 570 571 572 573 574 575 576
	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 已提交
577

578 579 580 581 582 583
fail_free_new:
	kfree(new);
fail:
	mk->mp = NULL;
	return err;
}
L
Linus Torvalds 已提交
584

585
#ifdef CONFIG_MODULES
586 587 588 589 590
static void free_module_param_attrs(struct module_kobject *mk)
{
	kfree(mk->mp->grp.attrs);
	kfree(mk->mp);
	mk->mp = NULL;
L
Linus Torvalds 已提交
591 592 593 594 595 596 597 598
}

/*
 * module_param_sysfs_setup - setup sysfs support for one module
 * @mod: module
 * @kparam: module parameters (array)
 * @num_params: number of module parameters
 *
599 600
 * Adds sysfs entries for module parameters under
 * /sys/module/[mod->name]/parameters/
L
Linus Torvalds 已提交
601 602
 */
int module_param_sysfs_setup(struct module *mod,
603
			     const struct kernel_param *kparam,
L
Linus Torvalds 已提交
604 605
			     unsigned int num_params)
{
606 607 608 609 610 611 612 613 614 615 616
	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 已提交
617

618 619
	if (!params)
		return 0;
L
Linus Torvalds 已提交
620

621 622 623 624 625
	/* 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 已提交
626 627 628 629 630 631 632 633 634 635 636
}

/*
 * 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)
{
637 638
	if (mod->mkobj.mp) {
		sysfs_remove_group(&mod->mkobj.kobj, &mod->mkobj.mp->grp);
L
Linus Torvalds 已提交
639 640
		/* We are positive that no one is using any param
		 * attrs at this point.  Deallocate immediately. */
641
		free_module_param_attrs(&mod->mkobj);
L
Linus Torvalds 已提交
642 643 644 645
	}
}
#endif

646 647
void destroy_params(const struct kernel_param *params, unsigned num)
{
648 649 650 651 652
	unsigned int i;

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

655 656 657
static void __init kernel_add_sysfs_param(const char *name,
					  struct kernel_param *kparam,
					  unsigned int name_skip)
L
Linus Torvalds 已提交
658 659
{
	struct module_kobject *mk;
660 661
	struct kobject *kobj;
	int err;
L
Linus Torvalds 已提交
662

663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685
	kobj = kset_find_obj(module_kset, name);
	if (kobj) {
		/* We already have one.  Remove params so we can add more. */
		mk = to_module_kobject(kobj);
		/* We need to remove it before adding parameters. */
		sysfs_remove_group(&mk->kobj, &mk->mp->grp);
	} 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);
		if (err) {
			kobject_put(&mk->kobj);
			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;
		}
		/* So that exit path is even. */
		kobject_get(&mk->kobj);
686
	}
687 688 689 690 691 692

	/* 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);
693
	kobject_uevent(&mk->kobj, KOBJ_ADD);
694
	kobject_put(&mk->kobj);
L
Linus Torvalds 已提交
695 696 697 698 699 700 701 702 703 704
}

/*
 * 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,
705
 * and for all who have the same, call kernel_add_sysfs_param.
L
Linus Torvalds 已提交
706 707 708
 */
static void __init param_sysfs_builtin(void)
{
709 710 711
	struct kernel_param *kp;
	unsigned int name_len;
	char modname[MODULE_NAME_LEN];
L
Linus Torvalds 已提交
712

713
	for (kp = __start___param; kp < __stop___param; kp++) {
L
Linus Torvalds 已提交
714 715
		char *dot;

716 717
		if (kp->perm == 0)
			continue;
L
Linus Torvalds 已提交
718

719
		dot = strchr(kp->name, '.');
L
Linus Torvalds 已提交
720
		if (!dot) {
721 722 723 724 725 726
			/* 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 已提交
727
		}
728
		kernel_add_sysfs_param(modname, kp, name_len);
L
Linus Torvalds 已提交
729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746
	}
}


/* 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)
747
		return -EIO;
L
Linus Torvalds 已提交
748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765

	ret = attribute->show(attribute, mk->mod, buf);

	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)
766
		return -EIO;
L
Linus Torvalds 已提交
767 768 769 770 771 772

	ret = attribute->store(attribute, mk->mod, buf, len);

	return ret;
}

773
static const struct sysfs_ops module_sysfs_ops = {
L
Linus Torvalds 已提交
774 775 776 777
	.show = module_attr_show,
	.store = module_attr_store,
};

K
Kay Sievers 已提交
778 779 780 781 782 783 784 785 786
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;
}

787
static const struct kset_uevent_ops module_uevent_ops = {
K
Kay Sievers 已提交
788 789 790
	.filter = uevent_filter,
};

791
struct kset *module_kset;
792
int module_sysfs_initialized;
L
Linus Torvalds 已提交
793

794
struct kobj_type module_ktype = {
L
Linus Torvalds 已提交
795 796 797 798 799 800 801 802
	.sysfs_ops =	&module_sysfs_ops,
};

/*
 * param_sysfs_init - wrapper for built-in params support
 */
static int __init param_sysfs_init(void)
{
803 804 805 806 807
	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;
808
	}
809
	module_sysfs_initialized = 1;
L
Linus Torvalds 已提交
810 811 812 813 814

	param_sysfs_builtin();

	return 0;
}
815
subsys_initcall(param_sysfs_init);
L
Linus Torvalds 已提交
816

817
#endif /* CONFIG_SYSFS */