137 lines
4.6 KiB
Diff
137 lines
4.6 KiB
Diff
From ac9103dd8e4dc65c110d6cba9a3380c6c617ffa7 Mon Sep 17 00:00:00 2001
|
|
From: Arjan van de Ven <arjan@linux.intel.com>
|
|
Date: Fri, 18 Jul 2008 15:16:08 -0700
|
|
Subject: [PATCH] fastboot: create a "asynchronous" initlevel
|
|
|
|
This patch creates an asynchronous initlevel (6a) which is at the same
|
|
level as the normal device initcalls, but with the difference that they
|
|
are run asynchronous from all the other initcalls. The purpose of this
|
|
*selective* level is that we can move long waiting inits that are not
|
|
boot-critical to this level one at a time.
|
|
|
|
To keep things not totally insane, the asynchronous initcalls are async
|
|
to the other initcalls, but are still ordered to themselves; think of it
|
|
as "bottom-half-not-softirq". This has the benefit that async drivers
|
|
still have stable device ordering between them.
|
|
|
|
Signed-off-by: Arjan van de Ven <arjan@linux.intel.com>
|
|
Signed-off-by: Ingo Molnar <mingo@elte.hu>
|
|
---
|
|
include/asm-generic/vmlinux.lds.h | 3 +++
|
|
include/linux/init.h | 6 ++++++
|
|
init/main.c | 36 +++++++++++++++++++++++++++++++++---
|
|
3 files changed, 42 insertions(+), 3 deletions(-)
|
|
|
|
diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h
|
|
index 729f6b0..39c1afc 100644
|
|
--- a/include/asm-generic/vmlinux.lds.h
|
|
+++ b/include/asm-generic/vmlinux.lds.h
|
|
@@ -372,6 +372,9 @@
|
|
*(.initcall5.init) \
|
|
*(.initcall5s.init) \
|
|
*(.initcallrootfs.init) \
|
|
+ __async_initcall_start = .; \
|
|
+ *(.initcall6a.init) \
|
|
+ __async_initcall_end = .; \
|
|
*(.initcall6.init) \
|
|
*(.initcall6s.init) \
|
|
*(.initcall7.init) \
|
|
diff --git a/include/linux/init.h b/include/linux/init.h
|
|
index 21d658c..75db909 100644
|
|
--- a/include/linux/init.h
|
|
+++ b/include/linux/init.h
|
|
@@ -197,11 +197,13 @@
|
|
#define fs_initcall_sync(fn) __define_initcall("5s",fn,5s)
|
|
#define rootfs_initcall(fn) __define_initcall("rootfs",fn,rootfs)
|
|
#define device_initcall(fn) __define_initcall("6",fn,6)
|
|
+#define device_initcall_async(fn) __define_initcall("6a", fn, 6a)
|
|
#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)
|
|
+#define __initcall_async(fn) device_initcall_async(fn)
|
|
|
|
#define __exitcall(fn) \
|
|
static exitcall_t __exitcall_##fn __exit_call = fn
|
|
@@ -257,6 +259,7 @@
|
|
* be one per module.
|
|
*/
|
|
#define module_init(x) __initcall(x);
|
|
+#define module_init_async(x) __initcall_async(x);
|
|
|
|
/**
|
|
* module_exit() - driver exit entry point
|
|
@@ -279,10 +282,13 @@
|
|
#define subsys_initcall(fn) module_init(fn)
|
|
#define fs_initcall(fn) module_init(fn)
|
|
#define device_initcall(fn) module_init(fn)
|
|
+#define device_initcall_async(fn) module_init(fn)
|
|
#define late_initcall(fn) module_init(fn)
|
|
|
|
#define security_initcall(fn) module_init(fn)
|
|
|
|
+#define module_init_async(fn) module_init(fn)
|
|
+
|
|
/* Each module must use one module_init(). */
|
|
#define module_init(initfn) \
|
|
static inline initcall_t __inittest(void) \
|
|
diff --git a/init/main.c b/init/main.c
|
|
index edeace0..6961de2 100644
|
|
--- a/init/main.c
|
|
+++ b/init/main.c
|
|
@@ -746,18 +746,47 @@
|
|
|
|
|
|
extern initcall_t __initcall_start[], __initcall_end[], __early_initcall_end[];
|
|
+extern initcall_t __async_initcall_start[], __async_initcall_end[];
|
|
|
|
-static void __init do_initcalls(void)
|
|
+static void __init do_async_initcalls(struct work_struct *dummy)
|
|
{
|
|
initcall_t *call;
|
|
|
|
- for (call = __early_initcall_end; call < __initcall_end; call++)
|
|
+ for (call = __async_initcall_start; call < __async_initcall_end; call++)
|
|
do_one_initcall(*call);
|
|
+}
|
|
+
|
|
+static struct workqueue_struct *async_init_wq;
|
|
+
|
|
+static void __init do_initcalls(void)
|
|
+{
|
|
+ initcall_t *call;
|
|
+ static DECLARE_WORK(async_work, do_async_initcalls);
|
|
+ int phase = 0; /* 0 = levels 0 - 6, 1 = level 6a, 2 = after level 6a */
|
|
+
|
|
+ async_init_wq = create_singlethread_workqueue("kasyncinit");
|
|
+
|
|
+ for (call = __early_initcall_end; call < __initcall_end; call++) {
|
|
+ if (phase == 0 && call >= __async_initcall_start) {
|
|
+ phase = 1;
|
|
+ queue_work(async_init_wq, &async_work);
|
|
+ }
|
|
+ if (phase == 1 && call >= __async_initcall_end)
|
|
+ phase = 2;
|
|
+ if (phase != 1)
|
|
+ do_one_initcall(*call);
|
|
+ }
|
|
|
|
- /* Make sure there is no pending stuff from the initcall sequence */
|
|
+ /*
|
|
+ * Make sure there is no pending stuff from the initcall sequence,
|
|
+ * including the async initcalls
|
|
+ */
|
|
flush_scheduled_work();
|
|
+ flush_workqueue(async_init_wq);
|
|
+ destroy_workqueue(async_init_wq);
|
|
}
|
|
|
|
+
|
|
/*
|
|
* Ok, the machine is now initialized. None of the devices
|
|
* have been touched yet, but the CPU subsystem is up and
|
|
--
|
|
1.5.4.3
|
|
|