params.c 21.3 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 35 36
/* Protects all parameters, and incidentally kmalloced_param list. */
static DEFINE_MUTEX(param_lock);

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 64 65 66 67 68 69
/* 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;
		}
	}
}

70
static inline char dash2underscore(char c)
L
Linus Torvalds 已提交
71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87
{
	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,
88
		     const struct kernel_param *params,
L
Linus Torvalds 已提交
89 90 91 92
		     unsigned num_params,
		     int (*handle_unknown)(char *param, char *val))
{
	unsigned int i;
93
	int err;
L
Linus Torvalds 已提交
94 95 96 97

	/* Find parameter */
	for (i = 0; i < num_params; i++) {
		if (parameq(param, params[i].name)) {
L
Lucas De Marchi 已提交
98
			/* No one handled NULL, so do it here. */
99
			if (!val && params[i].ops->set != param_set_bool)
100
				return -EINVAL;
L
Linus Torvalds 已提交
101
			DEBUGP("They are equal!  Calling %p\n",
102
			       params[i].ops->set);
103 104 105 106
			mutex_lock(&param_lock);
			err = params[i].ops->set(val, &params[i]);
			mutex_unlock(&param_lock);
			return err;
L
Linus Torvalds 已提交
107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133
		}
	}

	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++) {
134
		if (isspace(args[i]) && !in_quote)
L
Linus Torvalds 已提交
135 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
			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;
166 167

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

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

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

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

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

		args = next_arg(args, &param, &val);
190
		irq_was_disabled = irqs_disabled();
L
Linus Torvalds 已提交
191
		ret = parse_one(param, val, params, num, unknown);
192 193 194 195
		if (irq_was_disabled && !irqs_disabled()) {
			printk(KERN_WARNING "parse_args(): option '%s' enabled "
					"irq's!\n", param);
		}
L
Linus Torvalds 已提交
196 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
		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)      	\
222
	int param_set_##name(const char *val, const struct kernel_param *kp) \
L
Linus Torvalds 已提交
223 224
	{								\
		tmptype l;						\
225
		int ret;						\
L
Linus Torvalds 已提交
226
									\
227
		ret = strtolfn(val, 0, &l);				\
228 229
		if (ret < 0 || ((type)l != l))				\
			return ret < 0 ? ret : -EINVAL;			\
L
Linus Torvalds 已提交
230 231 232
		*((type *)kp->arg) = l;					\
		return 0;						\
	}								\
233
	int param_get_##name(char *buffer, const struct kernel_param *kp) \
L
Linus Torvalds 已提交
234 235
	{								\
		return sprintf(buffer, format, *((type *)kp->arg));	\
236
	}								\
237 238 239 240
	struct kernel_param_ops param_ops_##name = {			\
		.set = param_set_##name,				\
		.get = param_get_##name,				\
	};								\
241
	EXPORT_SYMBOL(param_set_##name);				\
242 243 244
	EXPORT_SYMBOL(param_get_##name);				\
	EXPORT_SYMBOL(param_ops_##name)

L
Linus Torvalds 已提交
245

246 247 248 249 250 251 252
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 已提交
253

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	*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';
398
		BUG_ON(!mutex_is_locked(&param_lock));
L
Linus Torvalds 已提交
399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415
		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;
}

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

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

426
static int param_array_get(char *buffer, const struct kernel_param *kp)
L
Linus Torvalds 已提交
427 428
{
	int i, off, ret;
429
	const struct kparam_array *arr = kp->arr;
L
Linus Torvalds 已提交
430 431 432 433 434 435 436
	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;
437
		BUG_ON(!mutex_is_locked(&param_lock));
438
		ret = arr->ops->get(buffer + off, &p);
L
Linus Torvalds 已提交
439 440 441 442 443 444 445 446
		if (ret < 0)
			return ret;
		off += ret;
	}
	buffer[off] = '\0';
	return off;
}

447 448 449 450 451 452 453 454 455 456
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);
}

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

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

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

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

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

L
Linus Torvalds 已提交
491
/* sysfs output in /sys/modules/XYZ/parameters/ */
492 493
#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 已提交
494 495 496 497 498 499

extern struct kernel_param __start___param[], __stop___param[];

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

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

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

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

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

522
	mutex_lock(&param_lock);
523
	count = attribute->param->ops->get(buf, attribute->param);
524
	mutex_unlock(&param_lock);
L
Linus Torvalds 已提交
525 526 527 528 529 530 531 532 533
	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,
534
				struct module_kobject *km,
