10 files changed, 65 insertions, 93 deletions

diff --git a/arch/um/drivers/hostaudio_kern.c b/arch/um/drivers/hostaudio_kern.c
index 9b90fdc4b151..f6b911cc3923 100644
--- a/arch/um/drivers/hostaudio_kern.c
+++ b/arch/um/drivers/hostaudio_kern.c
@@ -185,9 +185,9 @@ static int hostaudio_open(struct inode *inode, struct file *file)
         int ret;
 
 #ifdef DEBUG
-        kparam_block_sysfs_write(dsp);
+        kernel_param_lock(THIS_MODULE);
         printk(KERN_DEBUG "hostaudio: open called (host: %s)\n", dsp);
-        kparam_unblock_sysfs_write(dsp);
+        kernel_param_unlock(THIS_MODULE);
 #endif
 
         state = kmalloc(sizeof(struct hostaudio_state), GFP_KERNEL);
@@ -199,11 +199,11 @@ static int hostaudio_open(struct inode *inode, struct file *file)
         if (file->f_mode & FMODE_WRITE)
                 w = 1;
 
-        kparam_block_sysfs_write(dsp);
+        kernel_param_lock(THIS_MODULE);
         mutex_lock(&hostaudio_mutex);
         ret = os_open_file(dsp, of_set_rw(OPENFLAGS(), r, w), 0);
         mutex_unlock(&hostaudio_mutex);
