/* 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>#include <linux/slab.h> #if 0#define DEBUGP printk#else#define DEBUGP(fmt, a...)#endif static inline char dash2underscore(char c){	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)) {			DEBUGP("They are equal!  Calling %p\n",			       params[i].set);			return params[i].set(val, &params[i]);		}	} 	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++) {		if (args[i] == ' ' && !in_quote)			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; 	/* Chew up trailing spaces. */	while (*next == ' ')		next++;	return next;} /* 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); 	/* Chew leading spaces */	while (*args == ' ')		args++; 	while (*args) {		int ret;		int irq_was_disabled; 		args = next_arg(args, &param, &val);		irq_was_disabled = irqs_disabled();		ret = parse_one(param, val, params, num, unknown);		if (irq_was_disabled && !irqs_disabled()) {			printk(KERN_WARNING "parse_args(): option '%s' enabled "					"irq's!\n", param);		}		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)      	\	int param_set_##name(const char *val, struct kernel_param *kp)	\	{								\		tmptype l;						\		int ret;						\									\		if (!val) return -EINVAL;				\		ret = strtolfn(val, 0, &l);				\		if (ret == -EINVAL || ((type)l != l))			\			return -EINVAL;					\		*((type *)kp->arg) = l;					\		return 0;						\	}								\	int param_get_##name(char *buffer, struct kernel_param *kp)	\	{								\		return sprintf(buffer, format, *((type *)kp->arg));	\	} 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); int param_set_charp(const char *val, struct kernel_param *kp){	if (!val) {		printk(KERN_ERR "%s: string parameter expected\n",		       kp->name);		return -EINVAL;	} 	if (strlen(val) > 1024) {		printk(KERN_ERR "%s: string parameter too long\n",		       kp->name);		return -ENOSPC;	} 	if (kp->flags & KPARAM_KMALLOCED)		kfree(*(char **)kp->arg); 	/* 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()) {		kp->flags |= KPARAM_KMALLOCED;		*(char **)kp->arg = kstrdup(val, GFP_KERNEL);		if (!kp->arg)			return -ENOMEM;	} else		*(const char **)kp->arg = val; 	return 0;} int param_get_charp(char *buffer, struct kernel_param *kp){	return sprintf(buffer, "%s", *((char **)kp->arg));} /* Actually could be a bool or an int, for historical reasons. */int param_set_bool(const char *val, struct kernel_param *kp){	bool v; 	/* No equals means "set"... */	if (!val) val = "1"; 	/* One of =[yYnN01] */	switch (val[0]) {	case 'y': case 'Y': case '1':		v = true;		break;	case 'n': case 'N': case '0':		v = false;		break;	default:		return -EINVAL;	} 	if (kp->flags & KPARAM_ISBOOL)		*(bool *)kp->arg = v;	else		*(int *)kp->arg = v;	return 0;} int param_get_bool(char *buffer, struct kernel_param *kp){	bool val;	if (kp->flags & KPARAM_ISBOOL)		val = *(bool *)kp->arg;	else		val = *(int *)kp->arg; 	/* Y and N chosen as being relatively non-coder friendly */	return sprintf(buffer, "%c", val ? 'Y' : 'N');} /* This one must be bool. */int param_set_invbool(const char *val, struct kernel_param *kp){	int ret;	bool boolval;	struct kernel_param dummy; 	dummy.arg = &boolval;	dummy.flags = KPARAM_ISBOOL;	ret = param_set_bool(val, &dummy);	if (ret == 0)		*(bool *)kp->arg = !boolval;	return ret;} int param_get_invbool(char *buffer, struct kernel_param *kp){	return sprintf(buffer, "%c", (*(bool *)kp->arg) ? 'N' : 'Y');} /* We break the rule and mangle the string. */static int param_array(const char *name,		       const char *val,		       unsigned int min, unsigned int max,		       void *elem, int elemsize,		       int (*set)(const char *, struct kernel_param *kp),		       unsigned int *num){	int ret;	struct kernel_param kp;	char save; 	/* Get the name right for errors. */	kp.name = name;	kp.arg = elem; 	/* No equals sign? */	if (!val) {		printk(KERN_ERR "%s: expects arguments\n", name);		return -EINVAL;	} 	*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;} int param_array_set(const char *val, struct kernel_param *kp){	const struct kparam_array *arr = kp->arr;	unsigned int temp_num; 	return param_array(kp->name, val, 1, arr->max, arr->elem,			   arr->elemsize, arr->set, arr->num ?: &temp_num);} int param_array_get(char *buffer, struct kernel_param *kp){	int i, off, ret;	const struct kparam_array *arr = kp->arr;	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;		ret = arr->get(buffer + off, &p);		if (ret < 0)			return ret;		off += ret;	}	buffer[off] = '\0';	return off;} int param_set_copystring(const char *val, struct kernel_param *kp){	const struct kparam_string *kps = kp->str; 	if (!val) {		printk(KERN_ERR "%s: missing param set value\n", kp->name);		return -EINVAL;	}	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;} int param_get_string(char *buffer, struct kernel_param *kp){	const struct kparam_string *kps = kp->str;	return strlcpy(buffer, kps->string, kps->maxlen);} /* sysfs output in /sys/modules/XYZ/parameters/ */#define to_module_attr(n) container_of(n, struct module_attribute, attr);#define to_module_kobject(n) container_of(n, struct module_kobject, kobj); extern struct kernel_param __start___param[], __stop___param[]; struct param_attribute{	struct module_attribute mattr;	struct kernel_param *param;}; struct module_param_attrs{	unsigned int num;	struct attribute_group grp;	struct param_attribute attrs[0];}; #ifdef CONFIG_SYSFS#define to_param_attr(n) container_of(n, struct param_attribute, mattr); 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); 	if (!attribute->param->get)		return -EPERM; 	count = attribute->param->get(buf, attribute->param);	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); 	if (!attribute->param->set)		return -EPERM; 	err = attribute->param->set(buf, attribute->param);	if (!err)		return len;	return err;}#endif #ifdef CONFIG_MODULES#define __modinit#else#define __modinit __init#endif #ifdef CONFIG_SYSFS/* * 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 * * 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. */static __modinit int add_sysfs_param(struct module_kobject *mk,				     struct kernel_param *kp,				     const char *name){	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;	} 	/* Enlarge. */	new = krealloc(mk->mp,

Lines 1–500 of 801. Load more