L
Linus Torvalds 已提交
535 536 537 538 539
				const char *buf, size_t len)
{
 	int err;
	struct param_attribute *attribute = to_param_attr(mattr);

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

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

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

558
#ifdef CONFIG_SYSFS
559 560 561 562 563 564 565 566 567 568 569 570
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 已提交
571
/*
572 573 574 575
 * 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 已提交
576
 *
577 578 579
 * 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 已提交
580
 */
581
static __modinit int add_sysfs_param(struct module_kobject *mk,
582
				     const struct kernel_param *kp,
583
				     const char *name)
L
Linus Torvalds 已提交
584
{
585 586 587 588 589 590 591 592 593 594 595 596 597
	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 已提交
598 599
	}

600 601 602 603 604 605 606 607 608 609 610 611 612 613
	/* 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 已提交
614

615 616 617 618 619 620 621 622
	/* 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. */
623
	sysfs_attr_init(&new->attrs[num].mattr.attr);
624 625 626 627 628 629 630 631 632 633 634 635 636 637
	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 已提交
638

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

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

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

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

682 683 684 685 686
	/* 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 已提交
687 688 689 690 691 692 693 694 695 696 697
}

/*
 * 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)
{
698 699
	if (mod->mkobj.mp) {
		sysfs_remove_group(&mod->mkobj.kobj, &mod->mkobj.mp->grp);
L
Linus Torvalds 已提交
700 701
		/* We are positive that no one is using any param
		 * attrs at this point.  Deallocate immediately. */
702
		free_module_param_attrs(&mod->mkobj);
L
Linus Torvalds 已提交
703 704 705 706
	}
}
#endif

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

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

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

722 723 724 725 726 727 728 729 730 731 732 733 734
	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);
		if (err) {
			kobject_put(&mk->kobj);
735 736 737 738 739 740
			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;
741
		}
742 743

		/* So that we hold reference in both cases. */
744
		kobject_get(&mk->kobj);
745
	}
746

747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764
	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);

765 766 767 768 769
	/* 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);
770
	kobject_uevent(&mk->kobj, KOBJ_ADD);
771
	kobject_put(&mk->kobj);
L
Linus Torvalds 已提交
772 773 774 775 776 777 778 779 780 781
}

/*
 * 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,
782
 * and for all who have the same, call kernel_add_sysfs_param.
L
Linus Torvalds 已提交
783 784 785
 */
static void __init param_sysfs_builtin(void)
{
786 787 788
	struct kernel_param *kp;
	unsigned int name_len;
	char modname[MODULE_NAME_LEN];
L
Linus Torvalds 已提交
789

790
	for (kp = __start___param; kp < __stop___param; kp++) {
L
Linus Torvalds 已提交
791 792
		char *dot;

793 794
		if (kp->perm == 0)
			continue;
L
Linus Torvalds 已提交
795

796
		dot = strchr(kp->name, '.');
L
Linus Torvalds 已提交
797
		if (!dot) {
798 799 800 801 802 803
			/* 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 已提交
804
		}
805
		kernel_add_sysfs_param(modname, kp, name_len);
L
Linus Torvalds 已提交
806 807 808
	}
}

809
ssize_t __modver_version_show(struct module_attribute *mattr,
810
			      struct module_kobject *mk, char *buf)
811 812 813 814 815 816 817
{
	struct module_version_attribute *vattr =
		container_of(mattr, struct module_version_attribute, mattr);

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

818 819
extern const struct module_version_attribute *__start___modver[];
extern const struct module_version_attribute *__stop___modver[];
820 821 822

static void __init version_sysfs_builtin(void)
{
823
	const struct module_version_attribute **p;
824 825 826
	struct module_kobject *mk;
	int err;

827 828 829
	for (p = __start___modver; p < __stop___modver; p++) {
		const struct module_version_attribute *vattr = *p;

830 831 832 833 834 835 836 837
		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 已提交
838 839 840 841 842 843 844 845 846 847 848 849 850 851 852

/* 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)
853
		return -EIO;
L
Linus Torvalds 已提交
854

855
	ret = attribute->show(attribute, mk, buf);
L
Linus Torvalds 已提交
856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871

	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)
872
		return -EIO;
L
Linus Torvalds 已提交
873

874
	ret = attribute->store(attribute, mk, buf, len);
L
Linus Torvalds 已提交
875 876 877 878

	return ret;
}

879
static const struct sysfs_ops module_sysfs_ops = {
L
Linus Torvalds 已提交
880 881 882 883
	.show = module_attr_show,
	.store = module_attr_store,
};

K
Kay Sievers 已提交
884 885 886 887 888 889 890 891 892
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;
}

893
static const struct kset_uevent_ops module_uevent_ops = {
K
Kay Sievers 已提交
894 895 896
	.filter = uevent_filter,
};

897
struct kset *module_kset;
898
int module_sysfs_initialized;
L
Linus Torvalds 已提交
899

900
struct kobj_type module_ktype = {
L
Linus Torvalds 已提交
901 902 903 904 905 906 907 908
	.sysfs_ops =	&module_sysfs_ops,
};

/*
 * param_sysfs_init - wrapper for built-in params support
 */
static int __init param_sysfs_init(void)
{
909 910 911 912 913
	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;
914
	}
915
	module_sysfs_initialized = 1;
L
Linus Torvalds 已提交
916

917
	version_sysfs_builtin();
L
Linus Torvalds 已提交
918 919 920 921
	param_sysfs_builtin();

	return 0;
}
922
subsys_initcall(param_sysfs_init);
L
Linus Torvalds 已提交
923

924
#endif /* CONFIG_SYSFS */