-        kparam_unblock_sysfs_write(dsp);
+        kernel_param_unlock(THIS_MODULE);
 
         if (ret < 0) {
                 kfree(state);
@@ -260,17 +260,17 @@ static int hostmixer_open_mixdev(struct inode *inode, struct file *file)
         if (file->f_mode & FMODE_WRITE)
                 w = 1;
 
-        kparam_block_sysfs_write(mixer);
+        kernel_param_lock(THIS_MODULE);
         mutex_lock(&hostaudio_mutex);
         ret = os_open_file(mixer, of_set_rw(OPENFLAGS(), r, w), 0);
         mutex_unlock(&hostaudio_mutex);
-        kparam_unblock_sysfs_write(mixer);
+        kernel_param_unlock(THIS_MODULE);
 
         if (ret < 0) {
-                kparam_block_sysfs_write(dsp);
+                kernel_param_lock(THIS_MODULE);
                 printk(KERN_ERR "hostaudio_open_mixdev failed to open '%s', "
                        "err = %d\n", dsp, -ret);
-                kparam_unblock_sysfs_write(dsp);
+                kernel_param_unlock(THIS_MODULE);
                 kfree(state);
                 return ret;
         }
@@ -326,10 +326,10 @@ MODULE_LICENSE("GPL");
 
 static int __init hostaudio_init_module(void)
 {
-        __kernel_param_lock();
+        kernel_param_lock(THIS_MODULE);
         printk(KERN_INFO "UML Audio Relay (host dsp = %s, host mixer = %s)\n",
                dsp, mixer);
-        __kernel_param_unlock();
+        kernel_param_unlock(THIS_MODULE);
 
         module_data.dev_audio = register_sound_dsp(&hostaudio_fops, -1);
         if (module_data.dev_audio < 0) {
diff --git a/drivers/net/ethernet/myricom/myri10ge/myri10ge.c b/drivers/net/ethernet/myricom/myri10ge/myri10ge.c
index 2bae50292dcd..83651ac8ddb9 100644
--- a/drivers/net/ethernet/myricom/myri10ge/myri10ge.c
+++ b/drivers/net/ethernet/myricom/myri10ge/myri10ge.c
@@ -279,7 +279,7 @@ MODULE_FIRMWARE("myri10ge_eth_z8e.dat");
 MODULE_FIRMWARE("myri10ge_rss_ethp_z8e.dat");
 MODULE_FIRMWARE("myri10ge_rss_eth_z8e.dat");
 
-/* Careful: must be accessed under kparam_block_sysfs_write */
+/* Careful: must be accessed under kernel_param_lock() */
 static char *myri10ge_fw_name = NULL;
 module_param(myri10ge_fw_name, charp, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(myri10ge_fw_name, "Firmware image name");
@@ -3427,7 +3427,7 @@ static void myri10ge_select_firmware(struct myri10ge_priv *mgp)
                 }
         }
 
-        kparam_block_sysfs_write(myri10ge_fw_name);
+        kernel_param_lock(THIS_MODULE);
         if (myri10ge_fw_name != NULL) {
                 char *fw_name = kstrdup(myri10ge_fw_name, GFP_KERNEL);
                 if (fw_name) {
@@ -3435,7 +3435,7 @@ static void myri10ge_select_firmware(struct myri10ge_priv *mgp)
                         set_fw_name(mgp, fw_name, true);
                 }
         }
-        kparam_unblock_sysfs_write(myri10ge_fw_name);
+        kernel_param_unlock(THIS_MODULE);
 
         if (mgp->board_number < MYRI10GE_MAX_BOARDS &&
             myri10ge_fw_names[mgp->board_number] != NULL &&
diff --git a/drivers/net/wireless/libertas_tf/if_usb.c b/drivers/net/wireless/libertas_tf/if_usb.c
index 1a20cee5febe..799a2efe5793 100644
--- a/drivers/net/wireless/libertas_tf/if_usb.c
+++ b/drivers/net/wireless/libertas_tf/if_usb.c
@@ -821,15 +821,15 @@ static int if_usb_prog_firmware(struct if_usb_card *cardp)
 
         lbtf_deb_enter(LBTF_DEB_USB);
 
-        kparam_block_sysfs_write(fw_name);
+        kernel_param_lock(THIS_MODULE);
         ret = request_firmware(&cardp->fw, lbtf_fw_name, &cardp->udev->dev);
         if (ret < 0) {
                 pr_err("request_firmware() failed with %#x\n", ret);
                 pr_err("firmware %s not found\n", lbtf_fw_name);
-                kparam_unblock_sysfs_write(fw_name);
+                kernel_param_unlock(THIS_MODULE);
                 goto done;
         }
-        kparam_unblock_sysfs_write(fw_name);
+        kernel_param_unlock(THIS_MODULE);
 
         if (check_fwfile_format(cardp->fw->data, cardp->fw->size))
                 goto release_fw;
diff --git a/drivers/usb/atm/ueagle-atm.c b/drivers/usb/atm/ueagle-atm.c
index 888998a7fe31..a2ae88dbda78 100644
--- a/drivers/usb/atm/ueagle-atm.c
+++ b/drivers/usb/atm/ueagle-atm.c
@@ -1599,7 +1599,7 @@ static void cmvs_file_name(struct uea_softc *sc, char *const cmv_name, int ver)
         char file_arr[] = "CMVxy.bin";
         char *file;
 
-        kparam_block_sysfs_write(cmv_file);
+        kernel_param_lock(THIS_MODULE);
         /* set proper name corresponding modem version and line type */
         if (cmv_file[sc->modem_index] == NULL) {
                 if (UEA_CHIP_VERSION(sc) == ADI930)
@@ -1618,7 +1618,7 @@ static void cmvs_file_name(struct uea_softc *sc, char *const cmv_name, int ver)
         strlcat(cmv_name, file, UEA_FW_NAME_MAX);
         if (ver == 2)
                 strlcat(cmv_name, ".v2", UEA_FW_NAME_MAX);
-        kparam_unblock_sysfs_write(cmv_file);
+        kernel_param_unlock(THIS_MODULE);
 }
 
 static int request_cmvs_old(struct uea_softc *sc,
diff --git a/drivers/video/fbdev/vt8623fb.c b/drivers/video/fbdev/vt8623fb.c
index ea7f056ed5fe..8bac309c24b9 100644
--- a/drivers/video/fbdev/vt8623fb.c
+++ b/drivers/video/fbdev/vt8623fb.c
@@ -754,9 +754,9 @@ static int vt8623_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
 
         /* Prepare startup mode */
 
-        kparam_block_sysfs_write(mode_option);
+        kernel_param_lock(THIS_MODULE);
         rc = fb_find_mode(&(info->var), info, mode_option, NULL, 0, NULL, 8);
-        kparam_unblock_sysfs_write(mode_option);
+        kernel_param_unlock(THIS_MODULE);
         if (! ((rc == 1) || (rc == 2))) {
                 rc = -EINVAL;
                 dev_err(info->device, "mode %s not found\n", mode_option);
diff --git a/include/linux/module.h b/include/linux/module.h
index 4c1b02e1361d..6ba0e87fa804 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -240,6 +240,7 @@ struct module {
         unsigned int num_syms;
 
         /* Kernel parameters. */
+        struct mutex param_lock;
         struct kernel_param *kp;
         unsigned int num_kp;
 
diff --git a/include/linux/moduleparam.h b/include/linux/moduleparam.h
index ab5031453807..f1fdc50520d8 100644
--- a/include/linux/moduleparam.h
+++ b/include/linux/moduleparam.h
@@ -67,6 +67,7 @@ enum {
 
 struct kernel_param {
         const char *name;
+        struct module *mod;
         const struct kernel_param_ops *ops;
         const u16 perm;
         s8 level;
@@ -108,7 +109,7 @@ struct kparam_array
  *
  * @perm is 0 if the the variable is not to appear in sysfs, or 0444
  * for world-readable, 0644 for root-writable, etc.  Note that if it
- * is writable, you may need to use kparam_block_sysfs_write() around
+ * is writable, you may need to use kernel_param_lock() around
  * accesses (esp. charp, which can be kfreed when it changes).
  *
  * The @type is simply pasted to refer to a param_ops_##type and a
@@ -216,12 +217,12 @@ struct kparam_array
    parameters. */
 #define __module_param_call(prefix, name, ops, arg, perm, level, flags) \
         /* Default value instead of permissions? */                     \
-        static const char __param_str_##name[] = prefix #name; \
+        static const char __param_str_##name[] = prefix #name;          \
         static struct kernel_param __moduleparam_const __param_##name   \
         __used                                                          \
     __attribute__ ((unused,__section__ ("__param"),aligned(sizeof(void *)))) \
-        = { __param_str_##name, ops, VERIFY_OCTAL_PERMISSIONS(perm),    \
-            level, flags, { arg } }
+        = { __param_str_##name, THIS_MODULE, ops,                       \
+            VERIFY_OCTAL_PERMISSIONS(perm), level, flags, { arg } }
 
 /* Obsolete - use module_param_cb() */
 #define module_param_call(name, set, get, arg, perm)                    \
@@ -238,58 +239,14 @@ __check_old_set_param(int (*oldset)(const char *, struct kernel_param *))
         return 0;
 }
 
-/**
- * kparam_block_sysfs_write - make sure a parameter isn't written via sysfs.
- * @name: the name of the parameter
- *
- * There's no point blocking write on a paramter that isn't writable via sysfs!
- */
-#define kparam_block_sysfs_write(name)                  \
-        do {                                            \
-                BUG_ON(!(__param_##name.perm & 0222));  \
-                __kernel_param_lock();                  \
-        } while (0)
-
-/**
- * kparam_unblock_sysfs_write - allows sysfs to write to a parameter again.
- * @name: the name of the parameter
- */
-#define kparam_unblock_sysfs_write(name)                \
-        do {                                            \
-                BUG_ON(!(__param_##name.perm & 0222));  \
-                __kernel_param_unlock();                \
-        } while (0)
-
-/**
- * kparam_block_sysfs_read - make sure a parameter isn't read via sysfs.
- * @name: the name of the parameter
- *
- * This also blocks sysfs writes.
- */
-#define kparam_block_sysfs_read(name)                   \
-        do {                                            \
-                BUG_ON(!(__param_##name.perm & 0444));  \
-                __kernel_param_lock();                  \
-        } while (0)
-
-/**
- * kparam_unblock_sysfs_read - allows sysfs to read a parameter again.
- * @name: the name of the parameter
- */
-#define kparam_unblock_sysfs_read(name)                 \
-        do {                                            \
-                BUG_ON(!(__param_##name.perm & 0444));  \
-                __kernel_param_unlock();                \
-        } while (0)
-
 #ifdef CONFIG_SYSFS
-extern void __kernel_param_lock(void);
-extern void __kernel_param_unlock(void);
+extern void kernel_param_lock(struct module *mod);
+extern void kernel_param_unlock(struct module *mod);
 #else
-static inline void __kernel_param_lock(void)
+static inline void kernel_param_lock(struct module *mod)
 {
 }
-static inline void __kernel_param_unlock(void)
+static inline void kernel_param_unlock(struct module *mod)
 {
 }
 #endif
diff --git a/kernel/module.c b/kernel/module.c
index 427b99f1a4b3..8ec33ce202a6 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -3442,6 +3442,8 @@ static int load_module(struct load_info *info, const char __user *uargs,
         if (err)
                 goto unlink_mod;
 
+        mutex_init(&mod->param_lock);
+
         /* Now we've got everything in the final locations, we can
          * find optional sections. */
         err = find_module_sections(mod, info);
diff --git a/kernel/params.c b/kernel/params.c
index a8b09f6c87dc..8890d0b8dffc 100644
--- a/kernel/params.c
+++ b/kernel/params.c
@@ -25,15 +25,20 @@
 #include <linux/slab.h>
 #include <linux/ctype.h>
 
-/* Protects all parameters, and incidentally kmalloced_param list. */
+/* Protects all built-in parameters, modules use their own param_lock */
 static DEFINE_MUTEX(param_lock);
 
+/* Use the module's mutex, or if built-in use the built-in mutex */
+#define KPARAM_MUTEX(mod)       ((mod) ? &(mod)->param_lock : &param_lock)
+#define KPARAM_IS_LOCKED(mod)   mutex_is_locked(KPARAM_MUTEX(mod))
+
 /* 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 DEFINE_SPINLOCK(kmalloced_params_lock);
 
 static void *kmalloc_parameter(unsigned int size)
 {
@@ -43,7 +48,10 @@ static void *kmalloc_parameter(unsigned int size)
         if (!p)
                 return NULL;
 
+        spin_lock(&kmalloced_params_lock);
         list_add(&p->list, &kmalloced_params);
+        spin_unlock(&kmalloced_params_lock);
+
         return p->val;
 }
 
@@ -52,6 +60,7 @@ static void maybe_kfree_parameter(void *param)
 {
         struct kmalloced_param *p;
 
+        spin_lock(&kmalloced_params_lock);
         list_for_each_entry(p, &kmalloced_params, list) {
                 if (p->val == param) {
                         list_del(&p->list);
@@ -59,6 +68,7 @@ static void maybe_kfree_parameter(void *param)
                         break;
                 }
         }
+        spin_unlock(&kmalloced_params_lock);
 }
 
 static char dash2underscore(char c)
@@ -118,10 +128,10 @@ static int parse_one(char *param,
                                 return -EINVAL;
                         pr_debug("handling %s with %p\n", param,
                                 params[i].ops->set);
-                        mutex_lock(&param_lock);
+                        kernel_param_lock(params[i].mod);
                         param_check_unsafe(&params[i]);
                         err = params[i].ops->set(val, &params[i]);
-                        mutex_unlock(&param_lock);
+                        kernel_param_unlock(params[i].mod);
                         return err;
                 }
         }
@@ -417,7 +427,8 @@ const struct kernel_param_ops param_ops_bint = {
 EXPORT_SYMBOL(param_ops_bint);
 
 /* We break the rule and mangle the string. */
-static int param_array(const char *name,
+static int param_array(struct module *mod,
+                       const char *name,
                        const char *val,
                        unsigned int min, unsigned int max,
                        void *elem, int elemsize,
@@ -448,7 +459,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));
+                BUG_ON(!KPARAM_IS_LOCKED(mod));
                 ret = set(val, &kp);
 
                 if (ret != 0)
@@ -470,7 +481,7 @@ static int param_array_set(const char *val, const 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,
+        return param_array(kp->mod, kp->name, val, 1, arr->max, arr->elem,
                            arr->elemsize, arr->ops->set, kp->level,
                            arr->num ?: &temp_num);
 }
@@ -485,7 +496,7 @@ static int param_array_get(char *buffer, const struct kernel_param *kp)
                 if (i)
                         buffer[off++] = ',';
                 p.arg = arr->elem + arr->elemsize * i;
-                BUG_ON(!mutex_is_locked(&param_lock));
+                BUG_ON(!KPARAM_IS_LOCKED(p.mod));
                 ret = arr->ops->get(buffer + off, &p);
                 if (ret < 0)
                         return ret;
@@ -568,9 +579,9 @@ static ssize_t param_attr_show(struct module_attribute *mattr,
         if (!attribute->param->ops->get)
                 return -EPERM;
 
-        mutex_lock(&param_lock);
+        kernel_param_lock(mk->mod);
         count = attribute->param->ops->get(buf, attribute->param);
-        mutex_unlock(&param_lock);
+        kernel_param_unlock(mk->mod);
         if (count > 0) {
                 strcat(buf, "\n");
                 ++count;
@@ -580,7 +591,7 @@ 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_kobject *km,
+                                struct module_kobject *mk,
                                 const char *buf, size_t len)
 {
         int err;
@@ -589,10 +600,10 @@ static ssize_t param_attr_store(struct module_attribute *mattr,
         if (!attribute->param->ops->set)
                 return -EPERM;
 
-        mutex_lock(&param_lock);
+        kernel_param_lock(mk->mod);
         param_check_unsafe(attribute->param);
         err = attribute->param->ops->set(buf, attribute->param);
-        mutex_unlock(&param_lock);
+        kernel_param_unlock(mk->mod);
         if (!err)
                 return len;
         return err;
@@ -605,18 +616,19 @@ static ssize_t param_attr_store(struct module_attribute *mattr,
 #define __modinit __init
 #endif
 
-#ifdef CONFIG_SYSFS
-void __kernel_param_lock(void)
+void kernel_param_lock(struct module *mod)
 {
-        mutex_lock(&param_lock);
+        mutex_lock(KPARAM_MUTEX(mod));
 }
-EXPORT_SYMBOL(__kernel_param_lock);
 
-void __kernel_param_unlock(void)
+void kernel_param_unlock(struct module *mod)
 {
-        mutex_unlock(&param_lock);
+        mutex_unlock(KPARAM_MUTEX(mod));
 }
-EXPORT_SYMBOL(__kernel_param_unlock);
+
+#ifdef CONFIG_SYSFS
+EXPORT_SYMBOL(kernel_param_lock);
+EXPORT_SYMBOL(kernel_param_unlock);
 
 /*
  * add_sysfs_param - add a parameter to sysfs
diff --git a/net/mac80211/rate.c b/net/mac80211/rate.c
index d53355b011f5..8544e2eb570e 100644
--- a/net/mac80211/rate.c
+++ b/net/mac80211/rate.c
@@ -103,7 +103,7 @@ ieee80211_rate_control_ops_get(const char *name)
         const struct rate_control_ops *ops;
         const char *alg_name;
 
-        kparam_block_sysfs_write(ieee80211_default_rc_algo);
+        kernel_param_lock(THIS_MODULE);
         if (!name)
                 alg_name = ieee80211_default_rc_algo;
         else
@@ -117,7 +117,7 @@ ieee80211_rate_control_ops_get(const char *name)
         /* try built-in one if specific alg requested but not found */
         if (!ops && strlen(CONFIG_MAC80211_RC_DEFAULT))
                 ops = ieee80211_try_rate_control_ops_get(CONFIG_MAC80211_RC_DEFAULT);
-        kparam_unblock_sysfs_write(ieee80211_default_rc_algo);
+        kernel_param_unlock(THIS_MODULE);
 
         return ops;
 }