[PATCH 8/8] driver-core: allow enabling async probing for all modules and builtins

Dmitry Torokhov
2015-03-30T23:20:43Z

From: "Luis R. Rodriguez" <mcgrof@suse.com>

Folks wishing to test enabling async probe for all built-in drivers
and/or for all modules can use
__DEBUG__kernel_force_builtin_async_probe or
__DEBUG__kernel_force_modules_async_probe kernel parameters.

Activating either one will taint your kernel.

Signed-off-by: Luis R. Rodriguez <mcgrof@suse.com>
[Dmitry: split off from another patch, split into 2 parameters, moved
over to core_param_unsafe()]
Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
---
Documentation/kernel-parameters.txt | 10 ++++++++++
drivers/base/dd.c | 13 +++++++++----
kernel/module.c | 7 +++++++
3 files changed, 26 insertions(+), 4 deletions(-)

diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt
index 035d668..464dd56 100644
--- a/Documentation/kernel-parameters.txt
+++ b/Documentation/kernel-parameters.txt
@@ -932,6 +932,16 @@ bytes respectively. Such letter suffixes can also be entirely omitted.
module.async_probe [KNL]
Enable asynchronous probe on this module.

+ __DEBUG__kernel_force_builtin_async_probe [KNL]
+ Enable asynchronous probe on all built-in drivers.
+ This is is testing parameter and using it will taint
+ your kernel.
+
+ __DEBUG__kernel_force_modules_async_probe [KNL]
+ Enable asynchronous probe on all modules. This is
+ is testing parameter and using it will taint your
+ kernel.
+
early_ioremap_debug [KNL]
Enable debug messages in early_ioremap support. This
is useful for tracking down temporary early mappings
diff --git a/drivers/base/dd.c b/drivers/base/dd.c
index 3929253..9463457 100644
--- a/drivers/base/dd.c
+++ b/drivers/base/dd.c
@@ -20,6 +20,7 @@
#include <linux/device.h>
#include <linux/delay.h>
#include <linux/module.h>
+#include <linux/moduleparam.h>
#include <linux/kthread.h>
#include <linux/wait.h>
#include <linux/async.h>
@@ -417,6 +418,10 @@ int driver_probe_device(struct device_driver *drv, struct device *dev)
return ret;
}

+static bool force_builtin_async_probe;
+core_param_unsafe(__DEBUG__kernel_force_builtin_async_probe,
+ force_builtin_async_probe, bool, 0644);
+
bool driver_allows_async_probing(struct device_driver *drv)
{
switch (drv->probe_type) {
@@ -427,10 +432,10 @@ bool driver_allows_async_probing(struct device_driver *drv)
return false;

default:
- if (drv->owner && drv->owner->async_probe_requested)
- return true;
-
- return false;
+ if (drv->owner)
+ return drv->owner->async_probe_requested;
+ else
+ return force_builtin_async_probe;
}
}

diff --git a/kernel/module.c b/kernel/module.c
index 7b2fe3e..8dad167 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -3235,6 +3235,10 @@ static int unknown_module_param_cb(char *param, char *val, const char *modname,
return 0;
}

+static bool force_modules_async_probe;
+core_param_unsafe(__DEBUG__kernel_force_modules_async_probe,
+ force_modules_async_probe, bool, 0644);
+
/* Allocate and load the module: note that size of section 0 is always
zero, and we rely on this for optional sections. */
static int load_module(struct load_info *info, const char __user *uargs,
@@ -3329,6 +3333,9 @@ static int load_module(struct load_info *info, const char __user *uargs,
if (err)
goto ddebug_cleanup;

+ if (force_modules_async_probe)
+ mod->async_probe_requested = true;
+
/* Module is ready to execute: parsing args may do that. */
after_dashes = parse_args(mod->name, mod->args, mod->kp, mod->num_kp,
-32768, 32767, NULL,
--
2.2.0.rc0.207.ga3a616c