1 files changed, 44 insertions, 114 deletions
diff --git a/kernel/rcupdate.c b/kernel/rcupdate.c
index 400183346ad2..63fe25433980 100644
--- a/kernel/rcupdate.c
+++ b/kernel/rcupdate.c
@@ -45,143 +45,73 @@
 #include <linux/mutex.h>
 #include <linux/module.h>
 #include <linux/kernel_stat.h>
+#include <linux/hardirq.h>
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 static struct lock_class_key rcu_lock_key;
 struct lockdep_map rcu_lock_map =
        STATIC_LOCKDEP_MAP_INIT("rcu_read_lock", &rcu_lock_key);
 EXPORT_SYMBOL_GPL(rcu_lock_map);
-#endif
-int rcu_scheduler_active __read_mostly;
+static struct lock_class_key rcu_bh_lock_key;
+struct lockdep_map rcu_bh_lock_map =
+        STATIC_LOCKDEP_MAP_INIT("rcu_read_lock_bh", &rcu_bh_lock_key);
+EXPORT_SYMBOL_GPL(rcu_bh_lock_map);
-/*
+static struct lock_class_key rcu_sched_lock_key;
- * Awaken the corresponding synchronize_rcu() instance now that a
+struct lockdep_map rcu_sched_lock_map =
- * grace period has elapsed.
+        STATIC_LOCKDEP_MAP_INIT("rcu_read_lock_sched", &rcu_sched_lock_key);
- */
+EXPORT_SYMBOL_GPL(rcu_sched_lock_map);
-void wakeme_after_rcu(struct rcu_head  *head)
+#endif
-{
-        struct rcu_synchronize *rcu;
-        rcu = container_of(head, struct rcu_synchronize, head);
+int rcu_scheduler_active __read_mostly;
-        complete(&rcu->completion);
+EXPORT_SYMBOL_GPL(rcu_scheduler_active);
-}
-#ifdef CONFIG_TREE_PREEMPT_RCU
+#ifdef CONFIG_DEBUG_LOCK_ALLOC
 /**
- * synchronize_rcu - wait until a grace period has elapsed.
+ * rcu_read_lock_bh_held - might we be in RCU-bh read-side critical section?
+ *
+ * Check for bottom half being disabled, which covers both the
+ * CONFIG_PROVE_RCU and not cases.  Note that if someone uses
+ * rcu_read_lock_bh(), but then later enables BH, lockdep (if enabled)
+ * will show the situation.
 *
- * Control will return to the caller some time after a full grace
+ * Check debug_lockdep_rcu_enabled() to prevent false positives during boot.
- * period has elapsed, in other words after all currently executing RCU
- * read-side critical sections have completed.  RCU read-side critical
- * sections are delimited by rcu_read_lock() and rcu_read_unlock(),
- * and may be nested.
 */
-void synchronize_rcu(void)
+int rcu_read_lock_bh_held(void)
 {
-        struct rcu_synchronize rcu;
+        if (!debug_lockdep_rcu_enabled())
+                return 1;
-        if (!rcu_scheduler_active)
+        return in_softirq();
-                return;
-        init_completion(&rcu.completion);
-        /* Will wake me after RCU finished. */
-        call_rcu(&rcu.head, wakeme_after_rcu);
-        /* Wait for it. */
-        wait_for_completion(&rcu.completion);
 }
