kmemtrace, rcu: fix linux/rcutree.h and linux/rcuclassic.h dependencies

Impact: build fix for all non-x86 architectures We want to remove percpu.h from rcuclassic.h/rcutree.h (for upcoming kmemtrace changes) but that would break the DECLARE_PER_CPU based declarations in these files. Move the quiescent counter management functions to their respective RCU implementation .c files - they were slightly above the inlining limit anyway. Cc: Pekka Enberg <penberg@cs.helsinki.fi> Cc: Eduard - Gabriel Munteanu <eduard.munteanu@linux360.ro> Cc: paulmck@linux.vnet.ibm.com LKML-Reference: <1237898630.25315.83.camel@penberg-laptop> Signed-off-by: Ingo Molnar <mingo@elte.hu>

kmemtrace, rcu: fix linux/rcutree.h and linux/rcuclassic.h dependencies
Impact: build fix for all non-x86 architectures We want to remove percpu.h from rcuclassic.h/rcutree.h (for upcoming kmemtrace changes) but that would break the DECLARE_PER_CPU based declarations in these files. Move the quiescent counter management functions to their respective RCU implementation .c files - they were slightly above the inlining limit anyway. Cc: Pekka Enberg <penberg@cs.helsinki.fi> Cc: Eduard - Gabriel Munteanu <eduard.munteanu@linux360.ro> Cc: paulmck@linux.vnet.ibm.com LKML-Reference: <1237898630.25315.83.camel@penberg-laptop> Signed-off-by: Ingo Molnar <mingo@elte.hu>
Ingo Molnar
1 parent 255d11bc91
Showing 4 changed files with 49 additions and 43 deletions Side-by-side Diff
include/linux/rcuclassic.h
include/linux/rcutree.h
kernel/rcuclassic.c
kernel/rcutree.c
@@ -108,25 +108,14 @@
 	struct rcu_head barrier;
 };
  
-DECLARE_PER_CPU(struct rcu_data, rcu_data);
-DECLARE_PER_CPU(struct rcu_data, rcu_bh_data);
-
 /*
  * Increment the quiescent state counter.
  * The counter is a bit degenerated: We do not need to know
  * how many quiescent states passed, just if there was at least
  * one since the start of the grace period. Thus just a flag.
  */
-static inline void rcu_qsctr_inc(int cpu)
-{
-	struct rcu_data *rdp = &per_cpu(rcu_data, cpu);
-	rdp->passed_quiesc = 1;
-}
-static inline void rcu_bh_qsctr_inc(int cpu)
-{
-	struct rcu_data *rdp = &per_cpu(rcu_bh_data, cpu);
-	rdp->passed_quiesc = 1;
-}
+extern void rcu_qsctr_inc(int cpu);
+extern void rcu_bh_qsctr_inc(int cpu);
  
 extern int rcu_pending(int cpu);
 extern int rcu_needs_cpu(int cpu);
@@ -236,30 +236,8 @@
 #endif /* #ifdef CONFIG_NO_HZ */
 };
  
-extern struct rcu_state rcu_state;
-DECLARE_PER_CPU(struct rcu_data, rcu_data);
-
-extern struct rcu_state rcu_bh_state;
-DECLARE_PER_CPU(struct rcu_data, rcu_bh_data);
-
-/*
- * Increment the quiescent state counter.
- * The counter is a bit degenerated: We do not need to know
- * how many quiescent states passed, just if there was at least
- * one since the start of the grace period. Thus just a flag.
- */
-static inline void rcu_qsctr_inc(int cpu)
-{
-	struct rcu_data *rdp = &per_cpu(rcu_data, cpu);
-	rdp->passed_quiesc = 1;
-	rdp->passed_quiesc_completed = rdp->completed;
-}
-static inline void rcu_bh_qsctr_inc(int cpu)
-{
-	struct rcu_data *rdp = &per_cpu(rcu_bh_data, cpu);
-	rdp->passed_quiesc = 1;
-	rdp->passed_quiesc_completed = rdp->completed;
-}
+extern void rcu_qsctr_inc(int cpu);
+extern void rcu_bh_qsctr_inc(int cpu);
  
 extern int rcu_pending(int cpu);
 extern int rcu_needs_cpu(int cpu);
@@ -65,6 +65,7 @@
 	.lock = __SPIN_LOCK_UNLOCKED(&rcu_ctrlblk.lock),
 	.cpumask = CPU_BITS_NONE,
 };
+
 static struct rcu_ctrlblk rcu_bh_ctrlblk = {
 	.cur = -300,
 	.completed = -300,
@@ -73,8 +74,26 @@
 	.cpumask = CPU_BITS_NONE,
 };
  
