Commit 9b473de8 authored by Rusty Russell's avatar Rusty Russell
Browse files

param: Fix duplicate module prefixes 



Instead of insisting each new module_param sysfs entry is unique,
handle the case where it already exists (for builtin modules).

The current code assumes that all identical prefixes are together in
the section: true for normal uses, but not necessarily so if someone
overrides MODULE_PARAM_PREFIX.  More importantly, it's not true with
the new "core_param()" code which uses "kernel" as a prefix.

This simplifies the caller for the builtin case, at a slight loss of
efficiency (we do the lookup every time to see if the directory
exists).

Signed-off-by: default avatarRusty Russell <rusty@rustcorp.com.au>
Cc: Greg Kroah-Hartman <gregkh@suse.de>
parent 730b69d2

include/linux/module.h

+1 −1
Original line number Diff line number Diff line
@@ -60,6 +60,7 @@ struct module_kobject 
	struct kobject kobj;

	struct module *mod;

	struct kobject *drivers_dir;

	struct module_param_attrs *mp;

};



/* These are either module local, or the kernel's dummy ones. */
@@ -242,7 +243,6 @@ struct module 


	/* Sysfs stuff. */

	struct module_kobject mkobj;

	struct module_param_attrs *param_attrs;

	struct module_attribute *modinfo_attrs;

	const char *version;

	const char *srcversion;

kernel/params.c

+141 −120
Original line number Diff line number Diff line
@@ -373,6 +373,8 @@ int param_get_string(char *buffer, struct kernel_param *kp) 
}



/* 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[];
@@ -384,6 +386,7 @@ struct param_attribute 


struct module_param_attrs

{

	unsigned int num;

	struct attribute_group grp;

	struct param_attribute attrs[0];

};
@@ -434,69 +437,84 @@ static ssize_t param_attr_store(struct module_attribute *mattr, 


#ifdef CONFIG_SYSFS

/*

 * param_sysfs_setup - setup sysfs support for one module or KBUILD_MODNAME

 * @mk: struct module_kobject (contains parent kobject)

 * @kparam: array of struct kernel_param, the actual parameter definitions

 * @num_params: number of entries in array

 * @name_skip: offset where the parameter name start in kparam[].name. Needed for built-in "modules"

 * 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 for a (per-module) group of parameters, and create files

 * in sysfs. A pointer to the param_kobject is returned on success,

 * NULL if there's no parameter to export, or other ERR_PTR(err).

 * 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 struct module_param_attrs *

param_sysfs_setup(struct module_kobject *mk,

		  struct kernel_param *kparam,

		  unsigned int num_params,

		  unsigned int name_skip)

static __modinit int add_sysfs_param(struct module_kobject *mk,

				     struct kernel_param *kp,

				     const char *name)

{

	struct module_param_attrs *mp;

	unsigned int valid_attrs = 0;

	unsigned int i, size[2];

	struct param_attribute *pattr;

	struct attribute **gattr;

	int err;



	for (i=0; i<num_params; i++) {

		if (kparam[i].perm)

			valid_attrs++;

	}



	if (!valid_attrs)

		return NULL;



	size[0] = ALIGN(sizeof(*mp) +

			valid_attrs * sizeof(mp->attrs[0]),

			sizeof(mp->grp.attrs[0]));

	size[1] = (valid_attrs + 1) * sizeof(mp->grp.attrs[0]);



	mp = kzalloc(size[0] + size[1], GFP_KERNEL);

	if (!mp)

		return ERR_PTR(-ENOMEM);



	mp->grp.name = "parameters";

	mp->grp.attrs = (void *)mp + size[0];

	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,

		       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;

	}



	/* 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. */

	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;



	pattr = &mp->attrs[0];

	gattr = &mp->grp.attrs[0];

	for (i = 0; i < num_params; i++) {

		struct kernel_param *kp = &kparam[i];

		if (kp->perm) {

			pattr->param = kp;

			pattr->mattr.show = param_attr_show;

			pattr->mattr.store = param_attr_store;

			pattr->mattr.attr.name = (char *)&kp->name[name_skip];

			pattr->mattr.attr.mode = kp->perm;

			*(gattr++) = &(pattr++)->mattr.attr;

		}

fail_free_new:

	kfree(new);

fail:

	mk->mp = NULL;

	return err;

}

	*gattr = NULL;



	if ((err = sysfs_create_group(&mk->kobj, &mp->grp))) {

		kfree(mp);

		return ERR_PTR(err);

	}

	return mp;

static void free_module_param_attrs(struct module_kobject *mk)

{

	kfree(mk->mp->grp.attrs);

	kfree(mk->mp);

	mk->mp = NULL;

}



