mm/futex: fix futex writes on archs with SW tracking of dirty & young
[linux-2.6.git] / kernel / params.c
index e265b13..22df3e0 100644 (file)
@@ -23,6 +23,7 @@
 #include <linux/device.h>
 #include <linux/err.h>
 #include <linux/slab.h>
+#include <linux/ctype.h>
 
 #if 0
 #define DEBUGP printk
 #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 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;
+               }
+       }
+}
+
 static inline char dash2underscore(char c)
 {
        if (c == '-')
@@ -48,18 +85,25 @@ static inline int parameq(const char *input, const char *paramname)
 
 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))
 {
        unsigned int i;
+       int err;
 
        /* Find parameter */
        for (i = 0; i < num_params; i++) {
                if (parameq(param, params[i].name)) {
+                       /* No one handled NULL, so do it here. */
+                       if (!val && params[i].ops->set != param_set_bool)
+                               return -EINVAL;
                        DEBUGP("They are equal!  Calling %p\n",
-                              params[i].set);
-                       return params[i].set(val, &params[i]);
+                              params[i].ops->set);
+                       mutex_lock(&param_lock);
+                       err = params[i].ops->set(val, &params[i]);
+                       mutex_unlock(&param_lock);
+                       return err;
                }
        }
 
@@ -87,7 +131,7 @@ static char *next_arg(char *args, char **param, char **val)
        }
 
        for (i = 0; args[i]; i++) {
-               if (args[i] == ' ' && !in_quote)
+               if (isspace(args[i]) && !in_quote)
                        break;
                if (equals == 0) {
                        if (args[i] == '=')
@@ -121,15 +165,13 @@ static char *next_arg(char *args, char **param, char **val)
                next = args + i;
 
        /* Chew up trailing spaces. */
-       while (*next == ' ')
-               next++;
-       return next;
+       return skip_spaces(next);
 }
 
 /* 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))
 {
@@ -138,8 +180,7 @@ int parse_args(const char *name,
        DEBUGP("Parsing ARGS: %s\n", args);
 
        /* Chew leading spaces */
-       while (*args == ' ')
-               args++;
+       args = skip_spaces(args);
 
        while (*args) {
                int ret;
@@ -178,104 +219,157 @@ int parse_args(const char *name,
 
 /* Lazy bastard, eh? */
 #define STANDARD_PARAM_DEF(name, type, format, tmptype, strtolfn)              \
-       int param_set_##name(const char *val, struct kernel_param *kp)  \
+       int param_set_##name(const char *val, const struct kernel_param *kp) \
        {                                                               \
-               char *endp;                                             \
                tmptype l;                                              \
+               int ret;                                                \
                                                                        \
-               if (!val) return -EINVAL;                               \
-               l = strtolfn(val, &endp, 0);                            \
-               if (endp == val || ((type)l != l))                      \
-                       return -EINVAL;                                 \
+               ret = strtolfn(val, 0, &l);                             \
+               if (ret < 0 || ((type)l != l))                          \
+                       return ret < 0 ? ret : -EINVAL;                 \
                *((type *)kp->arg) = l;                                 \
                return 0;                                               \
        }                                                               \
-       int param_get_##name(char *buffer, struct kernel_param *kp)     \
+       int param_get_##name(char *buffer, const struct kernel_param *kp) \
        {                                                               \
                return sprintf(buffer, format, *((type *)kp->arg));     \
-       }
-
-STANDARD_PARAM_DEF(byte, unsigned char, "%c", unsigned long, simple_strtoul);
-STANDARD_PARAM_DEF(short, short, "%hi", long, simple_strtol);
-STANDARD_PARAM_DEF(ushort, unsigned short, "%hu", unsigned long, simple_strtoul);
-STANDARD_PARAM_DEF(int, int, "%i", long, simple_strtol);
-STANDARD_PARAM_DEF(uint, unsigned int, "%u", unsigned long, simple_strtoul);
-STANDARD_PARAM_DEF(long, long, "%li", long, simple_strtol);
-STANDARD_PARAM_DEF(ulong, unsigned long, "%lu", unsigned long, simple_strtoul);
-
-int param_set_charp(const char *val, struct kernel_param *kp)
+       }                                                               \
+       struct kernel_param_ops param_ops_##name = {                    \
+               .set = param_set_##name,                                \
+               .get = param_get_##name,                                \
+       };                                                              \
+       EXPORT_SYMBOL(param_set_##name);                                \
+       EXPORT_SYMBOL(param_get_##name);                                \
+       EXPORT_SYMBOL(param_ops_##name)
+
+
+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, const 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;
        }
 
-       *(char **)kp->arg = (char *)val;
+       maybe_kfree_parameter(*(char **)kp->arg);
+
+       /* This is a hack.  We can't kmalloc in early boot, and we
+        * don't need to; this mangled commandline is preserved. */
+       if (slab_is_available()) {
+               *(char **)kp->arg = kmalloc_parameter(strlen(val)+1);
+               if (!*(char **)kp->arg)
+                       return -ENOMEM;
+               strcpy(*(char **)kp->arg, val);
+       } else
+               *(const char **)kp->arg = val;
+
        return 0;
 }
+EXPORT_SYMBOL(param_set_charp);
 
-int param_get_charp(char *buffer, struct kernel_param *kp)
+int param_get_charp(char *buffer, const struct kernel_param *kp)
 {
        return sprintf(buffer, "%s", *((char **)kp->arg));
 }
+EXPORT_SYMBOL(param_get_charp);
+
+static void param_free_charp(void *arg)
+{
+       maybe_kfree_parameter(*((char **)arg));
+}
+
+struct kernel_param_ops param_ops_charp = {
+       .set = param_set_charp,
+       .get = param_get_charp,
+       .free = param_free_charp,
+};
+EXPORT_SYMBOL(param_ops_charp);
 
-int param_set_bool(const char *val, struct kernel_param *kp)
+/* Actually could be a bool or an int, for historical reasons. */
+int param_set_bool(const char *val, const struct kernel_param *kp)
 {
+       bool v;
+       int ret;
+
        /* No equals means "set"... */
        if (!val) val = "1";
 
        /* One of =[yYnN01] */
-       switch (val[0]) {
-       case 'y': case 'Y': case '1':
-               *(int *)kp->arg = 1;
-               return 0;
-       case 'n': case 'N': case '0':
-               *(int *)kp->arg = 0;
-               return 0;
-       }
-       return -EINVAL;
+       ret = strtobool(val, &v);
+       if (ret)
+               return ret;
+
+       if (kp->flags & KPARAM_ISBOOL)
+               *(bool *)kp->arg = v;
+       else
+               *(int *)kp->arg = v;
+       return 0;
 }
+EXPORT_SYMBOL(param_set_bool);
 
-int param_get_bool(char *buffer, struct kernel_param *kp)
+int param_get_bool(char *buffer, const 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", (*(int *)kp->arg) ? 'Y' : 'N');
+       return sprintf(buffer, "%c", val ? 'Y' : 'N');
 }
+EXPORT_SYMBOL(param_get_bool);
 
-int param_set_invbool(const char *val, struct kernel_param *kp)
+struct kernel_param_ops param_ops_bool = {
+       .set = param_set_bool,
+       .get = param_get_bool,
+};
+EXPORT_SYMBOL(param_ops_bool);
+
+/* This one must be bool. */
+int param_set_invbool(const char *val, const struct kernel_param *kp)
 {
-       int boolval, ret;
-       struct kernel_param dummy = { .arg = &boolval };
+       int ret;
+       bool boolval;
+       struct kernel_param dummy;
 
+       dummy.arg = &boolval;
+       dummy.flags = KPARAM_ISBOOL;
        ret = param_set_bool(val, &dummy);
        if (ret == 0)
-               *(int *)kp->arg = !boolval;
+               *(bool *)kp->arg = !boolval;
        return ret;
 }
+EXPORT_SYMBOL(param_set_invbool);
 
-int param_get_invbool(char *buffer, struct kernel_param *kp)
+int param_get_invbool(char *buffer, const struct kernel_param *kp)
 {
-       int val;
-       struct kernel_param dummy = { .arg = &val };
-
-       val = !*(int *)kp->arg;
-       return param_get_bool(buffer, &dummy);
+       return sprintf(buffer, "%c", (*(bool *)kp->arg) ? 'N' : 'Y');
 }
+EXPORT_SYMBOL(param_get_invbool);
+
+struct kernel_param_ops param_ops_invbool = {
+       .set = param_set_invbool,
+       .get = param_get_invbool,
+};
+EXPORT_SYMBOL(param_ops_invbool);
 
-/* We cheat here and temporarily mangle the string. */
+/* 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),
-                      int *num)
+                      int (*set)(const char *, const struct kernel_param *kp),
+                      u16 flags,
+                      unsigned int *num)
 {
        int ret;
        struct kernel_param kp;
@@ -284,12 +378,7 @@ static int param_array(const char *name,
        /* 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;
-       }
+       kp.flags = flags;
 
        *num = 0;
        /* We expect a comma-separated list of values. */
@@ -306,6 +395,7 @@ static int param_array(const char *name,
                /* nul-terminate and parse */
                save = val[len];
                ((char *)val)[len] = '\0';
+               BUG_ON(!mutex_is_locked(&param_lock));
                ret = set(val, &kp);
 
                if (ret != 0)
@@ -323,19 +413,20 @@ static int param_array(const char *name,
        return 0;
 }
 
-int param_array_set(const char *val, struct kernel_param *kp)
+static int param_array_set(const char *val, const struct kernel_param *kp)
 {
-       struct kparam_array *arr = kp->arg;
+       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);
+                          arr->elemsize, arr->ops->set, kp->flags,
+                          arr->num ?: &temp_num);
 }
 
-int param_array_get(char *buffer, struct kernel_param *kp)
+static int param_array_get(char *buffer, const struct kernel_param *kp)
 {
        int i, off, ret;
-       struct kparam_array *arr = kp->arg;
+       const struct kparam_array *arr = kp->arr;
        struct kernel_param p;
 
        p = *kp;
@@ -343,7 +434,8 @@ int param_array_get(char *buffer, struct kernel_param *kp)
                if (i)
                        buffer[off++] = ',';
                p.arg = arr->elem + arr->elemsize * i;
-               ret = arr->get(buffer + off, &p);
+               BUG_ON(!mutex_is_locked(&param_lock));
+               ret = arr->ops->get(buffer + off, &p);
                if (ret < 0)
                        return ret;
                off += ret;
@@ -352,9 +444,26 @@ int param_array_get(char *buffer, struct kernel_param *kp)
        return off;
 }
 
-int param_set_copystring(const char *val, struct kernel_param *kp)
+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);
+}
+
+struct kernel_param_ops param_array_ops = {
+       .set = param_array_set,
+       .get = param_array_get,
+       .free = param_array_free,
+};
+EXPORT_SYMBOL(param_array_ops);
+
+int param_set_copystring(const char *val, const struct kernel_param *kp)
 {
-       struct kparam_string *kps = kp->arg;
+       const struct kparam_string *kps = kp->str;
 
        if (strlen(val)+1 > kps->maxlen) {
                printk(KERN_ERR "%s: string doesn't fit in %u chars.\n",
@@ -364,44 +473,55 @@ int param_set_copystring(const char *val, struct kernel_param *kp)
        strcpy(kps->string, val);
        return 0;
 }
+EXPORT_SYMBOL(param_set_copystring);
 
-int param_get_string(char *buffer, struct kernel_param *kp)
+int param_get_string(char *buffer, const struct kernel_param *kp)
 {
-       struct kparam_string *kps = kp->arg;
+       const struct kparam_string *kps = kp->str;
        return strlcpy(buffer, kps->string, kps->maxlen);
 }
+EXPORT_SYMBOL(param_get_string);
+
+struct kernel_param_ops param_ops_string = {
+       .set = param_set_copystring,
+       .get = param_get_string,
+};
+EXPORT_SYMBOL(param_ops_string);
 
 /* 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[];
 
-#define MAX_KBUILD_MODNAME KOBJ_NAME_LEN
-
 struct param_attribute
 {
        struct module_attribute mattr;
-       struct kernel_param *param;
+       const 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);
+#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)
+                              struct module_kobject *mk, char *buf)
 {
        int count;
        struct param_attribute *attribute = to_param_attr(mattr);
 
-       if (!attribute->param->get)
+       if (!attribute->param->ops->get)
                return -EPERM;
 
-       count = attribute->param->get(buf, attribute->param);
+       mutex_lock(&param_lock);
+       count = attribute->param->ops->get(buf, attribute->param);
+       mutex_unlock(&param_lock);
        if (count > 0) {
                strcat(buf, "\n");
                ++count;
@@ -411,16 +531,18 @@ static ssize_t param_attr_show(struct module_attribute *mattr,
 
 /* 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,
+                               struct module_kobject *km,
                                const char *buf, size_t len)
 {
        int err;
        struct param_attribute *attribute = to_param_attr(mattr);
 
-       if (!attribute->param->set)
+       if (!attribute->param->ops->set)
                return -EPERM;
 
-       err = attribute->param->set(buf, attribute->param);
+       mutex_lock(&param_lock);
+       err = attribute->param->ops->set(buf, attribute->param);
+       mutex_unlock(&param_lock);
        if (!err)
                return len;
        return err;
@@ -434,95 +556,134 @@ static ssize_t param_attr_store(struct module_attribute *mattr,
 #endif
 
 #ifdef CONFIG_SYSFS
+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);
+
 /*
- * 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)
-{
-       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++;
+static __modinit int add_sysfs_param(struct module_kobject *mk,
+                                    const 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;
        }
 
-       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 = kmalloc(size[0] + size[1], GFP_KERNEL);
-       if (!mp)
-               return ERR_PTR(-ENOMEM);
-
-       mp->grp.name = "parameters";
-       mp->grp.attrs = (void *)mp + size[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.owner = mk->mod;
-                       pattr->mattr.attr.mode = kp->perm;
-                       *(gattr++) = &(pattr++)->mattr.attr;
-               }
+       /* 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;
        }
-       *gattr = NULL;
-
-       if ((err = sysfs_create_group(&mk->kobj, &mp->grp))) {
-               kfree(mp);
-               return ERR_PTR(err);
+       attrs = krealloc(attrs, sizeof(new->grp.attrs[0])*(num+2), GFP_KERNEL);
+       if (!attrs) {
+               err = -ENOMEM;
+               goto fail_free_new;
        }
-       return mp;
+
+       /* 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. */
+       sysfs_attr_init(&new->attrs[num].mattr.attr);
+       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;
+
+fail_free_new:
+       kfree(new);
+fail:
+       mk->mp = NULL;
+       return err;
 }
 
 #ifdef CONFIG_MODULES
+static void free_module_param_attrs(struct module_kobject *mk)
+{
+       kfree(mk->mp->grp.attrs);
+       kfree(mk->mp);
+       mk->mp = NULL;
+}
+
 /*
  * module_param_sysfs_setup - setup sysfs support for one module
  * @mod: module
  * @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,
+                            const struct kernel_param *kparam,
                             unsigned int num_params)
 {
-       struct module_param_attrs *mp;
+       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;
+       }
 
-       mp = param_sysfs_setup(&mod->mkobj, kparam, num_params, 0);
-       if (IS_ERR(mp))
-               return PTR_ERR(mp);
+       if (!params)
+               return 0;
 
-       mod->param_attrs = mp;
-       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;
 }
 
 /*
@@ -534,39 +695,84 @@ 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,
-                                           struct kernel_param *kparam,
-                                           unsigned int num_params,
-                                           unsigned int name_skip)
+void destroy_params(const struct kernel_param *params, unsigned num)
+{
+       unsigned int i;
+
+       for (i = 0; i < num; i++)
+               if (params[i].ops->free)
+                       params[i].ops->free(params[i].arg);
+}
+
+static struct module_kobject * __init locate_module_kobject(const char *name)
 {
        struct module_kobject *mk;
-       int ret;
+       struct kobject *kobj;
+       int err;
 
-       mk = kzalloc(sizeof(struct module_kobject), GFP_KERNEL);
-       BUG_ON(!mk);
+       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);
+#ifdef CONFIG_MODULES
+               if (!err)
+                       err = sysfs_create_file(&mk->kobj, &module_uevent.attr);
+#endif
+               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 NULL;
+               }
 
-       mk->mod = THIS_MODULE;
-       kobj_set_kset_s(mk, module_subsys);
-       kobject_set_name(&mk->kobj, name);
-       kobject_init(&mk->kobj);
-       ret = kobject_add(&mk->kobj);
-       BUG_ON(ret < 0);
-       param_sysfs_setup(mk, kparam, num_params, name_skip);
+               /* 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);
+       err = sysfs_create_group(&mk->kobj, &mk->mp->grp);
+       BUG_ON(err);
        kobject_uevent(&mk->kobj, KOBJ_ADD);
+       kobject_put(&mk->kobj);
 }
 
 /*
@@ -577,56 +783,64 @@ 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[MAX_KBUILD_MODNAME + 1] = "";
+       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;
 
-               /* We do not handle args without periods. */
-               dot = memchr(kp->name, '.', MAX_KBUILD_MODNAME);
+               dot = strchr(kp->name, '.');
                if (!dot) {
-                       DEBUGP("couldn't find period in %s\n", kp->name);
-                       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;
+                       /* This happens for core_param() */
+                       strcpy(modname, "kernel");
+                       name_len = 0;
+               } else {
+                       name_len = dot - kp->name + 1;
+                       strlcpy(modname, kp->name, name_len);
                }
-               count++;
+               kernel_add_sysfs_param(modname, kp, name_len);
        }
