4 files changed, 47 insertions, 7 deletions

diff --git a/include/linux/module.h b/include/linux/module.h
index 145a75528cc1..08e5e75d6122 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -248,6 +248,10 @@ struct module
         const unsigned long *crcs;
         unsigned int num_syms;
 
+        /* Kernel parameters. */
+        struct kernel_param *kp;
+        unsigned int num_kp;
+
         /* GPL-only exported symbols. */
         unsigned int num_gpl_syms;
         const struct kernel_symbol *gpl_syms;
diff --git a/include/linux/moduleparam.h b/include/linux/moduleparam.h
index e4af3399ef48..a4f0b931846c 100644
--- a/include/linux/moduleparam.h
+++ b/include/linux/moduleparam.h
@@ -138,6 +138,16 @@ extern int parse_args(const char *name,
                       unsigned num,
                       int (*unknown)(char *param, char *val));
 
+/* Called by module remove. */
+#ifdef CONFIG_SYSFS
+extern void destroy_params(const struct kernel_param *params, unsigned num);
+#else
+static inline void destroy_params(const struct kernel_param *params,
+                                  unsigned num)
+{
+}
+#endif /* !CONFIG_SYSFS */
+
 /* All the helper functions */
 /* The macros to do compile-time type checking stolen from Jakub
    Jelinek, who IIRC came up with this idea for the 2.4 module init code. */
diff --git a/kernel/module.c b/kernel/module.c
index f77ac320d0b5..b862fdb6a372 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -1491,6 +1491,9 @@ static void free_module(struct module *mod)
         /* Module unload stuff */
         module_unload_free(mod);
 
+        /* Free any allocated parameters. */
+        destroy_params(mod->kp, mod->num_kp);
+
         /* release any pointers to mcount in this module */
         ftrace_release(mod->module_core, mod->core_size);
 
@@ -1898,8 +1901,7 @@ static noinline struct module *load_module(void __user *umod,
         unsigned int symindex = 0;
         unsigned int strindex = 0;
         unsigned int modindex, versindex, infoindex, pcpuindex;
-        unsigned int num_kp, num_mcount;
-        struct kernel_param *kp;
+        unsigned int num_mcount;
         struct module *mod;
         long err = 0;
         void *percpu = NULL, *ptr = NULL; /* Stops spurious gcc warning */
@@ -2144,8 +2146,8 @@ static noinline struct module *load_module(void __user *umod,
 
         /* Now we've got everything in the final locations, we can
          * find optional sections. */
-        kp = section_objs(hdr, sechdrs, secstrings, "__param", sizeof(*kp),
-                          &num_kp);
+        mod->kp = section_objs(hdr, sechdrs, secstrings, "__param",
+                               sizeof(*mod->kp), &mod->num_kp);
         mod->syms = section_objs(hdr, sechdrs, secstrings, "__ksymtab",
                                  sizeof(*mod->syms), &mod->num_syms);
         mod->crcs = section_addr(hdr, sechdrs, secstrings, "__kcrctab");
@@ -2291,11 +2293,11 @@ static noinline struct module *load_module(void __user *umod,
          */
         list_add_rcu(&mod->list, &modules);
 
-        err = parse_args(mod->name, mod->args, kp, num_kp, NULL);
+        err = parse_args(mod->name, mod->args, mod->kp, mod->num_kp, NULL);
         if (err < 0)
                 goto unlink;
 
-        err = mod_sysfs_setup(mod, kp, num_kp);
+        err = mod_sysfs_setup(mod, mod->kp, mod->num_kp);
         if (err < 0)
                 goto unlink;
         add_sect_attrs(mod, hdr->e_shnum, secstrings, sechdrs);
diff --git a/kernel/params.c b/kernel/params.c
index a1e3025b19a9..de273ec85bd2 100644
--- a/kernel/params.c
+++ b/kernel/params.c
@@ -24,6 +24,9 @@
 #include <linux/err.h>
 #include <linux/slab.h>
 
+/* We abuse the high bits of "perm" to record whether we kmalloc'ed. */
+#define KPARAM_KMALLOCED        0x80000000
+
 #if 0
 #define DEBUGP printk
 #else
@@ -217,7 +220,19 @@ int param_set_charp(const char *val, struct kernel_param *kp)
                 return -ENOSPC;
         }
 
-        *(char **)kp->arg = (char *)val;
+        if (kp->perm & 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->perm |= KPARAM_KMALLOCED;
+                *(char **)kp->arg = kstrdup(val, GFP_KERNEL);
+                if (!kp->arg)
+                        return -ENOMEM;
+        } else
+                *(const char **)kp->arg = val;
+
         return 0;
 }
 
@@ -571,6 +586,15 @@ void module_param_sysfs_remove(struct module *mod)
 }
 #endif
 
+void destroy_params(const struct kernel_param *params, unsigned num)
+{
+        unsigned int i;
+
+        for (i = 0; i < num; i++)
+                if (params[i].perm & KPARAM_KMALLOCED)
+                        kfree(*(char **)params[i].arg);
+}
+
 static void __init kernel_add_sysfs_param(const char *name,
                                           struct kernel_param *kparam,
                                           unsigned int name_skip)