-DEFINE_PER_CPU(struct rcu_data, rcu_data) = { 0L };
-DEFINE_PER_CPU(struct rcu_data, rcu_bh_data) = { 0L };
+static DEFINE_PER_CPU(struct rcu_data, rcu_data);
+static DEFINE_PER_CPU(struct rcu_data, rcu_bh_data);
+
+/*
+ * Increment the quiescent state counter.
+ * The counter is a bit degenerated: We do not need to know
+ * how many quiescent states passed, just if there was at least
+ * one since the start of the grace period. Thus just a flag.
+ */
+void rcu_qsctr_inc(int cpu)
+{
+	struct rcu_data *rdp = &per_cpu(rcu_data, cpu);
+	rdp->passed_quiesc = 1;
+}
+
+void rcu_bh_qsctr_inc(int cpu)
+{
+	struct rcu_data *rdp = &per_cpu(rcu_bh_data, cpu);
+	rdp->passed_quiesc = 1;
+}
  
 static int blimit = 10;
 static int qhimark = 10000;
@@ -72,11 +72,31 @@
 	.n_force_qs_ngp = 0, \
 }
  
-struct rcu_state rcu_state = RCU_STATE_INITIALIZER(rcu_state);
-DEFINE_PER_CPU(struct rcu_data, rcu_data);
+static struct rcu_state rcu_state = RCU_STATE_INITIALIZER(rcu_state);
+static DEFINE_PER_CPU(struct rcu_data, rcu_data);
  
-struct rcu_state rcu_bh_state = RCU_STATE_INITIALIZER(rcu_bh_state);
-DEFINE_PER_CPU(struct rcu_data, rcu_bh_data);
+static struct rcu_state rcu_bh_state = RCU_STATE_INITIALIZER(rcu_bh_state);
+static DEFINE_PER_CPU(struct rcu_data, rcu_bh_data);
+
+/*
+ * Increment the quiescent state counter.
+ * The counter is a bit degenerated: We do not need to know
+ * how many quiescent states passed, just if there was at least
+ * one since the start of the grace period. Thus just a flag.
+ */
+void rcu_qsctr_inc(int cpu)
+{
+	struct rcu_data *rdp = &per_cpu(rcu_data, cpu);
+	rdp->passed_quiesc = 1;
+	rdp->passed_quiesc_completed = rdp->completed;
+}
+
+void rcu_bh_qsctr_inc(int cpu)
+{
+	struct rcu_data *rdp = &per_cpu(rcu_bh_data, cpu);
+	rdp->passed_quiesc = 1;
+	rdp->passed_quiesc_completed = rdp->completed;
+}
  
 #ifdef CONFIG_NO_HZ
 DEFINE_PER_CPU(struct rcu_dynticks, rcu_dynticks) = {
...	...	@@ -108,25 +108,14 @@
108	108	struct rcu_head barrier;
109	109	};
110	110
111		-DECLARE_PER_CPU(struct rcu_data, rcu_data);
112		-DECLARE_PER_CPU(struct rcu_data, rcu_bh_data);
113		-
114	111	/*
115	112	* Increment the quiescent state counter.
116	113	* The counter is a bit degenerated: We do not need to know
117	114	* how many quiescent states passed, just if there was at least
118	115	* one since the start of the grace period. Thus just a flag.
119	116	*/
120		-static inline void rcu_qsctr_inc(int cpu)
121		-{
122		- struct rcu_data *rdp = &per_cpu(rcu_data, cpu);
123		- rdp->passed_quiesc = 1;
124		-}
125		-static inline void rcu_bh_qsctr_inc(int cpu)
126		-{
127		- struct rcu_data *rdp = &per_cpu(rcu_bh_data, cpu);
128		- rdp->passed_quiesc = 1;
129		-}
	117	+extern void rcu_qsctr_inc(int cpu);
	118	+extern void rcu_bh_qsctr_inc(int cpu);