-EXPORT_SYMBOL_GPL(synchronize_rcu);
+EXPORT_SYMBOL_GPL(rcu_read_lock_bh_held);
-#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */
+#endif /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
-/**
+/*
- * synchronize_sched - wait until an rcu-sched grace period has elapsed.
+ * This function is invoked towards the end of the scheduler's initialization
- *
+ * process.  Before this is called, the idle task might contain
- * Control will return to the caller some time after a full rcu-sched
+ * RCU read-side critical sections (during which time, this idle
- * grace period has elapsed, in other words after all currently executing
+ * task is booting the system).  After this function is called, the
- * rcu-sched read-side critical sections have completed.   These read-side
+ * idle tasks are prohibited from containing RCU read-side critical
- * critical sections are delimited by rcu_read_lock_sched() and
+ * sections.
- * rcu_read_unlock_sched(), and may be nested.  Note that preempt_disable(),
- * local_irq_disable(), and so on may be used in place of
- * rcu_read_lock_sched().
- *
- * This means that all preempt_disable code sequences, including NMI and
- * hardware-interrupt handlers, in progress on entry will have completed
- * before this primitive returns.  However, this does not guarantee that
- * softirq handlers will have completed, since in some kernels, these
- * handlers can run in process context, and can block.
- *
- * This primitive provides the guarantees made by the (now removed)
- * synchronize_kernel() API.  In contrast, synchronize_rcu() only
- * guarantees that rcu_read_lock() sections will have completed.
- * In "classic RCU", these two guarantees happen to be one and
- * the same, but can differ in realtime RCU implementations.
 */
-void synchronize_sched(void)
+void rcu_scheduler_starting(void)
 {
-        struct rcu_synchronize rcu;
+        WARN_ON(num_online_cpus() != 1);
+        WARN_ON(nr_context_switches() > 0);
-        if (rcu_blocking_is_gp())
+        rcu_scheduler_active = 1;
-                return;
-        init_completion(&rcu.completion);
-        /* Will wake me after RCU finished. */
-        call_rcu_sched(&rcu.head, wakeme_after_rcu);
-        /* Wait for it. */
-        wait_for_completion(&rcu.completion);
 }
-EXPORT_SYMBOL_GPL(synchronize_sched);
-/**
+/*
- * synchronize_rcu_bh - wait until an rcu_bh grace period has elapsed.
+ * Awaken the corresponding synchronize_rcu() instance now that a
- *
+ * grace period has elapsed.
- * Control will return to the caller some time after a full rcu_bh grace
- * period has elapsed, in other words after all currently executing rcu_bh
- * read-side critical sections have completed.  RCU read-side critical
- * sections are delimited by rcu_read_lock_bh() and rcu_read_unlock_bh(),
- * and may be nested.
 */
-void synchronize_rcu_bh(void)
+void wakeme_after_rcu(struct rcu_head  *head)
-{
-        struct rcu_synchronize rcu;
-        if (rcu_blocking_is_gp())
-                return;
-        init_completion(&rcu.completion);
-        /* Will wake me after RCU finished. */
-        call_rcu_bh(&rcu.head, wakeme_after_rcu);
-        /* Wait for it. */
-        wait_for_completion(&rcu.completion);
-}
-EXPORT_SYMBOL_GPL(synchronize_rcu_bh);
-static int __cpuinit rcu_barrier_cpu_hotplug(struct notifier_block *self,
-                unsigned long action, void *hcpu)
-{
-        return rcu_cpu_notify(self, action, hcpu);
-}
-void __init rcu_init(void)
 {
-        int i;
+        struct rcu_synchronize *rcu;
-        __rcu_init();
-        cpu_notifier(rcu_barrier_cpu_hotplug, 0);
-        /*
-         * We don't need protection against CPU-hotplug here because
-         * this is called early in boot, before either interrupts
-         * or the scheduler are operational.
-         */
-        for_each_online_cpu(i)
-                rcu_barrier_cpu_hotplug(NULL, CPU_UP_PREPARE, (void *)(long)i);
-}
-void rcu_scheduler_starting(void)
+        rcu = container_of(head, struct rcu_synchronize, head);
-{
+        complete(&rcu->completion);
-        WARN_ON(num_online_cpus() != 1);
-        WARN_ON(nr_context_switches() > 0);
-        rcu_scheduler_active = 1;
 }

diff --git a/kernel/rcupdate.c b/kernel/rcupdate.c index 400183346ad2..63fe25433980 100644 --- a/kernel/rcupdate.c +++ b/kernel/rcupdate.c
@@ -45,143 +45,73 @@
45	#include <linux/mutex.h>	45	#include <linux/mutex.h>
46	#include <linux/module.h>	46	#include <linux/module.h>
47	#include <linux/kernel_stat.h>	47	#include <linux/kernel_stat.h>
		48	#include <linux/hardirq.h>
