module: add per-module param_lock

Add a "param_lock" mutex to each module, and update params.c to use
the correct built-in or module mutex while locking kernel params.
Remove the kparam_block_sysfs_r/w() macros, replace them with direct
calls to kernel_param_[un]lock(module).

The kernel param code currently uses a single mutex to protect
modification of any and all kernel params.  While this generally works,
there is one specific problem with it; a module callback function
cannot safely load another module, i.e. with request_module() or even
with indirect calls such as crypto_has_alg().  If the module to be
loaded has any of its params configured (e.g. with a /etc/modprobe.d/*
config file), then the attempt will result in a deadlock between the
first module param callback waiting for modprobe, and modprobe trying to
lock the single kernel param mutex to set the new module's param.

This fixes that by using per-module mutexes, so that each individual module
is protected against concurrent changes in its own kernel params, but is
not blocked by changes to other module params.  All built-in modules
continue to use the built-in mutex, since they will always be loaded at
runtime and references (e.g. request_module(), crypto_has_alg()) to them
will never cause load-time param changing.

This also simplifies the interface used by modules to block sysfs access
to their params; while there are currently functions to block and unblock
sysfs param access which are split up by read and write and expect a single
kernel param to be passed, their actual operation is identical and applies
to all params, not just the one passed to them; they simply lock and unlock
the global param mutex.  They are replaced with direct calls to
kernel_param_[un]lock(THIS_MODULE), which locks THIS_MODULE's param_lock, or
if the module is built-in, it locks the built-in mutex.

Suggested-by: Rusty Russell <rusty@rustcorp.com.au>
Signed-off-by: Dan Streetman <ddstreet@ieee.org>
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>

1 files changed, 10 insertions, 10 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) {