forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2023-12-09 b22da3d8526a935aa31e086e63f60ff3246cb61c 
 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
....@@ -42,34 +29,23 @@
4229 #include <linux/lockdep.h>
4330 #include <asm/processor.h>
4431 #include <linux/cpumask.h>
45
-#include <linux/rcu_assign_pointer.h>
4632 
4733 #define ULONG_CMP_GE(a, b)	(ULONG_MAX / 2 >= (a) - (b))
4834 #define ULONG_CMP_LT(a, b)	(ULONG_MAX / 2 < (a) - (b))
4935 #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)))
5038 
5139 /* Exported common interfaces */
52
-
53
-#ifdef CONFIG_PREEMPT_RCU
5440 void call_rcu(struct rcu_head *head, rcu_callback_t func);
55
-#else /* #ifdef CONFIG_PREEMPT_RCU */
56
-#define	call_rcu	call_rcu_sched
57
-#endif /* #else #ifdef CONFIG_PREEMPT_RCU */
58
-
59
-#ifdef CONFIG_PREEMPT_RT_FULL
60
-#define call_rcu_bh	call_rcu
61
-#else
62
-void call_rcu_bh(struct rcu_head *head, rcu_callback_t func);
63
-#endif
64
-void call_rcu_sched(struct rcu_head *head, rcu_callback_t func);
65
-void synchronize_sched(void);
6641 void rcu_barrier_tasks(void);
42
+void rcu_barrier_tasks_rude(void);
43
+void synchronize_rcu(void);
6744 
6845 #ifdef CONFIG_PREEMPT_RCU
6946 
7047 void __rcu_read_lock(void);
7148 void __rcu_read_unlock(void);
72
-void synchronize_rcu(void);
7349 
7450 /*
7551  * Defined as a macro as it is a very low level header included from
....@@ -78,13 +54,19 @@
7854  * types of kernel builds, the rcu_read_lock() nesting depth is unknowable.
7955  */
8056 #define rcu_preempt_depth() (current->rcu_read_lock_nesting)
81
-#ifndef CONFIG_PREEMPT_RT_FULL
57
+#ifndef CONFIG_PREEMPT_RT
8258 #define sched_rcu_preempt_depth()	rcu_preempt_depth()
8359 #else
8460 static inline int sched_rcu_preempt_depth(void) { return 0; }
8561 #endif
8662 
8763 #else /* #ifdef CONFIG_PREEMPT_RCU */
64
+
65
+#ifdef CONFIG_TINY_RCU
66
+#define rcu_read_unlock_strict() do { } while (0)
67
+#else
68
+void rcu_read_unlock_strict(void);
69
+#endif
8870 
8971 static inline void __rcu_read_lock(void)
9072 {
....@@ -94,11 +76,7 @@
9476 static inline void __rcu_read_unlock(void)
9577 {
9678 	preempt_enable();
97
-}
98
-
99
-static inline void synchronize_rcu(void)
100
-{
101
-	synchronize_sched();
79
+	rcu_read_unlock_strict();
10280 }
10381 
10482 static inline int rcu_preempt_depth(void)
....@@ -113,11 +91,15 @@
11391 /* Internal to kernel */
11492 void rcu_init(void);
11593 extern int rcu_scheduler_active __read_mostly;
116
-void rcu_sched_qs(void);
117
-void rcu_bh_qs(void);
118
-void rcu_check_callbacks(int user);
94
+void rcu_sched_clock_irq(int user);
11995 void rcu_report_dead(unsigned int cpu);
12096 void rcutree_migrate_callbacks(int cpu);
97
+
98
+#ifdef CONFIG_TASKS_RCU_GENERIC
99
+void rcu_init_tasks_generic(void);
100
+#else
101
+static inline void rcu_init_tasks_generic(void) { }
102
+#endif
121103 
122104 #ifdef CONFIG_RCU_STALL_COMMON
123105 void rcu_sysrq_start(void);
....@@ -137,19 +119,20 @@
137119 
138120 #ifdef CONFIG_RCU_NOCB_CPU
139121 void rcu_init_nohz(void);
122
+void rcu_nocb_flush_deferred_wakeup(void);
140123 #else /* #ifdef CONFIG_RCU_NOCB_CPU */
141124 static inline void rcu_init_nohz(void) { }
125
+static inline void rcu_nocb_flush_deferred_wakeup(void) { }
142126 #endif /* #else #ifdef CONFIG_RCU_NOCB_CPU */
143127 
144128 /**
145129  * RCU_NONIDLE - Indicate idle-loop code that needs RCU readers
146130  * @a: Code that RCU needs to pay attention to.
147131  *
148
- * RCU, RCU-bh, and RCU-sched read-side critical sections are forbidden
149
- * in the inner idle loop, that is, between the rcu_idle_enter() and
150
- * the rcu_idle_exit() -- RCU will happily ignore any such read-side
151
- * critical sections.  However, things like powertop need tracepoints
152
- * in the inner idle loop.
132
+ * RCU read-side critical sections are forbidden in the inner idle loop,
133
+ * that is, between the rcu_idle_enter() and the rcu_idle_exit() -- RCU
134
+ * will happily ignore any such read-side critical sections.  However,
135
+ * things like powertop need tracepoints in the inner idle loop.
153136  *
154137  * This macro provides the way out:  RCU_NONIDLE(do_something_with_RCU())
155138  * will tell RCU that it needs to pay attention, invoke its argument
....@@ -171,40 +154,68 @@
171154  * Note a quasi-voluntary context switch for RCU-tasks's benefit.
172155  * This is a macro rather than an inline function to avoid #include hell.
173156  */
174
-#ifdef CONFIG_TASKS_RCU
175
-#define rcu_tasks_qs(t) \
176
-	do { \
177
-		if (READ_ONCE((t)->rcu_tasks_holdout)) \
178
-			WRITE_ONCE((t)->rcu_tasks_holdout, false); \
179
-	} while (0)
180
-#define rcu_note_voluntary_context_switch(t) \
181
-	do { \
182
-		rcu_all_qs(); \
183
-		rcu_tasks_qs(t); \
157
+#ifdef CONFIG_TASKS_RCU_GENERIC
158
+
159
+# ifdef CONFIG_TASKS_RCU
160
+# define rcu_tasks_classic_qs(t, preempt)				\
161
+	do {								\
162
+		if (!(preempt) && READ_ONCE((t)->rcu_tasks_holdout))	\
163
+			WRITE_ONCE((t)->rcu_tasks_holdout, false);	\
184164 	} while (0)
185165 void call_rcu_tasks(struct rcu_head *head, rcu_callback_t func);
186166 void synchronize_rcu_tasks(void);
167
+# else
168
+# define rcu_tasks_classic_qs(t, preempt) do { } while (0)
169
+# define call_rcu_tasks call_rcu
170
+# define synchronize_rcu_tasks synchronize_rcu
171
+# endif
172
+
173
+# ifdef CONFIG_TASKS_TRACE_RCU
174
+# define rcu_tasks_trace_qs(t)						\
175
+	do {								\
176
+		if (!likely(READ_ONCE((t)->trc_reader_checked)) &&	\
177
+		    !unlikely(READ_ONCE((t)->trc_reader_nesting))) {	\
178
+			smp_store_release(&(t)->trc_reader_checked, true); \
179
+			smp_mb(); /* Readers partitioned by store. */	\
180
+		}							\
181
+	} while (0)
182
+# else
183
+# define rcu_tasks_trace_qs(t) do { } while (0)
184
+# endif
185
+
186
+#define rcu_tasks_qs(t, preempt)					\
187
+do {									\
188
+	rcu_tasks_classic_qs((t), (preempt));				\
189
+	rcu_tasks_trace_qs((t));					\
190
+} while (0)
191
+
192
+# ifdef CONFIG_TASKS_RUDE_RCU
193
+void call_rcu_tasks_rude(struct rcu_head *head, rcu_callback_t func);
194
+void synchronize_rcu_tasks_rude(void);
195
+# endif
196
+
197
+#define rcu_note_voluntary_context_switch(t) rcu_tasks_qs(t, false)
187198 void exit_tasks_rcu_start(void);
188199 void exit_tasks_rcu_finish(void);
189
-#else /* #ifdef CONFIG_TASKS_RCU */
190
-#define rcu_tasks_qs(t)	do { } while (0)
191
-#define rcu_note_voluntary_context_switch(t)		rcu_all_qs()
192
-#define call_rcu_tasks call_rcu_sched
193
-#define synchronize_rcu_tasks synchronize_sched
200
+#else /* #ifdef CONFIG_TASKS_RCU_GENERIC */
201
+#define rcu_tasks_qs(t, preempt) do { } while (0)
202
+#define rcu_note_voluntary_context_switch(t) do { } while (0)
203
+#define call_rcu_tasks call_rcu
204
+#define synchronize_rcu_tasks synchronize_rcu
194205 static inline void exit_tasks_rcu_start(void) { }
195206 static inline void exit_tasks_rcu_finish(void) { }
196
-#endif /* #else #ifdef CONFIG_TASKS_RCU */
207
+#endif /* #else #ifdef CONFIG_TASKS_RCU_GENERIC */
197208 
198209 /**
199210  * cond_resched_tasks_rcu_qs - Report potential quiescent states to RCU
200211  *
201212  * This macro resembles cond_resched(), except that it is defined to
202213  * report potential quiescent states to RCU-tasks even if the cond_resched()
203
- * machinery were to be shut off, as some advocate for PREEMPT kernels.
214
+ * machinery were to be shut off, as some advocate for PREEMPTION kernels.
204215  */
205216 #define cond_resched_tasks_rcu_qs() \
206217 do { \
207
-	rcu_tasks_qs(current); \
218
+	rcu_tasks_qs(current, false); \
208219 	cond_resched(); \
209220 } while (0)
210221 
....@@ -213,7 +224,7 @@
213224  * TREE_RCU and rcu_barrier_() primitives in TINY_RCU.
214225  */
215226 
216
-#if defined(CONFIG_TREE_RCU) || defined(CONFIG_PREEMPT_RCU)
227
+#if defined(CONFIG_TREE_RCU)
217228 #include <linux/rcutree.h>
218229 #elif defined(CONFIG_TINY_RCU)
219230 #include <linux/rcutiny.h>
....@@ -256,7 +267,7 @@
256267 
257268 static inline void rcu_lock_release(struct lockdep_map *map)
258269 {
259
-	lock_release(map, 1, _THIS_IP_);
270
+	lock_release(map, _THIS_IP_);
260271 }
261272 
262273 extern struct lockdep_map rcu_lock_map;
....@@ -265,15 +276,9 @@
265276 extern struct lockdep_map rcu_callback_map;
266277 int debug_lockdep_rcu_enabled(void);
267278 int rcu_read_lock_held(void);
268
-#ifdef CONFIG_PREEMPT_RT_FULL
269
-static inline int rcu_read_lock_bh_held(void)
270
-{
271
-	return rcu_read_lock_held();
272
-}
273
-#else
274279 int rcu_read_lock_bh_held(void);
275
-#endif
276280 int rcu_read_lock_sched_held(void);
281
+int rcu_read_lock_any_held(void);
277282 
278283 #else /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
279284 
....@@ -294,6 +299,12 @@
294299 {
295300 	return !preemptible();
296301 }
302
+
303
+static inline int rcu_read_lock_any_held(void)
304
+{
305
+	return !preemptible();
306
+}
307
+
297308 #endif /* #else #ifdef CONFIG_DEBUG_LOCK_ALLOC */
298309 
299310 #ifdef CONFIG_PROVE_RCU
....@@ -305,8 +316,8 @@
305316  */
306317 #define RCU_LOCKDEP_WARN(c, s)						\
307318 	do {								\
308
-		static bool __section(.data.unlikely) __warned;		\
309
-		if (debug_lockdep_rcu_enabled() && !__warned && (c)) {	\
319
+		static bool __section(".data.unlikely") __warned;	\
320
+		if ((c) && debug_lockdep_rcu_enabled() && !__warned) {	\
310321 			__warned = true;				\
311322 			lockdep_rcu_suspicious(__FILE__, __LINE__, s);	\
312323 		}							\
....@@ -325,7 +336,8 @@
325336 #define rcu_sleep_check()						\
326337 	do {								\
327338 		rcu_preempt_sleep_check();				\
328
-		RCU_LOCKDEP_WARN(lock_is_held(&rcu_bh_lock_map),	\
339
+		if (!IS_ENABLED(CONFIG_PREEMPT_RT))			\
340
+		    RCU_LOCKDEP_WARN(lock_is_held(&rcu_bh_lock_map),	\
329341 				 "Illegal context switch in RCU-bh read-side critical section"); \
330342 		RCU_LOCKDEP_WARN(lock_is_held(&rcu_sched_lock_map),	\
331343 				 "Illegal context switch in RCU-sched read-side critical section"); \
....@@ -342,22 +354,21 @@
342354  * Helper functions for rcu_dereference_check(), rcu_dereference_protected()
343355  * and rcu_assign_pointer().  Some of these could be folded into their
344356  * callers, but they are left separate in order to ease introduction of
345
- * multiple flavors of pointers to match the multiple flavors of RCU
346
- * (e.g., __rcu_bh, * __rcu_sched, and __srcu), should this make sense in
347
- * the future.
357
+ * multiple pointers markings to match different RCU implementations
358
+ * (e.g., __srcu), should this make sense in the future.
348359  */
349360 
350361 #ifdef __CHECKER__
351
-#define rcu_dereference_sparse(p, space) \
362
+#define rcu_check_sparse(p, space) \
352363 	((void)(((typeof(*p) space *)p) == p))
353364 #else /* #ifdef __CHECKER__ */
354
-#define rcu_dereference_sparse(p, space)
365
+#define rcu_check_sparse(p, space)
355366 #endif /* #else #ifdef __CHECKER__ */
356367 
357368 #define __rcu_access_pointer(p, space) \
358369 ({ \
359370 	typeof(*p) *_________p1 = (typeof(*p) *__force)READ_ONCE(p); \
360
-	rcu_dereference_sparse(p, space); \
371
+	rcu_check_sparse(p, space); \
361372 	((typeof(*p) __force __kernel *)(_________p1)); \
362373 })
363374 #define __rcu_dereference_check(p, c, space) \
....@@ -365,13 +376,13 @@
365376 	/* Dependency order vs. p above. */ \
366377 	typeof(*p) *________p1 = (typeof(*p) *__force)READ_ONCE(p); \
367378 	RCU_LOCKDEP_WARN(!(c), "suspicious rcu_dereference_check() usage"); \
368
-	rcu_dereference_sparse(p, space); \
379
+	rcu_check_sparse(p, space); \
369380 	((typeof(*p) __force __kernel *)(________p1)); \
370381 })
371382 #define __rcu_dereference_protected(p, c, space) \
372383 ({ \
373384 	RCU_LOCKDEP_WARN(!(c), "suspicious rcu_dereference_protected() usage"); \
374
-	rcu_dereference_sparse(p, space); \
385
+	rcu_check_sparse(p, space); \
375386 	((typeof(*p) __force __kernel *)(p)); \
376387 })
377388 #define rcu_dereference_raw(p) \
....@@ -382,20 +393,70 @@
382393 })
383394 
384395 /**
385
- * rcu_swap_protected() - swap an RCU and a regular pointer
386
- * @rcu_ptr: RCU pointer
387
- * @ptr: regular pointer
388
- * @c: the conditions under which the dereference will take place
389
- *
390
- * Perform swap(@rcu_ptr, @ptr) where @rcu_ptr is an RCU-annotated pointer and
391
- * @c is the argument that is passed to the rcu_dereference_protected() call
392
- * used to read that pointer.
396
+ * RCU_INITIALIZER() - statically initialize an RCU-protected global variable
397
+ * @v: The value to statically initialize with.
393398  */
394
-#define rcu_swap_protected(rcu_ptr, ptr, c) do {			\
399
+#define RCU_INITIALIZER(v) (typeof(*(v)) __force __rcu *)(v)
400
+
401
+/**
402
+ * rcu_assign_pointer() - assign to RCU-protected pointer
403
+ * @p: pointer to assign to
404
+ * @v: value to assign (publish)
405
+ *
406
+ * Assigns the specified value to the specified RCU-protected
407
+ * pointer, ensuring that any concurrent RCU readers will see
408
+ * any prior initialization.
409
+ *
410
+ * Inserts memory barriers on architectures that require them
411
+ * (which is most of them), and also prevents the compiler from
412
+ * reordering the code that initializes the structure after the pointer
413
+ * assignment.  More importantly, this call documents which pointers
414
+ * will be dereferenced by RCU read-side code.
415
+ *
416
+ * In some special cases, you may use RCU_INIT_POINTER() instead
417
+ * of rcu_assign_pointer().  RCU_INIT_POINTER() is a bit faster due
418
+ * to the fact that it does not constrain either the CPU or the compiler.
419
+ * That said, using RCU_INIT_POINTER() when you should have used
420
+ * rcu_assign_pointer() is a very bad thing that results in
421
+ * impossible-to-diagnose memory corruption.  So please be careful.
422
+ * See the RCU_INIT_POINTER() comment header for details.
423
+ *
424
+ * Note that rcu_assign_pointer() evaluates each of its arguments only
425
+ * once, appearances notwithstanding.  One of the "extra" evaluations
426
+ * is in typeof() and the other visible only to sparse (__CHECKER__),
427
+ * neither of which actually execute the argument.  As with most cpp
428
+ * macros, this execute-arguments-only-once property is important, so
429
+ * please be careful when making changes to rcu_assign_pointer() and the
430
+ * other macros that it invokes.
431
+ */
432
+#define rcu_assign_pointer(p, v)					      \
433
+do {									      \
434
+	uintptr_t _r_a_p__v = (uintptr_t)(v);				      \
435
+	rcu_check_sparse(p, __rcu);					      \
436
+									      \
437
+	if (__builtin_constant_p(v) && (_r_a_p__v) == (uintptr_t)NULL)	      \
438
+		WRITE_ONCE((p), (typeof(p))(_r_a_p__v));		      \
439
+	else								      \
440
+		smp_store_release(&p, RCU_INITIALIZER((typeof(p))_r_a_p__v)); \
441
+} while (0)
442
+
443
+/**
444
+ * rcu_replace_pointer() - replace an RCU pointer, returning its old value
445
+ * @rcu_ptr: RCU pointer, whose old value is returned
446
+ * @ptr: regular pointer
447
+ * @c: the lockdep conditions under which the dereference will take place
448
+ *
449
+ * Perform a replacement, where @rcu_ptr is an RCU-annotated
450
+ * pointer and @c is the lockdep argument that is passed to the
451
+ * rcu_dereference_protected() call used to read that pointer.  The old
452
+ * value of @rcu_ptr is returned, and @rcu_ptr is set to @ptr.
453
+ */
454
+#define rcu_replace_pointer(rcu_ptr, ptr, c)				\
455
+({									\
395456 	typeof(ptr) __tmp = rcu_dereference_protected((rcu_ptr), (c));	\
396457 	rcu_assign_pointer((rcu_ptr), (ptr));				\
397
-	(ptr) = __tmp;							\
398
-} while (0)
458
+	__tmp;								\
459
+})
399460 
400461 /**
401462  * rcu_access_pointer() - fetch RCU pointer with no dereferencing
....@@ -482,7 +543,7 @@
482543  * The no-tracing version of rcu_dereference_raw() must not call
483544  * rcu_read_lock_held().
484545  */
485
-#define rcu_dereference_raw_notrace(p) __rcu_dereference_check((p), 1, __rcu)
546
+#define rcu_dereference_raw_check(p) __rcu_dereference_check((p), 1, __rcu)
486547 
487548 /**
488549  * rcu_dereference_protected() - fetch RCU pointer when updates prevented
....@@ -579,12 +640,12 @@
579640  *
580641  * You can avoid reading and understanding the next paragraph by
581642  * following this rule: don't put anything in an rcu_read_lock() RCU
582
- * read-side critical section that would block in a !PREEMPT kernel.
643
+ * read-side critical section that would block in a !PREEMPTION kernel.
583644  * But if you want the full story, read on!
584645  *
585
- * In non-preemptible RCU implementations (TREE_RCU and TINY_RCU),
646
+ * In non-preemptible RCU implementations (pure TREE_RCU and TINY_RCU),
586647  * it is illegal to block while in an RCU read-side critical section.
587
- * In preemptible RCU implementations (PREEMPT_RCU) in CONFIG_PREEMPT
648
+ * In preemptible RCU implementations (PREEMPT_RCU) in CONFIG_PREEMPTION
588649  * kernel builds, RCU read-side critical sections may be preempted,
589650  * but explicit blocking is illegal.  Finally, in preemptible RCU
590651  * implementations in real-time (with -rt patchset) kernel builds, RCU
....@@ -655,14 +716,9 @@
655716 /**
656717  * rcu_read_lock_bh() - mark the beginning of an RCU-bh critical section
657718  *
658
- * This is equivalent of rcu_read_lock(), but to be used when updates
659
- * are being done using call_rcu_bh() or synchronize_rcu_bh(). Since
660
- * both call_rcu_bh() and synchronize_rcu_bh() consider completion of a
661
- * softirq handler to be a quiescent state, a process in RCU read-side
662
- * critical section must be protected by disabling softirqs. Read-side
663
- * critical sections in interrupt context can use just rcu_read_lock(),
664
- * though this should at least be commented to avoid confusing people
665
- * reading the code.
719
+ * This is equivalent of rcu_read_lock(), but also disables softirqs.
720
+ * Note that anything else that disables softirqs can also serve as
721
+ * an RCU read-side critical section.
666722  *
667723  * Note that rcu_read_lock_bh() and the matching rcu_read_unlock_bh()
668724  * must occur in the same context, for example, it is illegal to invoke
....@@ -672,41 +728,32 @@
672728 static inline void rcu_read_lock_bh(void)
673729 {
674730 	local_bh_disable();
675
-#ifdef CONFIG_PREEMPT_RT_FULL
676
-	rcu_read_lock();
677
-#else
678731 	__acquire(RCU_BH);
679732 	rcu_lock_acquire(&rcu_bh_lock_map);
680733 	RCU_LOCKDEP_WARN(!rcu_is_watching(),
681734 			 "rcu_read_lock_bh() used illegally while idle");
682
-#endif
683735 }
684736 
685
-/*
686
- * rcu_read_unlock_bh - marks the end of a softirq-only RCU critical section
737
+/**
738
+ * rcu_read_unlock_bh() - marks the end of a softirq-only RCU critical section
687739  *
688740  * See rcu_read_lock_bh() for more information.
689741  */
690742 static inline void rcu_read_unlock_bh(void)
691743 {
692
-#ifdef CONFIG_PREEMPT_RT_FULL
693
-	rcu_read_unlock();
694
-#else
695744 	RCU_LOCKDEP_WARN(!rcu_is_watching(),
696745 			 "rcu_read_unlock_bh() used illegally while idle");
697746 	rcu_lock_release(&rcu_bh_lock_map);
698747 	__release(RCU_BH);
699
-#endif
700748 	local_bh_enable();
701749 }
702750 
703751 /**
704752  * rcu_read_lock_sched() - mark the beginning of a RCU-sched critical section
705753  *
706
- * This is equivalent of rcu_read_lock(), but to be used when updates
707
- * are being done using call_rcu_sched() or synchronize_rcu_sched().
708
- * Read-side critical sections can also be introduced by anything that
709
- * disables preemption, including local_irq_disable() and friends.
754
+ * This is equivalent of rcu_read_lock(), but disables preemption.
755
+ * Read-side critical sections can also be introduced by anything else
756
+ * that disables preemption, including local_irq_disable() and friends.
710757  *
711758  * Note that rcu_read_lock_sched() and the matching rcu_read_unlock_sched()
712759  * must occur in the same context, for example, it is illegal to invoke
....@@ -729,10 +776,10 @@
729776 	__acquire(RCU_SCHED);
730777 }
731778 
732
-/*
733
- * rcu_read_unlock_sched - marks the end of a RCU-classic critical section
779
+/**
780
+ * rcu_read_unlock_sched() - marks the end of a RCU-classic critical section
734781  *
735
- * See rcu_read_lock_sched for more information.
782
+ * See rcu_read_lock_sched() for more information.
736783  */
737784 static inline void rcu_read_unlock_sched(void)
738785 {
....@@ -790,7 +837,7 @@
790837  */
791838 #define RCU_INIT_POINTER(p, v) \
792839 	do { \
793
-		rcu_dereference_sparse(p, __rcu); \
840
+		rcu_check_sparse(p, __rcu); \
794841 		WRITE_ONCE(p, RCU_INITIALIZER(v)); \
795842 	} while (0)
796843 
....@@ -806,23 +853,23 @@
806853 
807854 /*
808855  * Does the specified offset indicate that the corresponding rcu_head
809
- * structure can be handled by kfree_rcu()?
856
+ * structure can be handled by kvfree_rcu()?
810857  */
811
-#define __is_kfree_rcu_offset(offset) ((offset) < 4096)
858
+#define __is_kvfree_rcu_offset(offset) ((offset) < 4096)
812859 
813860 /*
814861  * Helper macro for kfree_rcu() to prevent argument-expansion eyestrain.
815862  */
816
-#define __kfree_rcu(head, offset) \
863
+#define __kvfree_rcu(head, offset) \
817864 	do { \
818
-		BUILD_BUG_ON(!__is_kfree_rcu_offset(offset)); \
819
-		kfree_call_rcu(head, (rcu_callback_t)(unsigned long)(offset)); \
865
+		BUILD_BUG_ON(!__is_kvfree_rcu_offset(offset)); \
866
+		kvfree_call_rcu(head, (rcu_callback_t)(unsigned long)(offset)); \
820867 	} while (0)
821868 
822869 /**
823870  * kfree_rcu() - kfree an object after a grace period.
824871  * @ptr:	pointer to kfree
825
- * @rcu_head:	the name of the struct rcu_head within the type of @ptr.
872
+ * @rhf:	the name of the struct rcu_head within the type of @ptr.
826873  *
827874  * Many rcu callbacks functions just call kfree() on the base structure.
828875  * These functions are trivial, but their size adds up, and furthermore
....@@ -835,7 +882,7 @@
835882  * Because the functions are not allowed in the low-order 4096 bytes of
836883  * kernel virtual memory, offsets up to 4095 bytes can be accommodated.
837884  * If the offset is larger than 4095 bytes, a compile-time error will
838
- * be generated in __kfree_rcu().  If this error is triggered, you can
885
+ * be generated in __kvfree_rcu(). If this error is triggered, you can
839886  * either fall back to use of call_rcu() or rearrange the structure to
840887  * position the rcu_head structure into the first 4096 bytes.
841888  *
....@@ -845,9 +892,52 @@
845892  * The BUILD_BUG_ON check must not involve any function calls, hence the
846893  * checks are done in macros here.
847894  */
848
-#define kfree_rcu(ptr, rcu_head)					\
849
-	__kfree_rcu(&((ptr)->rcu_head), offsetof(typeof(*(ptr)), rcu_head))
895
+#define kfree_rcu(ptr, rhf)						\
896
+do {									\
897
+	typeof (ptr) ___p = (ptr);					\
898
+									\
899
+	if (___p)							\
900
+		__kvfree_rcu(&((___p)->rhf), offsetof(typeof(*(ptr)), rhf)); \
901
+} while (0)
850902 
903
+/**
904
+ * kvfree_rcu() - kvfree an object after a grace period.
905
+ *
906
+ * This macro consists of one or two arguments and it is
907
+ * based on whether an object is head-less or not. If it
908
+ * has a head then a semantic stays the same as it used
909
+ * to be before:
910
+ *
911
+ *     kvfree_rcu(ptr, rhf);
912
+ *
913
+ * where @ptr is a pointer to kvfree(), @rhf is the name
914
+ * of the rcu_head structure within the type of @ptr.
915
+ *
916
+ * When it comes to head-less variant, only one argument
917
+ * is passed and that is just a pointer which has to be
918
+ * freed after a grace period. Therefore the semantic is
919
+ *
920
+ *     kvfree_rcu(ptr);
921
+ *
922
+ * where @ptr is a pointer to kvfree().
923
+ *
924
+ * Please note, head-less way of freeing is permitted to
925
+ * use from a context that has to follow might_sleep()
926
+ * annotation. Otherwise, please switch and embed the
927
+ * rcu_head structure within the type of @ptr.
928
+ */
929
+#define kvfree_rcu(...) KVFREE_GET_MACRO(__VA_ARGS__,		\
930
+	kvfree_rcu_arg_2, kvfree_rcu_arg_1)(__VA_ARGS__)
931
+
932
+#define KVFREE_GET_MACRO(_1, _2, NAME, ...) NAME
933
+#define kvfree_rcu_arg_2(ptr, rhf) kfree_rcu(ptr, rhf)
934
+#define kvfree_rcu_arg_1(ptr)					\
935
+do {								\
936
+	typeof(ptr) ___p = (ptr);				\
937
+								\
938
+	if (___p)						\
939
+		kvfree_call_rcu(NULL, (rcu_callback_t) (___p));	\
940
+} while (0)
851941 
852942 /*
853943  * Place this after a lock-acquisition primitive to guarantee that
....@@ -862,4 +952,49 @@
862952 #endif /* #else #ifdef CONFIG_ARCH_WEAK_RELEASE_ACQUIRE */
863953 
864954 
955
+/* Has the specified rcu_head structure been handed to call_rcu()? */
956
+
957
+/**
958
+ * rcu_head_init - Initialize rcu_head for rcu_head_after_call_rcu()
959
+ * @rhp: The rcu_head structure to initialize.
960
+ *
961
+ * If you intend to invoke rcu_head_after_call_rcu() to test whether a
962
+ * given rcu_head structure has already been passed to call_rcu(), then
963
+ * you must also invoke this rcu_head_init() function on it just after
964
+ * allocating that structure.  Calls to this function must not race with
965
+ * calls to call_rcu(), rcu_head_after_call_rcu(), or callback invocation.
966
+ */
967
+static inline void rcu_head_init(struct rcu_head *rhp)
968
+{
969
+	rhp->func = (rcu_callback_t)~0L;
970
+}
971
+
972
+/**
973
+ * rcu_head_after_call_rcu() - Has this rcu_head been passed to call_rcu()?
974
+ * @rhp: The rcu_head structure to test.
975
+ * @f: The function passed to call_rcu() along with @rhp.
976
+ *
977
+ * Returns @true if the @rhp has been passed to call_rcu() with @func,
978
+ * and @false otherwise.  Emits a warning in any other case, including
979
+ * the case where @rhp has already been invoked after a grace period.
980
+ * Calls to this function must not race with callback invocation.  One way
981
+ * to avoid such races is to enclose the call to rcu_head_after_call_rcu()
982
+ * in an RCU read-side critical section that includes a read-side fetch
983
+ * of the pointer to the structure containing @rhp.
984
+ */
985
+static inline bool
986
+rcu_head_after_call_rcu(struct rcu_head *rhp, rcu_callback_t f)
987
+{
988
+	rcu_callback_t func = READ_ONCE(rhp->func);
989
+
990
+	if (func == f)
991
+		return true;
992
+	WARN_ON_ONCE(func != (rcu_callback_t)~0L);
993
+	return false;
994
+}
995
+
996
+/* kernel/ksysfs.c definitions */
997
+extern int rcu_expedited;
998
+extern int rcu_normal;
999
+
8651000 #endif /* __LINUX_RCUPDATE_H */