#ifdef CONFIG_MODULES
@@ -506,21 +524,33 @@ param_sysfs_setup(struct module_kobject *mk, 
 * @kparam: module parameters (array)

 * @num_params: number of module parameters

 *

 * Adds sysfs entries for module parameters, and creates a link from

 * /sys/module/[mod->name]/parameters to /sys/parameters/[mod->name]/

 * Adds sysfs entries for module parameters under

 * /sys/module/[mod->name]/parameters/

 */

int module_param_sysfs_setup(struct module *mod,

			     struct kernel_param *kparam,

			     unsigned int num_params)

{

	struct module_param_attrs *mp;

	int i, err;

	bool params = false;



	mp = param_sysfs_setup(&mod->mkobj, kparam, num_params, 0);

	if (IS_ERR(mp))

		return PTR_ERR(mp);

	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;

	}



	mod->param_attrs = mp;

	if (!params)

		return 0;



	/* 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;

}



/*
@@ -532,43 +562,55 @@ int module_param_sysfs_setup(struct module *mod, 
 */

void module_param_sysfs_remove(struct module *mod)

{

	if (mod->param_attrs) {

		sysfs_remove_group(&mod->mkobj.kobj,

				   &mod->param_attrs->grp);

	if (mod->mkobj.mp) {

		sysfs_remove_group(&mod->mkobj.kobj, &mod->mkobj.mp->grp);

		/* We are positive that no one is using any param

		 * attrs at this point.  Deallocate immediately. */

		kfree(mod->param_attrs);

		mod->param_attrs = NULL;

		free_module_param_attrs(&mod->mkobj);

	}

}

#endif



/*

 * kernel_param_sysfs_setup - wrapper for built-in params support

 */

static void __init kernel_param_sysfs_setup(const char *name,

static void __init kernel_add_sysfs_param(const char *name,

					  struct kernel_param *kparam,

					    unsigned int num_params,

					  unsigned int name_skip)

{

	struct module_kobject *mk;

	int ret;

	struct kobject *kobj;

	int err;



	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;

	ret = kobject_init_and_add(&mk->kobj, &module_ktype, NULL, "%s", name);

	if (ret) {

		err = kobject_init_and_add(&mk->kobj, &module_ktype, NULL,

					   "%s", name);

		if (err) {

			kobject_put(&mk->kobj);

		printk(KERN_ERR "Module '%s' failed to be added to sysfs, "

		      "error number %d\n", name, ret);

			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;

		}

	param_sysfs_setup(mk, kparam, num_params, name_skip);

		/* So that exit path is even. */

		kobject_get(&mk->kobj);

	}



	/* 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);

	kobject_uevent(&mk->kobj, KOBJ_ADD);

	kobject_put(&mk->kobj);

}



/*
@@ -579,18 +621,19 @@ static void __init kernel_param_sysfs_setup(const char *name, 
 * 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,

 * and for all who have the same, call kernel_param_sysfs_setup.

 * and for all who have the same, call kernel_add_sysfs_param.

 */

static void __init param_sysfs_builtin(void)

{

	struct kernel_param *kp, *kp_begin = NULL;

	unsigned int i, name_len, count = 0;

	char modname[MODULE_NAME_LEN] = "";

	struct kernel_param *kp;

	unsigned int name_len;

	char modname[MODULE_NAME_LEN];



	for (i=0; i < __stop___param - __start___param; i++) {

	for (kp = __start___param; kp < __stop___param; kp++) {

		char *dot;



		kp = &__start___param[i];

		if (kp->perm == 0)

			continue;



		dot = strchr(kp->name, '.');

		if (!dot) {
@@ -599,37 +642,15 @@ static void __init param_sysfs_builtin(void) 
			continue;

		}

		name_len = dot - kp->name;



 		/* new kbuild_modname? */

		if (strlen(modname) != name_len

		    || strncmp(modname, kp->name, name_len) != 0) {

			/* add a new kobject for previous kernel_params. */

			if (count)

				kernel_param_sysfs_setup(modname,

							 kp_begin,

							 count,

							 strlen(modname)+1);



		strncpy(modname, kp->name, name_len);

		modname[name_len] = '\0';

			count = 0;

			kp_begin = kp;

		kernel_add_sysfs_param(modname, kp, name_len+1);

	}

		count++;

	}



	/* last kernel_params need to be registered as well */

	if (count)

		kernel_param_sysfs_setup(modname, kp_begin, count,

					 strlen(modname)+1);

}





/* module-related sysfs stuff */



#define to_module_attr(n) container_of(n, struct module_attribute, attr);

#define to_module_kobject(n) container_of(n, struct module_kobject, kobj);



static ssize_t module_attr_show(struct kobject *kobj,

				struct attribute *attr,

				char *buf)

CRA Git | Maintained and supported by SUSTech CRA and CCSE