forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-01-05 071106ecf68c401173c58808b1cf5f68cc50d390 
 kernel/include/linux/rcupdate.h
....@@ -1,25 +1,12 @@
1
+/* SPDX-License-Identifier: GPL-2.0+ */
12 /*
23  * Read-Copy Update mechanism for mutual exclusion
3
- *
4
- * This program is free software; you can redistribute it and/or modify
5
- * it under the terms of the GNU General Public License as published by
6
- * the Free Software Foundation; either version 2 of the License, or
7
- * (at your option) any later version.
8
- *
9
- * This program is distributed in the hope that it will be useful,
10
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
11
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
- * GNU General Public License for more details.
13
- *
14
- * You should have received a copy of the GNU General Public License
15
- * along with this program; if not, you can access it online at
16
- * http://www.gnu.org/licenses/gpl-2.0.html.
174  *
185  * Copyright IBM Corporation, 2001
196  *
207  * Author: Dipankar Sarma <dipankar@in.ibm.com>
218  *
22
- * Based on the original work by Paul McKenney <paulmck@us.ibm.com>
9
+ * Based on the original work by Paul McKenney <paulmck@vnet.ibm.com>
2310  * and inputs from Rusty Russell, Andrea Arcangeli and Andi Kleen.
2411  * Papers:
2512  * http://www.rdrop.com/users/paulmck/paper/rclockpdcsproof.pdf
....@@ -46,25 +33,19 @@
4633 #define ULONG_CMP_GE(a, b)	(ULONG_MAX / 2 >= (a) - (b))
4734 #define ULONG_CMP_LT(a, b)	(ULONG_MAX / 2 < (a) - (b))
4835 #define ulong2long(a)		(*(long *)(&(a)))
36
+#define USHORT_CMP_GE(a, b)	(USHRT_MAX / 2 >= (unsigned short)((a) - (b)))
37
+#define USHORT_CMP_LT(a, b)	(USHRT_MAX / 2 < (unsigned short)((a) - (b)))
4938 
5039 /* Exported common interfaces */
51
-
52
-#ifdef CONFIG_PREEMPT_RCU
5340 void call_rcu(struct rcu_head *head, rcu_callback_t func);
54
-#else /* #ifdef CONFIG_PREEMPT_RCU */
55
-#define	call_rcu	call_rcu_sched
56
-#endif /* #else #ifdef CONFIG_PREEMPT_RCU */
57
-
58
-void call_rcu_bh(struct rcu_head *head, rcu_callback_t func);
59
-void call_rcu_sched(struct rcu_head *head, rcu_callback_t func);
60
-void synchronize_sched(void);
6141 void rcu_barrier_tasks(void);
42
+void rcu_barrier_tasks_rude(void);
43
+void synchronize_rcu(void);
6244 
6345 #ifdef CONFIG_PREEMPT_RCU
6446 
6547 void __rcu_read_lock(void);
6648 void __rcu_read_unlock(void);
67
-void synchronize_rcu(void);
6849 
6950 /*
7051  * Defined as a macro as it is a very low level header included from
....@@ -76,6 +57,12 @@
7657 
7758 #else /* #ifdef CONFIG_PREEMPT_RCU */
7859 
60
+#ifdef CONFIG_TINY_RCU
61
+#define rcu_read_unlock_strict() do { } while (0)
62
+#else
63
+void rcu_read_unlock_strict(void);
64
+#endif
65
+
7966 static inline void __rcu_read_lock(void)
8067 {
8168 	preempt_disable();
....@@ -84,11 +71,7 @@
8471 static inline void __rcu_read_unlock(void)
8572 {
8673 	preempt_enable();
87
-}
88
-
89
-static inline void synchronize_rcu(void)
90
-{
91
-	synchronize_sched();
74
+	rcu_read_unlock_strict();
9275 }
9376 
9477 static inline int rcu_preempt_depth(void)
....@@ -100,12 +83,16 @@
10083 
10184 /* Internal to kernel */
10285 void rcu_init(void);
103
-extern int rcu_scheduler_active __read_mostly;
104
-void rcu_sched_qs(void);
105
-void rcu_bh_qs(void);
106
-void rcu_check_callbacks(int user);
86
+extern int rcu_scheduler_active;
87
+void rcu_sched_clock_irq(int user);
10788 void rcu_report_dead(unsigned int cpu);
10889 void rcutree_migrate_callbacks(int cpu);
90
+
91
+#ifdef CONFIG_TASKS_RCU_GENERIC
92
+void rcu_init_tasks_generic(void);
93
+#else
94
+static inline void rcu_init_tasks_generic(void) { }
95
+#endif
10996 
11097 #ifdef CONFIG_RCU_STALL_COMMON
11198 void rcu_sysrq_start(void);
....@@ -125,19 +112,20 @@
125112 
126113 #ifdef CONFIG_RCU_NOCB_CPU
127114 void rcu_init_nohz(void);
115
+void rcu_nocb_flush_deferred_wakeup(void);
128116 #else /* #ifdef CONFIG_RCU_NOCB_CPU */
129117 static inline void rcu_init_nohz(void) { }
118
+static inline void rcu_nocb_flush_deferred_wakeup(void) { }
130119 #endif /* #else #ifdef CONFIG_RCU_NOCB_CPU */
131120 
132121 /**
133122  * RCU_NONIDLE - Indicate idle-loop code that needs RCU readers
134123  * @a: Code that RCU needs to pay attention to.
135124  *
136
- * RCU, RCU-bh, and RCU-sched read-side critical sections are forbidden
137
- * in the inner idle loop, that is, between the rcu_idle_enter() and
138
- * the rcu_idle_exit() -- RCU will happily ignore any such read-side
139
- * critical sections.  However, things like powertop need tracepoints
140
- * in the inner idle loop.
125
+ * RCU read-side critical sections are forbidden in the inner idle loop,
126
+ * that is, between the rcu_idle_enter() and the rcu_idle_exit() -- RCU
127
+ * will happily ignore any such read-side critical sections.  However,
128
+ * things like powertop need tracepoints in the inner idle loop.
141129  *
142130  * This macro provides the way out:  RCU_NONIDLE(do_something_with_RCU())
143131  * will tell RCU that it needs to pay attention, invoke its argument
....@@ -159,40 +147,70 @@
159147  * Note a quasi-voluntary context switch for RCU-tasks's benefit.
160148  * This is a macro rather than an inline function to avoid #include hell.
161149  */
162
-#ifdef CONFIG_TASKS_RCU
163
-#define rcu_tasks_qs(t) \
164
-	do { \
165
-		if (READ_ONCE((t)->rcu_tasks_holdout)) \
166
-			WRITE_ONCE((t)->rcu_tasks_holdout, false); \
167
-	} while (0)
168
-#define rcu_note_voluntary_context_switch(t) \
169
-	do { \
170
-		rcu_all_qs(); \
171
-		rcu_tasks_qs(t); \
150
+#ifdef CONFIG_TASKS_RCU_GENERIC
151
+
152
+# ifdef CONFIG_TASKS_RCU
153
+# define rcu_tasks_classic_qs(t, preempt)				\
154
+	do {								\
155
+		if (!(preempt) && READ_ONCE((t)->rcu_tasks_holdout))	\
156
+			WRITE_ONCE((t)->rcu_tasks_holdout, false);	\
172157 	} while (0)
173158 void call_rcu_tasks(struct rcu_head *head, rcu_callback_t func);
174159 void synchronize_rcu_tasks(void);
160
+# else
161
+# define rcu_tasks_classic_qs(t, preempt) do { } while (0)
162
+# define call_rcu_tasks call_rcu
163
+# define synchronize_rcu_tasks synchronize_rcu
164
+# endif
165
+
166
+# ifdef CONFIG_TASKS_TRACE_RCU
167
+# define rcu_tasks_trace_qs(t)						\
168
+	do {								\
169
+		if (!likely(READ_ONCE((t)->trc_reader_checked)) &&	\
170
+		    !unlikely(READ_ONCE((t)->trc_reader_nesting))) {	\
171
+			smp_store_release(&(t)->trc_reader_checked, true); \
172
+			smp_mb(); /* Readers partitioned by store. */	\
173
+		}							\
174
+	} while (0)
175
+# else
176
+# define rcu_tasks_trace_qs(t) do { } while (0)
177
+# endif
178
+
179
+#define rcu_tasks_qs(t, preempt)					\
180
+do {									\
181
+	rcu_tasks_classic_qs((t), (preempt));				\
182
+	rcu_tasks_trace_qs((t));					\
183
+} while (0)
184
+
185
+# ifdef CONFIG_TASKS_RUDE_RCU
186
+void call_rcu_tasks_rude(struct rcu_head *head, rcu_callback_t func);
187
+void synchronize_rcu_tasks_rude(void);
188
+# endif
189
+
190
+#define rcu_note_voluntary_context_switch(t) rcu_tasks_qs(t, false)
175191 void exit_tasks_rcu_start(void);
192
+void exit_tasks_rcu_stop(void);
176193 void exit_tasks_rcu_finish(void);
177
-#else /* #ifdef CONFIG_TASKS_RCU */
178
-#define rcu_tasks_qs(t)	do { } while (0)
179
-#define rcu_note_voluntary_context_switch(t)		rcu_all_qs()
180
-#define call_rcu_tasks call_rcu_sched
181
-#define synchronize_rcu_tasks synchronize_sched
194
+#else /* #ifdef CONFIG_TASKS_RCU_GENERIC */
195
+#define rcu_tasks_qs(t, preempt) do { } while (0)
196
+#define rcu_note_voluntary_context_switch(t) do { } while (0)
197
+#define call_rcu_tasks call_rcu
198
+#define synchronize_rcu_tasks synchronize_rcu
182199 static inline void exit_tasks_rcu_start(void) { }
200
+static inline void exit_tasks_rcu_stop(void) { }
183201 static inline void exit_tasks_rcu_finish(void) { }
184
-#endif /* #else #ifdef CONFIG_TASKS_RCU */
202
+#endif /* #else #ifdef CONFIG_TASKS_RCU_GENERIC */
185203 
186204 /**
187205  * cond_resched_tasks_rcu_qs - Report potential quiescent states to RCU
188206  *
189207  * This macro resembles cond_resched(), except that it is defined to
190208  * report potential quiescent states to RCU-tasks even if the cond_resched()
191
- * machinery were to be shut off, as some advocate for PREEMPT kernels.
209
+ * machinery were to be shut off, as some advocate for PREEMPTION kernels.
192210  */
193211 #define cond_resched_tasks_rcu_qs() \
194212 do { \
195
-	rcu_tasks_qs(current); \
213
+	rcu_tasks_qs(current, false); \
196214 	cond_resched(); \
197215 } while (0)
198216 
....@@ -201,7 +219,7 @@
201219  * TREE_RCU and rcu_barrier_() primitives in TINY_RCU.
202220  */
203221 
204
-#if defined(CONFIG_TREE_RCU) || defined(CONFIG_PREEMPT_RCU)
222
+#if defined(CONFIG_TREE_RCU)
205223 #include <linux/rcutree.h>
206224 #elif defined(CONFIG_TINY_RCU)
207225 #include <linux/rcutiny.h>
....@@ -244,7 +262,7 @@
244262 
245263 static inline void rcu_lock_release(struct lockdep_map *map)
246264 {
247
-	lock_release(map, 1, _THIS_IP_);
265
+	lock_release(map, _THIS_IP_);
248266 }
249267 
250268 extern struct lockdep_map rcu_lock_map;
....@@ -255,6 +273,7 @@
255273 int rcu_read_lock_held(void);
256274 int rcu_read_lock_bh_held(void);
257275 int rcu_read_lock_sched_held(void);
276
+int rcu_read_lock_any_held(void);
258277 
259278 #else /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
260279 
....@@ -275,6 +294,12 @@
275294 {
276295 	return !preemptible();
277296 }
297
+
298
+static inline int rcu_read_lock_any_held(void)
299
+{
300
+	return !preemptible();
301
+}
302
+
278303 #endif /* #else #ifdef CONFIG_DEBUG_LOCK_ALLOC */
279304 
280305 #ifdef CONFIG_PROVE_RCU
....@@ -283,11 +308,18 @@
283308  * RCU_LOCKDEP_WARN - emit lockdep splat if specified condition is met
284309  * @c: condition to check
285310  * @s: informative message
311
+ *
312
+ * This checks debug_lockdep_rcu_enabled() before checking (c) to
313
+ * prevent early boot splats due to lockdep not yet being initialized,
314
+ * and rechecks it after checking (c) to prevent false-positive splats
315
+ * due to races with lockdep being disabled.  See commit 3066820034b5dd
316
+ * ("rcu: Reject RCU_LOCKDEP_WARN() false positives") for more detail.
286317  */
287318 #define RCU_LOCKDEP_WARN(c, s)						\
288319 	do {								\
289
-		static bool __section(.data.unlikely) __warned;		\
290
-		if (debug_lockdep_rcu_enabled() && !__warned && (c)) {	\
320
+		static bool __section(".data.unlikely") __warned;	\
321
+		if (debug_lockdep_rcu_enabled() && (c) &&		\
322
+		    debug_lockdep_rcu_enabled() && !__warned) {		\
291323 			__warned = true;				\
292324 			lockdep_rcu_suspicious(__FILE__, __LINE__, s);	\
293325 		}							\
....@@ -323,22 +355,21 @@
323355  * Helper functions for rcu_dereference_check(), rcu_dereference_protected()
324356  * and rcu_assign_pointer().  Some of these could be folded into their
325357  * callers, but they are left separate in order to ease introduction of
326
- * multiple flavors of pointers to match the multiple flavors of RCU
327
- * (e.g., __rcu_bh, * __rcu_sched, and __srcu), should this make sense in
328
- * the future.
358
+ * multiple pointers markings to match different RCU implementations
359
+ * (e.g., __srcu), should this make sense in the future.
329360  */
330361 
331362 #ifdef __CHECKER__
332
-#define rcu_dereference_sparse(p, space) \
363
+#define rcu_check_sparse(p, space) \
333364 	((void)(((typeof(*p) space *)p) == p))
334365 #else /* #ifdef __CHECKER__ */
335
-#define rcu_dereference_sparse(p, space)
366
+#define rcu_check_sparse(p, space)
336367 #endif /* #else #ifdef __CHECKER__ */
337368 
338369 #define __rcu_access_pointer(p, space) \
339370 ({ \
340371 	typeof(*p) *_________p1 = (typeof(*p) *__force)READ_ONCE(p); \
341
-	rcu_dereference_sparse(p, space); \
372
+	rcu_check_sparse(p, space); \
342373 	((typeof(*p) __force __kernel *)(_________p1)); \
343374 })
344375 #define __rcu_dereference_check(p, c, space) \
....@@ -346,13 +377,13 @@
346377 	/* Dependency order vs. p above. */ \
347378 	typeof(*p) *________p1 = (typeof(*p) *__force)READ_ONCE(p); \
348379 	RCU_LOCKDEP_WARN(!(c), "suspicious rcu_dereference_check() usage"); \
349
-	rcu_dereference_sparse(p, space); \
380
+	rcu_check_sparse(p, space); \
350381 	((typeof(*p) __force __kernel *)(________p1)); \
351382 })
352383 #define __rcu_dereference_protected(p, c, space) \
353384 ({ \
354385 	RCU_LOCKDEP_WARN(!(c), "suspicious rcu_dereference_protected() usage"); \
355
-	rcu_dereference_sparse(p, space); \
386
+	rcu_check_sparse(p, space); \
356387 	((typeof(*p) __force __kernel *)(p)); \
357388 })
358389 #define rcu_dereference_raw(p) \
....@@ -400,31 +431,33 @@
400431  * other macros that it invokes.
401432  */
402433 #define rcu_assign_pointer(p, v)					      \
403
-({									      \
434
+do {									      \
404435 	uintptr_t _r_a_p__v = (uintptr_t)(v);				      \
436
+	rcu_check_sparse(p, __rcu);					      \
405437 									      \
406438 	if (__builtin_constant_p(v) && (_r_a_p__v) == (uintptr_t)NULL)	      \
407439 		WRITE_ONCE((p), (typeof(p))(_r_a_p__v));		      \
408440 	else								      \
409441 		smp_store_release(&p, RCU_INITIALIZER((typeof(p))_r_a_p__v)); \
410
-	_r_a_p__v;							      \
411
-})
442
+} while (0)
412443 
413444 /**
414
- * rcu_swap_protected() - swap an RCU and a regular pointer
415
- * @rcu_ptr: RCU pointer
445
+ * rcu_replace_pointer() - replace an RCU pointer, returning its old value
446
+ * @rcu_ptr: RCU pointer, whose old value is returned
416447  * @ptr: regular pointer
417
- * @c: the conditions under which the dereference will take place
448
+ * @c: the lockdep conditions under which the dereference will take place
418449  *
419
- * Perform swap(@rcu_ptr, @ptr) where @rcu_ptr is an RCU-annotated pointer and
420
- * @c is the argument that is passed to the rcu_dereference_protected() call
421
- * used to read that pointer.
450
+ * Perform a replacement, where @rcu_ptr is an RCU-annotated
451
+ * pointer and @c is the lockdep argument that is passed to the
452
+ * rcu_dereference_protected() call used to read that pointer.  The old
453
+ * value of @rcu_ptr is returned, and @rcu_ptr is set to @ptr.
422454  */
423
-#define rcu_swap_protected(rcu_ptr, ptr, c) do {			\
455
+#define rcu_replace_pointer(rcu_ptr, ptr, c)				\
456
+({									\
424457 	typeof(ptr) __tmp = rcu_dereference_protected((rcu_ptr), (c));	\
425458 	rcu_assign_pointer((rcu_ptr), (ptr));				\
426
-	(ptr) = __tmp;							\
427
-} while (0)
459
+	__tmp;								\
460
+})
428461 
429462 /**
430463  * rcu_access_pointer() - fetch RCU pointer with no dereferencing
....@@ -511,7 +544,7 @@
511544  * The no-tracing version of rcu_dereference_raw() must not call
512545  * rcu_read_lock_held().
513546  */
514
-#define rcu_dereference_raw_notrace(p) __rcu_dereference_check((p), 1, __rcu)
547
+#define rcu_dereference_raw_check(p) __rcu_dereference_check((p), 1, __rcu)
515548 
516549 /**
517550  * rcu_dereference_protected() - fetch RCU pointer when updates prevented
....@@ -608,12 +641,12 @@
608641  *
609642  * You can avoid reading and understanding the next paragraph by
610643  * following this rule: don't put anything in an rcu_read_lock() RCU
611
- * read-side critical section that would block in a !PREEMPT kernel.
644
+ * read-side critical section that would block in a !PREEMPTION kernel.
612645  * But if you want the full story, read on!
613646  *
614
- * In non-preemptible RCU implementations (TREE_RCU and TINY_RCU),
647
+ * In non-preemptible RCU implementations (pure TREE_RCU and TINY_RCU),
615648  * it is illegal to block while in an RCU read-side critical section.
616
- * In preemptible RCU implementations (PREEMPT_RCU) in CONFIG_PREEMPT
649
+ * In preemptible RCU implementations (PREEMPT_RCU) in CONFIG_PREEMPTION
617650  * kernel builds, RCU read-side critical sections may be preempted,
618651  * but explicit blocking is illegal.  Finally, in preemptible RCU
619652  * implementations in real-time (with -rt patchset) kernel builds, RCU
....@@ -684,14 +717,9 @@
684717 /**
685718  * rcu_read_lock_bh() - mark the beginning of an RCU-bh critical section
686719  *
687
- * This is equivalent of rcu_read_lock(), but to be used when updates
688
- * are being done using call_rcu_bh() or synchronize_rcu_bh(). Since
689
- * both call_rcu_bh() and synchronize_rcu_bh() consider completion of a
690
- * softirq handler to be a quiescent state, a process in RCU read-side
691
- * critical section must be protected by disabling softirqs. Read-side
692
- * critical sections in interrupt context can use just rcu_read_lock(),
693
- * though this should at least be commented to avoid confusing people
694
- * reading the code.
720
+ * This is equivalent of rcu_read_lock(), but also disables softirqs.
721
+ * Note that anything else that disables softirqs can also serve as
722
+ * an RCU read-side critical section.
695723  *
696724  * Note that rcu_read_lock_bh() and the matching rcu_read_unlock_bh()
697725  * must occur in the same context, for example, it is illegal to invoke
....@@ -707,8 +735,8 @@
707735 			 "rcu_read_lock_bh() used illegally while idle");
708736 }
709737 
710
-/*
711
- * rcu_read_unlock_bh - marks the end of a softirq-only RCU critical section
738
+/**
739
+ * rcu_read_unlock_bh() - marks the end of a softirq-only RCU critical section
712740  *
713741  * See rcu_read_lock_bh() for more information.
714742  */
....@@ -724,10 +752,9 @@
724752 /**
725753  * rcu_read_lock_sched() - mark the beginning of a RCU-sched critical section
726754  *
727
- * This is equivalent of rcu_read_lock(), but to be used when updates
728
- * are being done using call_rcu_sched() or synchronize_rcu_sched().
729
- * Read-side critical sections can also be introduced by anything that
730
- * disables preemption, including local_irq_disable() and friends.
755
+ * This is equivalent of rcu_read_lock(), but disables preemption.
756
+ * Read-side critical sections can also be introduced by anything else
757
+ * that disables preemption, including local_irq_disable() and friends.
731758  *
732759  * Note that rcu_read_lock_sched() and the matching rcu_read_unlock_sched()
733760  * must occur in the same context, for example, it is illegal to invoke
....@@ -750,10 +777,10 @@
750777 	__acquire(RCU_SCHED);
751778 }
752779 
753
-/*
754
- * rcu_read_unlock_sched - marks the end of a RCU-classic critical section
780
+/**
781
+ * rcu_read_unlock_sched() - marks the end of a RCU-classic critical section
755782  *
756
- * See rcu_read_lock_sched for more information.
783
+ * See rcu_read_lock_sched() for more information.
757784  */
758785 static inline void rcu_read_unlock_sched(void)
759786 {
....@@ -811,7 +838,7 @@
811838  */
812839 #define RCU_INIT_POINTER(p, v) \
813840 	do { \
814
-		rcu_dereference_sparse(p, __rcu); \
841
+		rcu_check_sparse(p, __rcu); \
815842 		WRITE_ONCE(p, RCU_INITIALIZER(v)); \
816843 	} while (0)
817844 
....@@ -827,23 +854,23 @@
827854 
828855 /*
829856  * Does the specified offset indicate that the corresponding rcu_head
830
- * structure can be handled by kfree_rcu()?
857
+ * structure can be handled by kvfree_rcu()?
831858  */
832
-#define __is_kfree_rcu_offset(offset) ((offset) < 4096)
859
+#define __is_kvfree_rcu_offset(offset) ((offset) < 4096)
833860 
834861 /*
835862  * Helper macro for kfree_rcu() to prevent argument-expansion eyestrain.
836863  */
837
-#define __kfree_rcu(head, offset) \
864
+#define __kvfree_rcu(head, offset) \
838865 	do { \
839
-		BUILD_BUG_ON(!__is_kfree_rcu_offset(offset)); \
840
-		kfree_call_rcu(head, (rcu_callback_t)(unsigned long)(offset)); \
866
+		BUILD_BUG_ON(!__is_kvfree_rcu_offset(offset)); \
867
+		kvfree_call_rcu(head, (rcu_callback_t)(unsigned long)(offset)); \
841868 	} while (0)
842869 
843870 /**
844871  * kfree_rcu() - kfree an object after a grace period.
845872  * @ptr:	pointer to kfree
846
- * @rcu_head:	the name of the struct rcu_head within the type of @ptr.
873
+ * @rhf:	the name of the struct rcu_head within the type of @ptr.
847874  *
848875  * Many rcu callbacks functions just call kfree() on the base structure.
849876  * These functions are trivial, but their size adds up, and furthermore
....@@ -856,7 +883,7 @@
856883  * Because the functions are not allowed in the low-order 4096 bytes of
857884  * kernel virtual memory, offsets up to 4095 bytes can be accommodated.
858885  * If the offset is larger than 4095 bytes, a compile-time error will
859
- * be generated in __kfree_rcu().  If this error is triggered, you can
886
+ * be generated in __kvfree_rcu(). If this error is triggered, you can
860887  * either fall back to use of call_rcu() or rearrange the structure to
861888  * position the rcu_head structure into the first 4096 bytes.
862889  *
....@@ -866,9 +893,52 @@
866893  * The BUILD_BUG_ON check must not involve any function calls, hence the
867894  * checks are done in macros here.
868895  */
869
-#define kfree_rcu(ptr, rcu_head)					\
870
-	__kfree_rcu(&((ptr)->rcu_head), offsetof(typeof(*(ptr)), rcu_head))
896
+#define kfree_rcu(ptr, rhf)						\
897
+do {									\
898
+	typeof (ptr) ___p = (ptr);					\
899
+									\
900
+	if (___p)							\
901
+		__kvfree_rcu(&((___p)->rhf), offsetof(typeof(*(ptr)), rhf)); \
902
+} while (0)
871903 
904
+/**
905
+ * kvfree_rcu() - kvfree an object after a grace period.
906
+ *
907
+ * This macro consists of one or two arguments and it is
908
+ * based on whether an object is head-less or not. If it
909
+ * has a head then a semantic stays the same as it used
910
+ * to be before:
911
+ *
912
+ *     kvfree_rcu(ptr, rhf);
913
+ *
914
+ * where @ptr is a pointer to kvfree(), @rhf is the name
915
+ * of the rcu_head structure within the type of @ptr.
916
+ *
917
+ * When it comes to head-less variant, only one argument
918
+ * is passed and that is just a pointer which has to be
919
+ * freed after a grace period. Therefore the semantic is
920
+ *
921
+ *     kvfree_rcu(ptr);
922
+ *
923
+ * where @ptr is a pointer to kvfree().
924
+ *
925
+ * Please note, head-less way of freeing is permitted to
926
+ * use from a context that has to follow might_sleep()
927
+ * annotation. Otherwise, please switch and embed the
928
+ * rcu_head structure within the type of @ptr.
929
+ */
930
+#define kvfree_rcu(...) KVFREE_GET_MACRO(__VA_ARGS__,		\
931
+	kvfree_rcu_arg_2, kvfree_rcu_arg_1)(__VA_ARGS__)
932
+
933
+#define KVFREE_GET_MACRO(_1, _2, NAME, ...) NAME
934
+#define kvfree_rcu_arg_2(ptr, rhf) kfree_rcu(ptr, rhf)
935
+#define kvfree_rcu_arg_1(ptr)					\
936
+do {								\
937
+	typeof(ptr) ___p = (ptr);				\
938
+								\
939
+	if (___p)						\
940
+		kvfree_call_rcu(NULL, (rcu_callback_t) (___p));	\
941
+} while (0)
872942 
873943 /*
874944  * Place this after a lock-acquisition primitive to guarantee that
....@@ -883,4 +953,49 @@
883953 #endif /* #else #ifdef CONFIG_ARCH_WEAK_RELEASE_ACQUIRE */
884954 
885955 
956
+/* Has the specified rcu_head structure been handed to call_rcu()? */
957
+
958
+/**
959
+ * rcu_head_init - Initialize rcu_head for rcu_head_after_call_rcu()
960
+ * @rhp: The rcu_head structure to initialize.
961
+ *
962
+ * If you intend to invoke rcu_head_after_call_rcu() to test whether a
963
+ * given rcu_head structure has already been passed to call_rcu(), then
964
+ * you must also invoke this rcu_head_init() function on it just after
965
+ * allocating that structure.  Calls to this function must not race with
966
+ * calls to call_rcu(), rcu_head_after_call_rcu(), or callback invocation.
967
+ */
968
+static inline void rcu_head_init(struct rcu_head *rhp)
969
+{
970
+	rhp->func = (rcu_callback_t)~0L;
971
+}
972
+
973
+/**
974
+ * rcu_head_after_call_rcu() - Has this rcu_head been passed to call_rcu()?
975
+ * @rhp: The rcu_head structure to test.
976
+ * @f: The function passed to call_rcu() along with @rhp.
977
+ *
978
+ * Returns @true if the @rhp has been passed to call_rcu() with @func,
979
+ * and @false otherwise.  Emits a warning in any other case, including
980
+ * the case where @rhp has already been invoked after a grace period.
981
+ * Calls to this function must not race with callback invocation.  One way
982
+ * to avoid such races is to enclose the call to rcu_head_after_call_rcu()
983
+ * in an RCU read-side critical section that includes a read-side fetch
984
+ * of the pointer to the structure containing @rhp.
985
+ */
986
+static inline bool
987
+rcu_head_after_call_rcu(struct rcu_head *rhp, rcu_callback_t f)
988
+{
989
+	rcu_callback_t func = READ_ONCE(rhp->func);
990
+
991
+	if (func == f)
992
+		return true;
993
+	WARN_ON_ONCE(func != (rcu_callback_t)~0L);
994
+	return false;
995
+}
996
+
997
+/* kernel/ksysfs.c definitions */
998
+extern int rcu_expedited;
999
+extern int rcu_normal;
1000
+
8861001 #endif /* __LINUX_RCUPDATE_H */