130	119
131	120	extern int rcu_pending(int cpu);
132	121	extern int rcu_needs_cpu(int cpu);
...	...	@@ -236,30 +236,8 @@
236	236	#endif /* #ifdef CONFIG_NO_HZ */
237	237	};
238	238
239		-extern struct rcu_state rcu_state;
240		-DECLARE_PER_CPU(struct rcu_data, rcu_data);
241		-
242		-extern struct rcu_state rcu_bh_state;
243		-DECLARE_PER_CPU(struct rcu_data, rcu_bh_data);
244		-
245		-/*
246		- * Increment the quiescent state counter.
247		- * The counter is a bit degenerated: We do not need to know
248		- * how many quiescent states passed, just if there was at least
249		- * one since the start of the grace period. Thus just a flag.
250		- */
251		-static inline void rcu_qsctr_inc(int cpu)
252		-{
253		- struct rcu_data *rdp = &per_cpu(rcu_data, cpu);
254		- rdp->passed_quiesc = 1;
255		- rdp->passed_quiesc_completed = rdp->completed;
256		-}
257		-static inline void rcu_bh_qsctr_inc(int cpu)
258		-{
259		- struct rcu_data *rdp = &per_cpu(rcu_bh_data, cpu);
260		- rdp->passed_quiesc = 1;
261		- rdp->passed_quiesc_completed = rdp->completed;
262		-}
	239	+extern void rcu_qsctr_inc(int cpu);
	240	+extern void rcu_bh_qsctr_inc(int cpu);
263	241
264	242	extern int rcu_pending(int cpu);
265	243	extern int rcu_needs_cpu(int cpu);
...	...	@@ -65,6 +65,7 @@
65	65	.lock = __SPIN_LOCK_UNLOCKED(&rcu_ctrlblk.lock),
66	66	.cpumask = CPU_BITS_NONE,
67	67	};
	68	+
68	69	static struct rcu_ctrlblk rcu_bh_ctrlblk = {
69	70	.cur = -300,
70	71	.completed = -300,
...	...	@@ -73,8 +74,26 @@
73	74	.cpumask = CPU_BITS_NONE,
74	75	};
75	76
76		-DEFINE_PER_CPU(struct rcu_data, rcu_data) = { 0L };
77		-DEFINE_PER_CPU(struct rcu_data, rcu_bh_data) = { 0L };
	77	+static DEFINE_PER_CPU(struct rcu_data, rcu_data);
	78	+static DEFINE_PER_CPU(struct rcu_data, rcu_bh_data);
	79	+
	80	+/*
	81	+ * Increment the quiescent state counter.
	82	+ * The counter is a bit degenerated: We do not need to know
	83	+ * how many quiescent states passed, just if there was at least
	84	+ * one since the start of the grace period. Thus just a flag.
	85	+ */
	86	+void rcu_qsctr_inc(int cpu)
	87	+{
	88	+ struct rcu_data *rdp = &per_cpu(rcu_data, cpu);
	89	+ rdp->passed_quiesc = 1;
	90	+}
	91	+
	92	+void rcu_bh_qsctr_inc(int cpu)
	93	+{
	94	+ struct rcu_data *rdp = &per_cpu(rcu_bh_data, cpu);
	95	+ rdp->passed_quiesc = 1;
	96	+}
78	97
79	98	static int blimit = 10;
80	99	static int qhimark = 10000;
...	...	@@ -72,11 +72,31 @@
72	72	.n_force_qs_ngp = 0, \
73	73	}
74	74
75		-struct rcu_state rcu_state = RCU_STATE_INITIALIZER(rcu_state);
76		-DEFINE_PER_CPU(struct rcu_data, rcu_data);
	75	+static struct rcu_state rcu_state = RCU_STATE_INITIALIZER(rcu_state);
	76	+static DEFINE_PER_CPU(struct rcu_data, rcu_data);
77	77
78		-struct rcu_state rcu_bh_state = RCU_STATE_INITIALIZER(rcu_bh_state);
79		-DEFINE_PER_CPU(struct rcu_data, rcu_bh_data);
	78	+static struct rcu_state rcu_bh_state = RCU_STATE_INITIALIZER(rcu_bh_state);
	79	+static DEFINE_PER_CPU(struct rcu_data, rcu_bh_data);
	80	+
	81	+/*
	82	+ * Increment the quiescent state counter.
	83	+ * The counter is a bit degenerated: We do not need to know
	84	+ * how many quiescent states passed, just if there was at least
	85	+ * one since the start of the grace period. Thus just a flag.
	86	+ */
	87	+void rcu_qsctr_inc(int cpu)
	88	+{
	89	+ struct rcu_data *rdp = &per_cpu(rcu_data, cpu);
	90	+ rdp->passed_quiesc = 1;
	91	+ rdp->passed_quiesc_completed = rdp->completed;
	92	+}
	93	+
	94	+void rcu_bh_qsctr_inc(int cpu)
	95	+{
	96	+ struct rcu_data *rdp = &per_cpu(rcu_bh_data, cpu);
	97	+ rdp->passed_quiesc = 1;
	98	+ rdp->passed_quiesc_completed = rdp->completed;
	99	+}
80	100
81	101	#ifdef CONFIG_NO_HZ
82	102	DEFINE_PER_CPU(struct rcu_dynticks, rcu_dynticks) = {