+}
+
+ssize_t __modver_version_show(struct module_attribute *mattr,
+                             struct module_kobject *mk, char *buf)
+{
+       struct module_version_attribute *vattr =
+               container_of(mattr, struct module_version_attribute, mattr);
 
-       /* last kernel_params need to be registered as well */
-       if (count)
-               kernel_param_sysfs_setup(modname, kp_begin, count,
-                                        strlen(modname)+1);
+       return sprintf(buf, "%s\n", vattr->version);
 }
 
+extern const struct module_version_attribute *__start___modver[];
+extern const struct module_version_attribute *__stop___modver[];
 
-/* module-related sysfs stuff */
+static void __init version_sysfs_builtin(void)
+{
+       const struct module_version_attribute **p;
+       struct module_kobject *mk;
+       int err;
 
-#define to_module_attr(n) container_of(n, struct module_attribute, attr);
-#define to_module_kobject(n) container_of(n, struct module_kobject, kobj);
+       for (p = __start___modver; p < __stop___modver; p++) {
+               const struct module_version_attribute *vattr = *p;
+
+               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 */
 
 static ssize_t module_attr_show(struct kobject *kobj,
                                struct attribute *attr,
@@ -642,7 +856,7 @@ static ssize_t module_attr_show(struct kobject *kobj,
        if (!attribute->show)
                return -EIO;
 
-       ret = attribute->show(attribute, mk->mod, buf);
+       ret = attribute->show(attribute, mk, buf);
 
        return ret;
 }
@@ -661,18 +875,16 @@ static ssize_t module_attr_store(struct kobject *kobj,
        if (!attribute->store)
                return -EIO;
 
-       ret = attribute->store(attribute, mk->mod, buf, len);
+       ret = attribute->store(attribute, mk, buf, len);
 
        return ret;
 }
 
-static struct sysfs_ops module_sysfs_ops = {
+static const struct sysfs_ops module_sysfs_ops = {
        .show = module_attr_show,
        .store = module_attr_store,
 };
 
-static struct kobj_type module_ktype;
-
 static int uevent_filter(struct kset *kset, struct kobject *kobj)
 {
        struct kobj_type *ktype = get_ktype(kobj);
@@ -682,13 +894,14 @@ static int uevent_filter(struct kset *kset, struct kobject *kobj)
        return 0;
 }
 
-static struct kset_uevent_ops module_uevent_ops = {
+static const struct kset_uevent_ops module_uevent_ops = {
        .filter = uevent_filter,
 };
 
-decl_subsys(module, &module_ktype, &module_uevent_ops);
+struct kset *module_kset;
+int module_sysfs_initialized;
 
-static struct kobj_type module_ktype = {
+struct kobj_type module_ktype = {
        .sysfs_ops =    &module_sysfs_ops,
 };
 
@@ -697,51 +910,19 @@ static struct kobj_type module_ktype = {
  */
 static int __init param_sysfs_init(void)
 {
-       int ret;
-
-       ret = subsystem_register(&module_subsys);
-       if (ret < 0) {
-               printk(KERN_WARNING "%s (%d): subsystem_register error: %d\n",
-                       __FILE__, __LINE__, ret);
-               return ret;
+       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;
        }
+       module_sysfs_initialized = 1;
 
+       version_sysfs_builtin();
        param_sysfs_builtin();
 
        return 0;
 }
 subsys_initcall(param_sysfs_init);
 
-#else
-#if 0
-static struct sysfs_ops module_sysfs_ops = {
-       .show = NULL,
-       .store = NULL,
-};
-#endif
-#endif
-
-EXPORT_SYMBOL(param_set_byte);
-EXPORT_SYMBOL(param_get_byte);
-EXPORT_SYMBOL(param_set_short);
-EXPORT_SYMBOL(param_get_short);
-EXPORT_SYMBOL(param_set_ushort);
-EXPORT_SYMBOL(param_get_ushort);
-EXPORT_SYMBOL(param_set_int);
-EXPORT_SYMBOL(param_get_int);
-EXPORT_SYMBOL(param_set_uint);
-EXPORT_SYMBOL(param_get_uint);
-EXPORT_SYMBOL(param_set_long);
-EXPORT_SYMBOL(param_get_long);
-EXPORT_SYMBOL(param_set_ulong);
-EXPORT_SYMBOL(param_get_ulong);
-EXPORT_SYMBOL(param_set_charp);
-EXPORT_SYMBOL(param_get_charp);
-EXPORT_SYMBOL(param_set_bool);
-EXPORT_SYMBOL(param_get_bool);
-EXPORT_SYMBOL(param_set_invbool);
-EXPORT_SYMBOL(param_get_invbool);
-EXPORT_SYMBOL(param_array_set);
-EXPORT_SYMBOL(param_array_get);
-EXPORT_SYMBOL(param_set_copystring);
-EXPORT_SYMBOL(param_get_string);
+#endif /* CONFIG_SYSFS */