#define DEBUGP(fmt, a...)
#endif
+/* Protects all parameters, and incidentally kmalloced_param list. */
+static DEFINE_MUTEX(param_lock);
+
/* This just allows us to keep track of which parameters are kmalloced. */
struct kmalloced_param {
struct list_head list;
char val[];
};
-static DEFINE_MUTEX(param_lock);
static LIST_HEAD(kmalloced_params);
static void *kmalloc_parameter(unsigned int size)
if (!p)
return NULL;
- mutex_lock(¶m_lock);
list_add(&p->list, &kmalloced_params);
- mutex_unlock(¶m_lock);
-
return p->val;
}
{
struct kmalloced_param *p;
- mutex_lock(¶m_lock);
list_for_each_entry(p, &kmalloced_params, list) {
if (p->val == param) {
list_del(&p->list);
break;
}
}
- mutex_unlock(¶m_lock);
}
static inline char dash2underscore(char c)
static int parse_one(char *param,
char *val,
- struct kernel_param *params,
+ const struct kernel_param *params,
unsigned num_params,
- int (*handle_unknown)(char *param, char *val))
+ int (*handle_arg)(char *param, char *val, int known))
{
unsigned int i;
+ int err;
/* Find parameter */
for (i = 0; i < num_params; i++) {
/* Noone handled NULL, so do it here. */
if (!val && params[i].ops->set != param_set_bool)
return -EINVAL;
+ if (handle_arg) {
+ int ret;
+ DEBUGP("Valid argument: calling %p\n",
+ handle_arg);
+ ret = handle_arg(param, val, 1);
+ if (ret)
+ return ret;
+ }
DEBUGP("They are equal! Calling %p\n",
params[i].ops->set);
- return params[i].ops->set(val, ¶ms[i]);
+ mutex_lock(¶m_lock);
+ err = params[i].ops->set(val, ¶ms[i]);
+ mutex_unlock(¶m_lock);
+ return err;
}
}
- if (handle_unknown) {
- DEBUGP("Unknown argument: calling %p\n", handle_unknown);
- return handle_unknown(param, val);
+ if (handle_arg) {
+ DEBUGP("Unknown argument: calling %p\n", handle_arg);
+ return handle_arg(param, val, 0);
}
DEBUGP("Unknown argument `%s'\n", param);
/* Args looks like "foo=bar,bar2 baz=fuz wiz". */
int parse_args(const char *name,
char *args,
- struct kernel_param *params,
+ const struct kernel_param *params,
unsigned num,
- int (*unknown)(char *param, char *val))
+ int (*handle_arg)(char *param, char *val, int arg))
{
char *param, *val;
args = next_arg(args, ¶m, &val);
irq_was_disabled = irqs_disabled();
- ret = parse_one(param, val, params, num, unknown);
+ ret = parse_one(param, val, params, num, handle_arg);
if (irq_was_disabled && !irqs_disabled()) {
printk(KERN_WARNING "parse_args(): option '%s' enabled "
"irq's!\n", param);
/* nul-terminate and parse */
save = val[len];
((char *)val)[len] = '\0';
+ BUG_ON(!mutex_is_locked(¶m_lock));
ret = set(val, &kp);
if (ret != 0)
if (i)
buffer[off++] = ',';
p.arg = arr->elem + arr->elemsize * i;
+ BUG_ON(!mutex_is_locked(¶m_lock));
ret = arr->ops->get(buffer + off, &p);
if (ret < 0)
return ret;
if (!attribute->param->ops->get)
return -EPERM;
+ mutex_lock(¶m_lock);
count = attribute->param->ops->get(buf, attribute->param);
+ mutex_unlock(¶m_lock);
if (count > 0) {
strcat(buf, "\n");
++count;
if (!attribute->param->ops->set)
return -EPERM;
+ mutex_lock(¶m_lock);
err = attribute->param->ops->set(buf, attribute->param);
+ mutex_unlock(¶m_lock);
if (!err)
return len;
return err;
#endif
#ifdef CONFIG_SYSFS
+void __kernel_param_lock(void)
+{
+ mutex_lock(¶m_lock);
+}
+EXPORT_SYMBOL(__kernel_param_lock);
+
+void __kernel_param_unlock(void)
+{
+ mutex_unlock(¶m_lock);
+}
+EXPORT_SYMBOL(__kernel_param_unlock);
+
/*
* add_sysfs_param - add a parameter to sysfs
* @mk: struct module_kobject
params[i].ops->free(params[i].arg);
}
-static void __init kernel_add_sysfs_param(const char *name,
- struct kernel_param *kparam,
- unsigned int name_skip)
+static struct module_kobject * __init locate_module_kobject(const char *name)
{
struct module_kobject *mk;
struct kobject *kobj;
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);
"%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;
+ 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;
}
- /* So that exit path is even. */
+
+ /* So that we hold reference in both cases. */
kobject_get(&mk->kobj);
}
+ 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);
+
/* These should not fail at boot. */
err = add_sysfs_param(mk, kparam, kparam->name + name_skip);
BUG_ON(err);
}
}
+ssize_t __modver_version_show(struct module_attribute *mattr,
+ struct module *mod, char *buf)
+{
+ struct module_version_attribute *vattr =
+ container_of(mattr, struct module_version_attribute, mattr);
+
+ return sprintf(buf, "%s\n", vattr->version);
+}
+
+extern struct module_version_attribute __start___modver[], __stop___modver[];
+
+static void __init version_sysfs_builtin(void)
+{
+ const struct module_version_attribute *vattr;
+ struct module_kobject *mk;
+ int err;
+
+ for (vattr = __start___modver; vattr < __stop___modver; vattr++) {
+ 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);
+ }
+ }
+}
/* module-related sysfs stuff */
}
module_sysfs_initialized = 1;
+ version_sysfs_builtin();
param_sysfs_builtin();
return 0;