driver synchronization: make scsi_wait_scan more advanced

There is currently only one way for userspace to say "wait for my storage
device to get ready for the modules I just loaded": to load the
scsi_wait_scan module. Expectations of userspace are that once this
module is loaded, all the (storage) devices for which the drivers
were loaded before the module load are present.

Now, there are some issues with the implementation, and the async
stuff got caught in the middle of this: The existing code only
waits for the scsy async probing to finish, but it did not take
into account at all that probing might not have begun yet.
(Russell ran into this problem on his computer and the fix works for him)

This patch fixes this more thoroughly than the previous "fix", which
had some bad side effects (namely, for kernel code that wanted to wait for
the scsi scan it would also do an async sync, which would deadlock if you did
it from async context already.. there's a report about that on lkml):
The patch makes the module first wait for all device driver probes, and then it
will wait for the scsi parallel scan to finish.

Signed-off-by: Arjan van de Ven <arjan@linux.intel.com>
Tested-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/drivers/base/dd.c b/drivers/base/dd.c
index f17c3266a0e045f963eabebbc3009df5e356839b..742cbe6b042bbf711054e2cd7f02cdcc66354752 100644 (file)
--- a/drivers/base/dd.c
+++ b/drivers/base/dd.c
@@ -179,6 +179,7 @@ void wait_for_device_probe(void)
        wait_event(probe_waitqueue, atomic_read(&probe_count) == 0);
        async_synchronize_full();
 }
+EXPORT_SYMBOL_GPL(wait_for_device_probe);
 
 /**
  * driver_probe_device - attempt to bind device & driver together

diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
index a14d245a66b842c3bdfa619a04904fefd8e90db5..6f51ca485f35df24e28b21752e9bae0aed20d8a9 100644 (file)
--- a/drivers/scsi/scsi_scan.c
+++ b/drivers/scsi/scsi_scan.c
@@ -180,8 +180,6 @@ int scsi_complete_async_scans(void)
        spin_unlock(&async_scan_lock);
 
        kfree(data);
-       /* Synchronize async operations globally */
-       async_synchronize_full();
        return 0;
 }
 

diff --git a/drivers/scsi/scsi_wait_scan.c b/drivers/scsi/scsi_wait_scan.c
index 2f21af21269a76eefc7ca070e05eb2aee4acc133..74708fcaf82fe900c3a77689ccad11c91b48b173 100644 (file)
--- a/drivers/scsi/scsi_wait_scan.c
+++ b/drivers/scsi/scsi_wait_scan.c
@@ -11,10 +11,21 @@
  */
 
 #include <linux/module.h>
+#include <linux/device.h>
 #include <scsi/scsi_scan.h>
 
 static int __init wait_scan_init(void)
 {
+       /*
+        * First we need to wait for device probing to finish;
+        * the drivers we just loaded might just still be probing
+        * and might not yet have reached the scsi async scanning
+        */
+       wait_for_device_probe();
+       /*
+        * and then we wait for the actual asynchronous scsi scan
+        * to finish.
+        */
        scsi_complete_async_scans();
        return 0;
 }

diff --git a/include/linux/device.h b/include/linux/device.h
index 2918c0e8fdfdeed78d032b7218bd2194b627706e..6a69caaac18a8f18fcbdc60c2f5e686ff95922c8 100644 (file)
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -551,6 +551,7 @@ extern int (*platform_notify_remove)(struct device *dev);
 extern struct device *get_device(struct device *dev);
 extern void put_device(struct device *dev);
 
+extern void wait_for_device_probe(void);
 
 /* drivers/base/power/shutdown.c */
 extern void device_shutdown(void);