48		49
49	#ifdef CONFIG_DEBUG_LOCK_ALLOC	50	#ifdef CONFIG_DEBUG_LOCK_ALLOC
50	static struct lock_class_key rcu_lock_key;	51	static struct lock_class_key rcu_lock_key;
51	struct lockdep_map rcu_lock_map =	52	struct lockdep_map rcu_lock_map =
52	STATIC_LOCKDEP_MAP_INIT("rcu_read_lock", &rcu_lock_key);	53	STATIC_LOCKDEP_MAP_INIT("rcu_read_lock", &rcu_lock_key);
53	EXPORT_SYMBOL_GPL(rcu_lock_map);	54	EXPORT_SYMBOL_GPL(rcu_lock_map);
54	#endif
55		55
56	int rcu_scheduler_active __read_mostly;	56	static struct lock_class_key rcu_bh_lock_key;
		57	struct lockdep_map rcu_bh_lock_map =
		58	STATIC_LOCKDEP_MAP_INIT("rcu_read_lock_bh", &rcu_bh_lock_key);
		59	EXPORT_SYMBOL_GPL(rcu_bh_lock_map);
57		60
58	/*	61	static struct lock_class_key rcu_sched_lock_key;
59	* Awaken the corresponding synchronize_rcu() instance now that a	62	struct lockdep_map rcu_sched_lock_map =
60	* grace period has elapsed.	63	STATIC_LOCKDEP_MAP_INIT("rcu_read_lock_sched", &rcu_sched_lock_key);
61	*/	64	EXPORT_SYMBOL_GPL(rcu_sched_lock_map);
62	void wakeme_after_rcu(struct rcu_head *head)	65	#endif
63	{
64	struct rcu_synchronize *rcu;
65		66
66	rcu = container_of(head, struct rcu_synchronize, head);	67	int rcu_scheduler_active __read_mostly;
67	complete(&rcu->completion);	68	EXPORT_SYMBOL_GPL(rcu_scheduler_active);
68	}
69		69
70	#ifdef CONFIG_TREE_PREEMPT_RCU	70	#ifdef CONFIG_DEBUG_LOCK_ALLOC
71		71
72	/**	72	/**
73	* synchronize_rcu - wait until a grace period has elapsed.	73	* rcu_read_lock_bh_held - might we be in RCU-bh read-side critical section?
		74	*
		75	* Check for bottom half being disabled, which covers both the
		76	* CONFIG_PROVE_RCU and not cases. Note that if someone uses
		77	* rcu_read_lock_bh(), but then later enables BH, lockdep (if enabled)
		78	* will show the situation.
74	*	79	*
75	* Control will return to the caller some time after a full grace	80	* Check debug_lockdep_rcu_enabled() to prevent false positives during boot.
76	* period has elapsed, in other words after all currently executing RCU
77	* read-side critical sections have completed. RCU read-side critical
78	* sections are delimited by rcu_read_lock() and rcu_read_unlock(),
79	* and may be nested.
80	*/	81	*/
81	void synchronize_rcu(void)	82	int rcu_read_lock_bh_held(void)
82	{	83	{
83	struct rcu_synchronize rcu;	84	if (!debug_lockdep_rcu_enabled())
84		85	return 1;
85	if (!rcu_scheduler_active)	86	return in_softirq();
86	return;
87
88	init_completion(&rcu.completion);
89	/* Will wake me after RCU finished. */
90	call_rcu(&rcu.head, wakeme_after_rcu);
91	/* Wait for it. */
92	wait_for_completion(&rcu.completion);
93	}	87	}
94	EXPORT_SYMBOL_GPL(synchronize_rcu);	88	EXPORT_SYMBOL_GPL(rcu_read_lock_bh_held);
95		89
96	#endif /* #ifdef CONFIG_TREE_PREEMPT_RCU */	90	#endif /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
97		91
98	/**	92	/*
99	* synchronize_sched - wait until an rcu-sched grace period has elapsed.	93	* This function is invoked towards the end of the scheduler's initialization
100	*	94	* process. Before this is called, the idle task might contain
101	* Control will return to the caller some time after a full rcu-sched	95	* RCU read-side critical sections (during which time, this idle
102	* grace period has elapsed, in other words after all currently executing	96	* task is booting the system). After this function is called, the
103	* rcu-sched read-side critical sections have completed. These read-side	97	* idle tasks are prohibited from containing RCU read-side critical
104	* critical sections are delimited by rcu_read_lock_sched() and	98	* sections.
105	* rcu_read_unlock_sched(), and may be nested. Note that preempt_disable(),
106	* local_irq_disable(), and so on may be used in place of
107	* rcu_read_lock_sched().
108	*
109	* This means that all preempt_disable code sequences, including NMI and
110	* hardware-interrupt handlers, in progress on entry will have completed
111	* before this primitive returns. However, this does not guarantee that
112	* softirq handlers will have completed, since in some kernels, these
113	* handlers can run in process context, and can block.
114	*
115	* This primitive provides the guarantees made by the (now removed)
116	* synchronize_kernel() API. In contrast, synchronize_rcu() only
117	* guarantees that rcu_read_lock() sections will have completed.
118	* In "classic RCU", these two guarantees happen to be one and
119	* the same, but can differ in realtime RCU implementations.
120	*/	99	*/
121	void synchronize_sched(void)	100	void rcu_scheduler_starting(void)
122	{	101	{
123	struct rcu_synchronize rcu;	102	WARN_ON(num_online_cpus() != 1);
124		103	WARN_ON(nr_context_switches() > 0);
125	if (rcu_blocking_is_gp())	104	rcu_scheduler_active = 1;
126	return;
127
128	init_completion(&rcu.completion);
129	/* Will wake me after RCU finished. */
130	call_rcu_sched(&rcu.head, wakeme_after_rcu);
131	/* Wait for it. */
132	wait_for_completion(&rcu.completion);
133	}	105	}
134	EXPORT_SYMBOL_GPL(synchronize_sched);
135		106
136	/**	107	/*
137	* synchronize_rcu_bh - wait until an rcu_bh grace period has elapsed.	108	* Awaken the corresponding synchronize_rcu() instance now that a
138	*	109	* grace period has elapsed.
139	* Control will return to the caller some time after a full rcu_bh grace
140	* period has elapsed, in other words after all currently executing rcu_bh
141	* read-side critical sections have completed. RCU read-side critical
142	* sections are delimited by rcu_read_lock_bh() and rcu_read_unlock_bh(),
143	* and may be nested.
144	*/	110	*/
145	void synchronize_rcu_bh(void)	111	void wakeme_after_rcu(struct rcu_head *head)
146	{
147	struct rcu_synchronize rcu;
148
149	if (rcu_blocking_is_gp())
150	return;
151
152	init_completion(&rcu.completion);
153	/* Will wake me after RCU finished. */
154	call_rcu_bh(&rcu.head, wakeme_after_rcu);
155	/* Wait for it. */
156	wait_for_completion(&rcu.completion);
157	}
158	EXPORT_SYMBOL_GPL(synchronize_rcu_bh);
159
160	static int __cpuinit rcu_barrier_cpu_hotplug(struct notifier_block *self,
161	unsigned long action, void *hcpu)
162	{
163	return rcu_cpu_notify(self, action, hcpu);
164	}
165
166	void __init rcu_init(void)
167	{	112	{
168	int i;	113	struct rcu_synchronize *rcu;
169
170	__rcu_init();
171	cpu_notifier(rcu_barrier_cpu_hotplug, 0);
172
173	/*
174	* We don't need protection against CPU-hotplug here because
175	* this is called early in boot, before either interrupts
176	* or the scheduler are operational.
177	*/
178	for_each_online_cpu(i)
179	rcu_barrier_cpu_hotplug(NULL, CPU_UP_PREPARE, (void *)(long)i);
180	}
181		114
182	void rcu_scheduler_starting(void)	115	rcu = container_of(head, struct rcu_synchronize, head);
183	{	116	complete(&rcu->completion);
184	WARN_ON(num_online_cpus() != 1);
185	WARN_ON(nr_context_switches() > 0);
186	rcu_scheduler_active = 1;
187	}	117	}