Driver Core: add ability for drivers to do a threaded probe

This adds the infrastructure for drivers to do a threaded probe, and
waits at init time for all currently outstanding probes to complete.

A new kernel thread will be created when the probe() function for the
driver is called, if the multithread_probe bit is set in the driver
saying it can support this kind of operation.

I have tested this with USB and PCI, and it works, and shaves off a lot
of time in the boot process, but there are issues with finding root boot
disks, and some USB drivers assume that this can never happen, so it is
currently not enabled for any bus type.  Individual drivers can enable
this right now if they wish, and bus authors can selectivly turn it on
as well, once they determine that their subsystem will work properly
with it.

Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

3 files changed, 89 insertions, 27 deletions

diff --git a/drivers/base/dd.c b/drivers/base/dd.c
index 9f6f11ca0ab6..319a73be4180 100644
--- a/drivers/base/dd.c
+++ b/drivers/base/dd.c
@@ -17,6 +17,7 @@
 
 #include <linux/device.h>
 #include <linux/module.h>
+#include <linux/kthread.h>
 
 #include "base.h"
 #include "power/power.h"
@@ -63,44 +64,35 @@ int device_bind_driver(struct device *dev)
         return ret;
 }
 
-/**
- *      driver_probe_device - attempt to bind device & driver.
- *      @drv:   driver.
- *      @dev:   device.
- *
- *      First, we call the bus's match function, if one present, which
- *      should compare the device IDs the driver supports with the
- *      device IDs of the device. Note we don't do this ourselves
- *      because we don't know the format of the ID structures, nor what
- *      is to be considered a match and what is not.
- *
- *      This function returns 1 if a match is found, an error if one
- *      occurs (that is not -ENODEV or -ENXIO), and 0 otherwise.
- *
- *      This function must be called with @dev->sem held.  When called
- *      for a USB interface, @dev->parent->sem must be held as well.
- */
-int driver_probe_device(struct device_driver * drv, struct device * dev)
+struct stupid_thread_structure {
+        struct device_driver *drv;
+        struct device *dev;
+};
+
+static atomic_t probe_count = ATOMIC_INIT(0);
+static int really_probe(void *void_data)
 {
+        struct stupid_thread_structure *data = void_data;
+        struct device_driver *drv = data->drv;
+        struct device *dev = data->dev;
         int ret = 0;
 
-        if (drv->bus->match && !drv->bus->match(dev, drv))
-                goto Done;
+        atomic_inc(&probe_count);
+        pr_debug("%s: Probing driver %s with device %s\n",
+                 drv->bus->name, drv->name, dev->bus_id);
 
-        pr_debug("%s: Matched Device %s with Driver %s\n",
-                 drv->bus->name, dev->bus_id, drv->name);
         dev->driver = drv;
         if (dev->bus->probe) {
                 ret = dev->bus->probe(dev);
                 if (ret) {
                         dev->driver = NULL;
-                        goto ProbeFailed;
+                        goto probe_failed;
                 }
         } else if (drv->probe) {
                 ret = drv->probe(dev);
                 if (ret) {
                         dev->driver = NULL;
-                        goto ProbeFailed;
+                        goto probe_failed;
                 }
         }
         if (device_bind_driver(dev)) {
@@ -111,9 +103,9 @@ int driver_probe_device(struct device_driver * drv, struct device * dev)
         ret = 1;
         pr_debug("%s: Bound Device %s to Driver %s\n",
                  drv->bus->name, dev->bus_id, drv->name);
-        goto Done;
+        goto done;
 
- ProbeFailed:
+probe_failed:
         if (ret == -ENODEV || ret == -ENXIO) {
                 /* Driver matched, but didn't support device
                  * or device not found.
@@ -126,7 +118,69 @@ int driver_probe_device(struct device_driver * drv, struct device * dev)
                        "%s: probe of %s failed with error %d\n",
                        drv->name, dev->bus_id, ret);
         }
- Done:
+done:
+        kfree(data);
+        atomic_dec(&probe_count);
+        return ret;
+}
+
+/**
+ * driver_probe_done
+ * Determine if the probe sequence is finished or not.
+ *
+ * Should somehow figure out how to use a semaphore, not an atomic variable...
+ */
+int driver_probe_done(void)
+{
+        pr_debug("%s: probe_count = %d\n", __FUNCTION__,
+                 atomic_read(&probe_count));
+        if (atomic_read(&probe_count))
+                return -EBUSY;
+        return 0;
+}
+
+/**
+ * driver_probe_device - attempt to bind device & driver together
+ * @drv: driver to bind a device to
+ * @dev: device to try to bind to the driver
+ *
+ * First, we call the bus's match function, if one present, which should
+ * compare the device IDs the driver supports with the device IDs of the
+ * device. Note we don't do this ourselves because we don't know the
+ * format of the ID structures, nor what is to be considered a match and
+ * what is not.
+ *
+ * This function returns 1 if a match is found, an error if one occurs
+ * (that is not -ENODEV or -ENXIO), and 0 otherwise.
+ *
+ * This function must be called with @dev->sem held.  When called for a
+ * USB interface, @dev->parent->sem must be held as well.
+ */
+int driver_probe_device(struct device_driver * drv, struct device * dev)
+{
+        struct stupid_thread_structure *data;
+        struct task_struct *probe_task;
+        int ret = 0;
+
+        if (drv->bus->match && !drv->bus->match(dev, drv))
+                goto done;
+
+        pr_debug("%s: Matched Device %s with Driver %s\n",
+                 drv->bus->name, dev->bus_id, drv->name);
+
+        data = kmalloc(sizeof(*data), GFP_KERNEL);
+        data->drv = drv;
+        data->dev = dev;
+
+        if (drv->multithread_probe) {
+                probe_task = kthread_run(really_probe, data,
+                                         "probe-%s", dev->bus_id);
+                if (IS_ERR(probe_task))
+                        ret = PTR_ERR(probe_task);
+        } else
+                ret = really_probe(data);
+
+done:
         return ret;
 }
 
diff --git a/include/linux/device.h b/include/linux/device.h
index b3da9a870cfc..74246efba931 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -106,6 +106,8 @@ struct device_driver {
         void    (*shutdown)     (struct device * dev);
         int     (*suspend)      (struct device * dev, pm_message_t state);
         int     (*resume)       (struct device * dev);
+
+        unsigned int multithread_probe:1;
 };
 
 
@@ -115,6 +117,7 @@ extern void driver_unregister(struct device_driver * drv);
 extern struct device_driver * get_driver(struct device_driver * drv);
 extern void put_driver(struct device_driver * drv);
 extern struct device_driver *driver_find(const char *name, struct bus_type *bus);
+extern int driver_probe_done(void);
 
 /* driverfs interface for exporting driver attributes */
 
diff --git a/init/do_mounts.c b/init/do_mounts.c
index 94aeec7aa917..b290aadb1d3f 100644
--- a/init/do_mounts.c
+++ b/init/do_mounts.c
@@ -8,6 +8,7 @@
 #include <linux/security.h>
 #include <linux/delay.h>
 #include <linux/mount.h>
+#include <linux/device.h>
 
 #include <linux/nfs_fs.h>
 #include <linux/nfs_fs_sb.h>
@@ -403,6 +404,10 @@ void __init prepare_namespace(void)
                 ssleep(root_delay);
         }
 
+        /* wait for the known devices to complete their probing */
+        while (driver_probe_done() != 0)
+                msleep(100);
+
         md_run_setup();
 
         if (saved_root_name[0]) {