[PATCH] drivers: wait for threaded probes between initcall levels

The multithreaded-probing code has a problem: after one initcall level (eg,
core_initcall) has been processed, we will then start processing the next
level (postcore_initcall) while the kernel threads which are handling
core_initcall are still executing.  This breaks the guarantees which the
layered initcalls previously gave us.

IOW, we want to be multithreaded _within_ an initcall level, but not between
different levels.

Fix that up by causing the probing code to wait for all outstanding probes at
one level to complete before we start processing the next level.

Cc: Greg KH <greg@kroah.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

diff --git a/drivers/base/dd.c b/drivers/base/dd.c
index db01b95a47a501d5976c04d66052a8809f026f29..c5d6bb4290ad2d8fa24c279dc71aaef0b0eb46e4 100644 (file)
--- a/drivers/base/dd.c
+++ b/drivers/base/dd.c
@@ -18,6 +18,7 @@
 #include <linux/device.h>
 #include <linux/module.h>
 #include <linux/kthread.h>
+#include <linux/wait.h>
 
 #include "base.h"
 #include "power/power.h"
@@ -70,6 +71,8 @@ struct stupid_thread_structure {
 };
 
 static atomic_t probe_count = ATOMIC_INIT(0);
+static DECLARE_WAIT_QUEUE_HEAD(probe_waitqueue);
+
 static int really_probe(void *void_data)
 {
        struct stupid_thread_structure *data = void_data;
@@ -121,6 +124,7 @@ probe_failed:
 done:
        kfree(data);
        atomic_dec(&probe_count);
+       wake_up(&probe_waitqueue);
        return ret;
 }
 
@@ -337,6 +341,32 @@ void driver_detach(struct device_driver * drv)
        }
 }
 
+#ifdef CONFIG_PCI_MULTITHREAD_PROBE
+static int __init wait_for_probes(void)
+{
+       DEFINE_WAIT(wait);
+
+       printk(KERN_INFO "%s: waiting for %d threads\n", __FUNCTION__,
+                       atomic_read(&probe_count));
+       if (!atomic_read(&probe_count))
+               return 0;
+       while (atomic_read(&probe_count)) {
+               prepare_to_wait(&probe_waitqueue, &wait, TASK_UNINTERRUPTIBLE);
+               if (atomic_read(&probe_count))
+                       schedule();
+       }
+       finish_wait(&probe_waitqueue, &wait);
+       return 0;
+}
+
+core_initcall_sync(wait_for_probes);
+postcore_initcall_sync(wait_for_probes);
+arch_initcall_sync(wait_for_probes);
+subsys_initcall_sync(wait_for_probes);
+fs_initcall_sync(wait_for_probes);
+device_initcall_sync(wait_for_probes);
+late_initcall_sync(wait_for_probes);
+#endif
 
 EXPORT_SYMBOL_GPL(device_bind_driver);
 EXPORT_SYMBOL_GPL(device_release_driver);

diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h
index e3e83bcaf71047f2f113c76ed50d1abf8b312fa7..9d873163a7ab09dfe605e2a2a49c5176f1b347e9 100644 (file)
--- a/include/asm-generic/vmlinux.lds.h
+++ b/include/asm-generic/vmlinux.lds.h
@@ -216,10 +216,17 @@
 
 #define INITCALLS                                                      \
        *(.initcall1.init)                                              \
+       *(.initcall1s.init)                                             \
        *(.initcall2.init)                                              \
+       *(.initcall2s.init)                                             \
        *(.initcall3.init)                                              \
+       *(.initcall3s.init)                                             \
        *(.initcall4.init)                                              \
+       *(.initcall4s.init)                                             \
        *(.initcall5.init)                                              \
+       *(.initcall5s.init)                                             \
        *(.initcall6.init)                                              \
-       *(.initcall7.init)
+       *(.initcall6s.init)                                             \
+       *(.initcall7.init)                                              \
+       *(.initcall7s.init)
 

diff --git a/include/linux/init.h b/include/linux/init.h
index e92b1455d7afd8c908bfc0722be018a09c46c226..ff40ea118e3a7798f2a3a092be3cc238788cbd2c 100644 (file)
--- a/include/linux/init.h
+++ b/include/linux/init.h
@@ -84,19 +84,29 @@ extern void setup_arch(char **);
  * by link order. 
  * For backwards compatibility, initcall() puts the call in 
  * the device init subsection.
+ *
+ * The `id' arg to __define_initcall() is needed so that multiple initcalls
+ * can point at the same handler without causing duplicate-symbol build errors.
  */
 
-#define __define_initcall(level,fn) \
-       static initcall_t __initcall_##fn __attribute_used__ \
+#define __define_initcall(level,fn,id) \
+       static initcall_t __initcall_##fn##id __attribute_used__ \
        __attribute__((__section__(".initcall" level ".init"))) = fn
 
-#define core_initcall(fn)              __define_initcall("1",fn)
-#define postcore_initcall(fn)          __define_initcall("2",fn)
-#define arch_initcall(fn)              __define_initcall("3",fn)
-#define subsys_initcall(fn)            __define_initcall("4",fn)
-#define fs_initcall(fn)                        __define_initcall("5",fn)
-#define device_initcall(fn)            __define_initcall("6",fn)
-#define late_initcall(fn)              __define_initcall("7",fn)
+#define core_initcall(fn)              __define_initcall("1",fn,1)
+#define core_initcall_sync(fn)         __define_initcall("1s",fn,1s)
+#define postcore_initcall(fn)          __define_initcall("2",fn,2)
+#define postcore_initcall_sync(fn)     __define_initcall("2s",fn,2s)
+#define arch_initcall(fn)              __define_initcall("3",fn,3)
+#define arch_initcall_sync(fn)         __define_initcall("3s",fn,3s)
+#define subsys_initcall(fn)            __define_initcall("4",fn,4)
+#define subsys_initcall_sync(fn)       __define_initcall("4s",fn,4s)
+#define fs_initcall(fn)                        __define_initcall("5",fn,5)
+#define fs_initcall_sync(fn)           __define_initcall("5s",fn,5s)
+#define device_initcall(fn)            __define_initcall("6",fn,6)
+#define device_initcall_sync(fn)       __define_initcall("6s",fn,6s)
+#define late_initcall(fn)              __define_initcall("7",fn,7)
+#define late_initcall_sync(fn)         __define_initcall("7s",fn,7s)
 
 #define __initcall(fn) device_initcall(fn)