Merge branches 'urgent.2012.10.27a', 'doc.2012.11.16a', 'fixes.2012.11.13a', 'srcu...
[linux-3.10.git] / include / linux / rcupdate.h
1 /*
2  * 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, write to the Free Software
16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17  *
18  * Copyright IBM Corporation, 2001
19  *
20  * Author: Dipankar Sarma <dipankar@in.ibm.com>
21  *
22  * Based on the original work by Paul McKenney <paulmck@us.ibm.com>
23  * and inputs from Rusty Russell, Andrea Arcangeli and Andi Kleen.
24  * Papers:
25  * http://www.rdrop.com/users/paulmck/paper/rclockpdcsproof.pdf
26  * http://lse.sourceforge.net/locking/rclock_OLS.2001.05.01c.sc.pdf (OLS2001)
27  *
28  * For detailed explanation of Read-Copy Update mechanism see -
29  *              http://lse.sourceforge.net/locking/rcupdate.html
30  *
31  */
32
33 #ifndef __LINUX_RCUPDATE_H
34 #define __LINUX_RCUPDATE_H
35
36 #include <linux/types.h>
37 #include <linux/cache.h>
38 #include <linux/spinlock.h>
39 #include <linux/threads.h>
40 #include <linux/cpumask.h>
41 #include <linux/seqlock.h>
42 #include <linux/lockdep.h>
43 #include <linux/completion.h>
44 #include <linux/debugobjects.h>
45 #include <linux/bug.h>
46 #include <linux/compiler.h>
47
48 #ifdef CONFIG_RCU_TORTURE_TEST
49 extern int rcutorture_runnable; /* for sysctl */
50 #endif /* #ifdef CONFIG_RCU_TORTURE_TEST */
51
52 #if defined(CONFIG_TREE_RCU) || defined(CONFIG_TREE_PREEMPT_RCU)
53 extern void rcutorture_record_test_transition(void);
54 extern void rcutorture_record_progress(unsigned long vernum);
55 extern void do_trace_rcu_torture_read(char *rcutorturename,
56                                       struct rcu_head *rhp);
57 #else
58 static inline void rcutorture_record_test_transition(void)
59 {
60 }
61 static inline void rcutorture_record_progress(unsigned long vernum)
62 {
63 }
64 #ifdef CONFIG_RCU_TRACE
65 extern void do_trace_rcu_torture_read(char *rcutorturename,
66                                       struct rcu_head *rhp);
67 #else
68 #define do_trace_rcu_torture_read(rcutorturename, rhp) do { } while (0)
69 #endif
70 #endif
71
72 #define UINT_CMP_GE(a, b)       (UINT_MAX / 2 >= (a) - (b))
73 #define UINT_CMP_LT(a, b)       (UINT_MAX / 2 < (a) - (b))
74 #define ULONG_CMP_GE(a, b)      (ULONG_MAX / 2 >= (a) - (b))
75 #define ULONG_CMP_LT(a, b)      (ULONG_MAX / 2 < (a) - (b))
76
77 /* Exported common interfaces */
78
79 #ifdef CONFIG_PREEMPT_RCU
80
81 /**
82  * call_rcu() - Queue an RCU callback for invocation after a grace period.
83  * @head: structure to be used for queueing the RCU updates.
84  * @func: actual callback function to be invoked after the grace period
85  *
86  * The callback function will be invoked some time after a full grace
87  * period elapses, in other words after all pre-existing RCU read-side
88  * critical sections have completed.  However, the callback function
89  * might well execute concurrently with RCU read-side critical sections
90  * that started after call_rcu() was invoked.  RCU read-side critical
91  * sections are delimited by rcu_read_lock() and rcu_read_unlock(),
92  * and may be nested.
93  *
94  * Note that all CPUs must agree that the grace period extended beyond
95  * all pre-existing RCU read-side critical section.  On systems with more
96  * than one CPU, this means that when "func()" is invoked, each CPU is
97  * guaranteed to have executed a full memory barrier since the end of its
98  * last RCU read-side critical section whose beginning preceded the call
99  * to call_rcu().  It also means that each CPU executing an RCU read-side
100  * critical section that continues beyond the start of "func()" must have
101  * executed a memory barrier after the call_rcu() but before the beginning
102  * of that RCU read-side critical section.  Note that these guarantees
103  * include CPUs that are offline, idle, or executing in user mode, as
104  * well as CPUs that are executing in the kernel.
105  *
106  * Furthermore, if CPU A invoked call_rcu() and CPU B invoked the
107  * resulting RCU callback function "func()", then both CPU A and CPU B are
108  * guaranteed to execute a full memory barrier during the time interval
109  * between the call to call_rcu() and the invocation of "func()" -- even
110  * if CPU A and CPU B are the same CPU (but again only if the system has
111  * more than one CPU).
112  */
113 extern void call_rcu(struct rcu_head *head,
114                               void (*func)(struct rcu_head *head));
115
116 #else /* #ifdef CONFIG_PREEMPT_RCU */
117
118 /* In classic RCU, call_rcu() is just call_rcu_sched(). */
119 #define call_rcu        call_rcu_sched
120
121 #endif /* #else #ifdef CONFIG_PREEMPT_RCU */
122
123 /**
124  * call_rcu_bh() - Queue an RCU for invocation after a quicker grace period.
125  * @head: structure to be used for queueing the RCU updates.
126  * @func: actual callback function to be invoked after the grace period
127  *
128  * The callback function will be invoked some time after a full grace
129  * period elapses, in other words after all currently executing RCU
130  * read-side critical sections have completed. call_rcu_bh() assumes
131  * that the read-side critical sections end on completion of a softirq
132  * handler. This means that read-side critical sections in process
133  * context must not be interrupted by softirqs. This interface is to be
134  * used when most of the read-side critical sections are in softirq context.
135  * RCU read-side critical sections are delimited by :
136  *  - rcu_read_lock() and  rcu_read_unlock(), if in interrupt context.
137  *  OR
138  *  - rcu_read_lock_bh() and rcu_read_unlock_bh(), if in process context.
139  *  These may be nested.
140  *
141  * See the description of call_rcu() for more detailed information on
142  * memory ordering guarantees.
143  */
144 extern void call_rcu_bh(struct rcu_head *head,
145                         void (*func)(struct rcu_head *head));
146
147 /**
148  * call_rcu_sched() - Queue an RCU for invocation after sched grace period.
149  * @head: structure to be used for queueing the RCU updates.
150  * @func: actual callback function to be invoked after the grace period
151  *
152  * The callback function will be invoked some time after a full grace
153  * period elapses, in other words after all currently executing RCU
154  * read-side critical sections have completed. call_rcu_sched() assumes
155  * that the read-side critical sections end on enabling of preemption
156  * or on voluntary preemption.
157  * RCU read-side critical sections are delimited by :
158  *  - rcu_read_lock_sched() and  rcu_read_unlock_sched(),
159  *  OR
160  *  anything that disables preemption.
161  *  These may be nested.
162  *
163  * See the description of call_rcu() for more detailed information on
164  * memory ordering guarantees.
165  */
166 extern void call_rcu_sched(struct rcu_head *head,
167                            void (*func)(struct rcu_head *rcu));
168
169 extern void synchronize_sched(void);
170
171 #ifdef CONFIG_PREEMPT_RCU
172
173 extern void __rcu_read_lock(void);
174 extern void __rcu_read_unlock(void);
175 extern void rcu_read_unlock_special(struct task_struct *t);
176 void synchronize_rcu(void);
177
178 /*
179  * Defined as a macro as it is a very low level header included from
180  * areas that don't even know about current.  This gives the rcu_read_lock()
181  * nesting depth, but makes sense only if CONFIG_PREEMPT_RCU -- in other
182  * types of kernel builds, the rcu_read_lock() nesting depth is unknowable.
183  */
184 #define rcu_preempt_depth() (current->rcu_read_lock_nesting)
185
186 #else /* #ifdef CONFIG_PREEMPT_RCU */
187
188 static inline void __rcu_read_lock(void)
189 {
190         preempt_disable();
191 }
192
193 static inline void __rcu_read_unlock(void)
194 {
195         preempt_enable();
196 }
197
198 static inline void synchronize_rcu(void)
199 {
200         synchronize_sched();
201 }
202
203 static inline int rcu_preempt_depth(void)
204 {
205         return 0;
206 }
207
208 #endif /* #else #ifdef CONFIG_PREEMPT_RCU */
209
210 /* Internal to kernel */
211 extern void rcu_sched_qs(int cpu);
212 extern void rcu_bh_qs(int cpu);
213 extern void rcu_check_callbacks(int cpu, int user);
214 struct notifier_block;
215 extern void rcu_idle_enter(void);
216 extern void rcu_idle_exit(void);
217 extern void rcu_irq_enter(void);
218 extern void rcu_irq_exit(void);
219
220 #ifdef CONFIG_RCU_USER_QS
221 extern void rcu_user_enter(void);
222 extern void rcu_user_exit(void);
223 extern void rcu_user_enter_after_irq(void);
224 extern void rcu_user_exit_after_irq(void);
225 extern void rcu_user_hooks_switch(struct task_struct *prev,
226                                   struct task_struct *next);
227 #else
228 static inline void rcu_user_enter(void) { }
229 static inline void rcu_user_exit(void) { }
230 static inline void rcu_user_enter_after_irq(void) { }
231 static inline void rcu_user_exit_after_irq(void) { }
232 static inline void rcu_user_hooks_switch(struct task_struct *prev,
233                                          struct task_struct *next) { }
234 #endif /* CONFIG_RCU_USER_QS */
235
236 extern void exit_rcu(void);
237
238 /**
239  * RCU_NONIDLE - Indicate idle-loop code that needs RCU readers
240  * @a: Code that RCU needs to pay attention to.
241  *
242  * RCU, RCU-bh, and RCU-sched read-side critical sections are forbidden
243  * in the inner idle loop, that is, between the rcu_idle_enter() and
244  * the rcu_idle_exit() -- RCU will happily ignore any such read-side
245  * critical sections.  However, things like powertop need tracepoints
246  * in the inner idle loop.
247  *
248  * This macro provides the way out:  RCU_NONIDLE(do_something_with_RCU())
249  * will tell RCU that it needs to pay attending, invoke its argument
250  * (in this example, a call to the do_something_with_RCU() function),
251  * and then tell RCU to go back to ignoring this CPU.  It is permissible
252  * to nest RCU_NONIDLE() wrappers, but the nesting level is currently
253  * quite limited.  If deeper nesting is required, it will be necessary
254  * to adjust DYNTICK_TASK_NESTING_VALUE accordingly.
255  */
256 #define RCU_NONIDLE(a) \
257         do { \
258                 rcu_irq_enter(); \
259                 do { a; } while (0); \
260                 rcu_irq_exit(); \
261         } while (0)
262
263 /*
264  * Infrastructure to implement the synchronize_() primitives in
265  * TREE_RCU and rcu_barrier_() primitives in TINY_RCU.
266  */
267
268 typedef void call_rcu_func_t(struct rcu_head *head,
269                              void (*func)(struct rcu_head *head));
270 void wait_rcu_gp(call_rcu_func_t crf);
271
272 #if defined(CONFIG_TREE_RCU) || defined(CONFIG_TREE_PREEMPT_RCU)
273 #include <linux/rcutree.h>
274 #elif defined(CONFIG_TINY_RCU) || defined(CONFIG_TINY_PREEMPT_RCU)
275 #include <linux/rcutiny.h>
276 #else
277 #error "Unknown RCU implementation specified to kernel configuration"
278 #endif
279
280 /*
281  * init_rcu_head_on_stack()/destroy_rcu_head_on_stack() are needed for dynamic
282  * initialization and destruction of rcu_head on the stack. rcu_head structures
283  * allocated dynamically in the heap or defined statically don't need any
284  * initialization.
285  */
286 #ifdef CONFIG_DEBUG_OBJECTS_RCU_HEAD
287 extern void init_rcu_head_on_stack(struct rcu_head *head);
288 extern void destroy_rcu_head_on_stack(struct rcu_head *head);
289 #else /* !CONFIG_DEBUG_OBJECTS_RCU_HEAD */
290 static inline void init_rcu_head_on_stack(struct rcu_head *head)
291 {
292 }
293
294 static inline void destroy_rcu_head_on_stack(struct rcu_head *head)
295 {
296 }
297 #endif  /* #else !CONFIG_DEBUG_OBJECTS_RCU_HEAD */
298
299 #if defined(CONFIG_DEBUG_LOCK_ALLOC) || defined(CONFIG_SMP)
300 extern int rcu_is_cpu_idle(void);
301 #endif /* #if defined(CONFIG_DEBUG_LOCK_ALLOC) || defined(CONFIG_SMP) */
302
303 #if defined(CONFIG_HOTPLUG_CPU) && defined(CONFIG_PROVE_RCU)
304 bool rcu_lockdep_current_cpu_online(void);
305 #else /* #if defined(CONFIG_HOTPLUG_CPU) && defined(CONFIG_PROVE_RCU) */
306 static inline bool rcu_lockdep_current_cpu_online(void)
307 {
308         return 1;
309 }
310 #endif /* #else #if defined(CONFIG_HOTPLUG_CPU) && defined(CONFIG_PROVE_RCU) */
311
312 #ifdef CONFIG_DEBUG_LOCK_ALLOC
313
314 static inline void rcu_lock_acquire(struct lockdep_map *map)
315 {
316         lock_acquire(map, 0, 0, 2, 1, NULL, _THIS_IP_);
317 }
318
319 static inline void rcu_lock_release(struct lockdep_map *map)
320 {
321         lock_release(map, 1, _THIS_IP_);
322 }
323
324 extern struct lockdep_map rcu_lock_map;
325 extern struct lockdep_map rcu_bh_lock_map;
326 extern struct lockdep_map rcu_sched_lock_map;
327 extern int debug_lockdep_rcu_enabled(void);
328
329 /**
330  * rcu_read_lock_held() - might we be in RCU read-side critical section?
331  *
332  * If CONFIG_DEBUG_LOCK_ALLOC is selected, returns nonzero iff in an RCU
333  * read-side critical section.  In absence of CONFIG_DEBUG_LOCK_ALLOC,
334  * this assumes we are in an RCU read-side critical section unless it can
335  * prove otherwise.  This is useful for debug checks in functions that
336  * require that they be called within an RCU read-side critical section.
337  *
338  * Checks debug_lockdep_rcu_enabled() to prevent false positives during boot
339  * and while lockdep is disabled.
340  *
341  * Note that rcu_read_lock() and the matching rcu_read_unlock() must
342  * occur in the same context, for example, it is illegal to invoke
343  * rcu_read_unlock() in process context if the matching rcu_read_lock()
344  * was invoked from within an irq handler.
345  *
346  * Note that rcu_read_lock() is disallowed if the CPU is either idle or
347  * offline from an RCU perspective, so check for those as well.
348  */
349 static inline int rcu_read_lock_held(void)
350 {
351         if (!debug_lockdep_rcu_enabled())
352                 return 1;
353         if (rcu_is_cpu_idle())
354                 return 0;
355         if (!rcu_lockdep_current_cpu_online())
356                 return 0;
357         return lock_is_held(&rcu_lock_map);
358 }
359
360 /*
361  * rcu_read_lock_bh_held() is defined out of line to avoid #include-file
362  * hell.
363  */
364 extern int rcu_read_lock_bh_held(void);
365
366 /**
367  * rcu_read_lock_sched_held() - might we be in RCU-sched read-side critical section?
368  *
369  * If CONFIG_DEBUG_LOCK_ALLOC is selected, returns nonzero iff in an
370  * RCU-sched read-side critical section.  In absence of
371  * CONFIG_DEBUG_LOCK_ALLOC, this assumes we are in an RCU-sched read-side
372  * critical section unless it can prove otherwise.  Note that disabling
373  * of preemption (including disabling irqs) counts as an RCU-sched
374  * read-side critical section.  This is useful for debug checks in functions
375  * that required that they be called within an RCU-sched read-side
376  * critical section.
377  *
378  * Check debug_lockdep_rcu_enabled() to prevent false positives during boot
379  * and while lockdep is disabled.
380  *
381  * Note that if the CPU is in the idle loop from an RCU point of
382  * view (ie: that we are in the section between rcu_idle_enter() and
383  * rcu_idle_exit()) then rcu_read_lock_held() returns false even if the CPU
384  * did an rcu_read_lock().  The reason for this is that RCU ignores CPUs
385  * that are in such a section, considering these as in extended quiescent
386  * state, so such a CPU is effectively never in an RCU read-side critical
387  * section regardless of what RCU primitives it invokes.  This state of
388  * affairs is required --- we need to keep an RCU-free window in idle
389  * where the CPU may possibly enter into low power mode. This way we can
390  * notice an extended quiescent state to other CPUs that started a grace
391  * period. Otherwise we would delay any grace period as long as we run in
392  * the idle task.
393  *
394  * Similarly, we avoid claiming an SRCU read lock held if the current
395  * CPU is offline.
396  */
397 #ifdef CONFIG_PREEMPT_COUNT
398 static inline int rcu_read_lock_sched_held(void)
399 {
400         int lockdep_opinion = 0;
401
402         if (!debug_lockdep_rcu_enabled())
403                 return 1;
404         if (rcu_is_cpu_idle())
405                 return 0;
406         if (!rcu_lockdep_current_cpu_online())
407                 return 0;
408         if (debug_locks)
409                 lockdep_opinion = lock_is_held(&rcu_sched_lock_map);
410         return lockdep_opinion || preempt_count() != 0 || irqs_disabled();
411 }
412 #else /* #ifdef CONFIG_PREEMPT_COUNT */
413 static inline int rcu_read_lock_sched_held(void)
414 {
415         return 1;
416 }
417 #endif /* #else #ifdef CONFIG_PREEMPT_COUNT */
418
419 #else /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
420
421 # define rcu_lock_acquire(a)            do { } while (0)
422 # define rcu_lock_release(a)            do { } while (0)
423
424 static inline int rcu_read_lock_held(void)
425 {
426         return 1;
427 }
428
429 static inline int rcu_read_lock_bh_held(void)
430 {
431         return 1;
432 }
433
434 #ifdef CONFIG_PREEMPT_COUNT
435 static inline int rcu_read_lock_sched_held(void)
436 {
437         return preempt_count() != 0 || irqs_disabled();
438 }
439 #else /* #ifdef CONFIG_PREEMPT_COUNT */
440 static inline int rcu_read_lock_sched_held(void)
441 {
442         return 1;
443 }
444 #endif /* #else #ifdef CONFIG_PREEMPT_COUNT */
445
446 #endif /* #else #ifdef CONFIG_DEBUG_LOCK_ALLOC */
447
448 #ifdef CONFIG_PROVE_RCU
449
450 extern int rcu_my_thread_group_empty(void);
451
452 /**
453  * rcu_lockdep_assert - emit lockdep splat if specified condition not met
454  * @c: condition to check
455  * @s: informative message
456  */
457 #define rcu_lockdep_assert(c, s)                                        \
458         do {                                                            \
459                 static bool __section(.data.unlikely) __warned;         \
460                 if (debug_lockdep_rcu_enabled() && !__warned && !(c)) { \
461                         __warned = true;                                \
462                         lockdep_rcu_suspicious(__FILE__, __LINE__, s);  \
463                 }                                                       \
464         } while (0)
465
466 #if defined(CONFIG_PROVE_RCU) && !defined(CONFIG_PREEMPT_RCU)
467 static inline void rcu_preempt_sleep_check(void)
468 {
469         rcu_lockdep_assert(!lock_is_held(&rcu_lock_map),
470                            "Illegal context switch in RCU read-side critical section");
471 }
472 #else /* #ifdef CONFIG_PROVE_RCU */
473 static inline void rcu_preempt_sleep_check(void)
474 {
475 }
476 #endif /* #else #ifdef CONFIG_PROVE_RCU */
477
478 #define rcu_sleep_check()                                               \
479         do {                                                            \
480                 rcu_preempt_sleep_check();                              \
481                 rcu_lockdep_assert(!lock_is_held(&rcu_bh_lock_map),     \
482                                    "Illegal context switch in RCU-bh"   \
483                                    " read-side critical section");      \
484                 rcu_lockdep_assert(!lock_is_held(&rcu_sched_lock_map),  \
485                                    "Illegal context switch in RCU-sched"\
486                                    " read-side critical section");      \
487         } while (0)
488
489 #else /* #ifdef CONFIG_PROVE_RCU */
490
491 #define rcu_lockdep_assert(c, s) do { } while (0)
492 #define rcu_sleep_check() do { } while (0)
493
494 #endif /* #else #ifdef CONFIG_PROVE_RCU */
495
496 /*
497  * Helper functions for rcu_dereference_check(), rcu_dereference_protected()
498  * and rcu_assign_pointer().  Some of these could be folded into their
499  * callers, but they are left separate in order to ease introduction of
500  * multiple flavors of pointers to match the multiple flavors of RCU
501  * (e.g., __rcu_bh, * __rcu_sched, and __srcu), should this make sense in
502  * the future.
503  */
504
505 #ifdef __CHECKER__
506 #define rcu_dereference_sparse(p, space) \
507         ((void)(((typeof(*p) space *)p) == p))
508 #else /* #ifdef __CHECKER__ */
509 #define rcu_dereference_sparse(p, space)
510 #endif /* #else #ifdef __CHECKER__ */
511
512 #define __rcu_access_pointer(p, space) \
513         ({ \
514                 typeof(*p) *_________p1 = (typeof(*p)*__force )ACCESS_ONCE(p); \
515                 rcu_dereference_sparse(p, space); \
516                 ((typeof(*p) __force __kernel *)(_________p1)); \
517         })
518 #define __rcu_dereference_check(p, c, space) \
519         ({ \
520                 typeof(*p) *_________p1 = (typeof(*p)*__force )ACCESS_ONCE(p); \
521                 rcu_lockdep_assert(c, "suspicious rcu_dereference_check()" \
522                                       " usage"); \
523                 rcu_dereference_sparse(p, space); \
524                 smp_read_barrier_depends(); \
525                 ((typeof(*p) __force __kernel *)(_________p1)); \
526         })
527 #define __rcu_dereference_protected(p, c, space) \
528         ({ \
529                 rcu_lockdep_assert(c, "suspicious rcu_dereference_protected()" \
530                                       " usage"); \
531                 rcu_dereference_sparse(p, space); \
532                 ((typeof(*p) __force __kernel *)(p)); \
533         })
534
535 #define __rcu_access_index(p, space) \
536         ({ \
537                 typeof(p) _________p1 = ACCESS_ONCE(p); \
538                 rcu_dereference_sparse(p, space); \
539                 (_________p1); \
540         })
541 #define __rcu_dereference_index_check(p, c) \
542         ({ \
543                 typeof(p) _________p1 = ACCESS_ONCE(p); \
544                 rcu_lockdep_assert(c, \
545                                    "suspicious rcu_dereference_index_check()" \
546                                    " usage"); \
547                 smp_read_barrier_depends(); \
548                 (_________p1); \
549         })
550 #define __rcu_assign_pointer(p, v, space) \
551         do { \
552                 smp_wmb(); \
553                 (p) = (typeof(*v) __force space *)(v); \
554         } while (0)
555
556
557 /**
558  * rcu_access_pointer() - fetch RCU pointer with no dereferencing
559  * @p: The pointer to read
560  *
561  * Return the value of the specified RCU-protected pointer, but omit the
562  * smp_read_barrier_depends() and keep the ACCESS_ONCE().  This is useful
563  * when the value of this pointer is accessed, but the pointer is not
564  * dereferenced, for example, when testing an RCU-protected pointer against
565  * NULL.  Although rcu_access_pointer() may also be used in cases where
566  * update-side locks prevent the value of the pointer from changing, you
567  * should instead use rcu_dereference_protected() for this use case.
568  *
569  * It is also permissible to use rcu_access_pointer() when read-side
570  * access to the pointer was removed at least one grace period ago, as
571  * is the case in the context of the RCU callback that is freeing up
572  * the data, or after a synchronize_rcu() returns.  This can be useful
573  * when tearing down multi-linked structures after a grace period
574  * has elapsed.
575  */
576 #define rcu_access_pointer(p) __rcu_access_pointer((p), __rcu)
577
578 /**
579  * rcu_dereference_check() - rcu_dereference with debug checking
580  * @p: The pointer to read, prior to dereferencing
581  * @c: The conditions under which the dereference will take place
582  *
583  * Do an rcu_dereference(), but check that the conditions under which the
584  * dereference will take place are correct.  Typically the conditions
585  * indicate the various locking conditions that should be held at that
586  * point.  The check should return true if the conditions are satisfied.
587  * An implicit check for being in an RCU read-side critical section
588  * (rcu_read_lock()) is included.
589  *
590  * For example:
591  *
592  *      bar = rcu_dereference_check(foo->bar, lockdep_is_held(&foo->lock));
593  *
594  * could be used to indicate to lockdep that foo->bar may only be dereferenced
595  * if either rcu_read_lock() is held, or that the lock required to replace
596  * the bar struct at foo->bar is held.
597  *
598  * Note that the list of conditions may also include indications of when a lock
599  * need not be held, for example during initialisation or destruction of the
600  * target struct:
601  *
602  *      bar = rcu_dereference_check(foo->bar, lockdep_is_held(&foo->lock) ||
603  *                                            atomic_read(&foo->usage) == 0);
604  *
605  * Inserts memory barriers on architectures that require them
606  * (currently only the Alpha), prevents the compiler from refetching
607  * (and from merging fetches), and, more importantly, documents exactly
608  * which pointers are protected by RCU and checks that the pointer is
609  * annotated as __rcu.
610  */
611 #define rcu_dereference_check(p, c) \
612         __rcu_dereference_check((p), rcu_read_lock_held() || (c), __rcu)
613
614 /**
615  * rcu_dereference_bh_check() - rcu_dereference_bh with debug checking
616  * @p: The pointer to read, prior to dereferencing
617  * @c: The conditions under which the dereference will take place
618  *
619  * This is the RCU-bh counterpart to rcu_dereference_check().
620  */
621 #define rcu_dereference_bh_check(p, c) \
622         __rcu_dereference_check((p), rcu_read_lock_bh_held() || (c), __rcu)
623
624 /**
625  * rcu_dereference_sched_check() - rcu_dereference_sched with debug checking
626  * @p: The pointer to read, prior to dereferencing
627  * @c: The conditions under which the dereference will take place
628  *
629  * This is the RCU-sched counterpart to rcu_dereference_check().
630  */
631 #define rcu_dereference_sched_check(p, c) \
632         __rcu_dereference_check((p), rcu_read_lock_sched_held() || (c), \
633                                 __rcu)
634
635 #define rcu_dereference_raw(p) rcu_dereference_check(p, 1) /*@@@ needed? @@@*/
636
637 /**
638  * rcu_access_index() - fetch RCU index with no dereferencing
639  * @p: The index to read
640  *
641  * Return the value of the specified RCU-protected index, but omit the
642  * smp_read_barrier_depends() and keep the ACCESS_ONCE().  This is useful
643  * when the value of this index is accessed, but the index is not
644  * dereferenced, for example, when testing an RCU-protected index against
645  * -1.  Although rcu_access_index() may also be used in cases where
646  * update-side locks prevent the value of the index from changing, you
647  * should instead use rcu_dereference_index_protected() for this use case.
648  */
649 #define rcu_access_index(p) __rcu_access_index((p), __rcu)
650
651 /**
652  * rcu_dereference_index_check() - rcu_dereference for indices with debug checking
653  * @p: The pointer to read, prior to dereferencing
654  * @c: The conditions under which the dereference will take place
655  *
656  * Similar to rcu_dereference_check(), but omits the sparse checking.
657  * This allows rcu_dereference_index_check() to be used on integers,
658  * which can then be used as array indices.  Attempting to use
659  * rcu_dereference_check() on an integer will give compiler warnings
660  * because the sparse address-space mechanism relies on dereferencing
661  * the RCU-protected pointer.  Dereferencing integers is not something
662  * that even gcc will put up with.
663  *
664  * Note that this function does not implicitly check for RCU read-side
665  * critical sections.  If this function gains lots of uses, it might
666  * make sense to provide versions for each flavor of RCU, but it does
667  * not make sense as of early 2010.
668  */
669 #define rcu_dereference_index_check(p, c) \
670         __rcu_dereference_index_check((p), (c))
671
672 /**
673  * rcu_dereference_protected() - fetch RCU pointer when updates prevented
674  * @p: The pointer to read, prior to dereferencing
675  * @c: The conditions under which the dereference will take place
676  *
677  * Return the value of the specified RCU-protected pointer, but omit
678  * both the smp_read_barrier_depends() and the ACCESS_ONCE().  This
679  * is useful in cases where update-side locks prevent the value of the
680  * pointer from changing.  Please note that this primitive does -not-
681  * prevent the compiler from repeating this reference or combining it
682  * with other references, so it should not be used without protection
683  * of appropriate locks.
684  *
685  * This function is only for update-side use.  Using this function
686  * when protected only by rcu_read_lock() will result in infrequent
687  * but very ugly failures.
688  */
689 #define rcu_dereference_protected(p, c) \
690         __rcu_dereference_protected((p), (c), __rcu)
691
692
693 /**
694  * rcu_dereference() - fetch RCU-protected pointer for dereferencing
695  * @p: The pointer to read, prior to dereferencing
696  *
697  * This is a simple wrapper around rcu_dereference_check().
698  */
699 #define rcu_dereference(p) rcu_dereference_check(p, 0)
700
701 /**
702  * rcu_dereference_bh() - fetch an RCU-bh-protected pointer for dereferencing
703  * @p: The pointer to read, prior to dereferencing
704  *
705  * Makes rcu_dereference_check() do the dirty work.
706  */
707 #define rcu_dereference_bh(p) rcu_dereference_bh_check(p, 0)
708
709 /**
710  * rcu_dereference_sched() - fetch RCU-sched-protected pointer for dereferencing
711  * @p: The pointer to read, prior to dereferencing
712  *
713  * Makes rcu_dereference_check() do the dirty work.
714  */
715 #define rcu_dereference_sched(p) rcu_dereference_sched_check(p, 0)
716
717 /**
718  * rcu_read_lock() - mark the beginning of an RCU read-side critical section
719  *
720  * When synchronize_rcu() is invoked on one CPU while other CPUs
721  * are within RCU read-side critical sections, then the
722  * synchronize_rcu() is guaranteed to block until after all the other
723  * CPUs exit their critical sections.  Similarly, if call_rcu() is invoked
724  * on one CPU while other CPUs are within RCU read-side critical
725  * sections, invocation of the corresponding RCU callback is deferred
726  * until after the all the other CPUs exit their critical sections.
727  *
728  * Note, however, that RCU callbacks are permitted to run concurrently
729  * with new RCU read-side critical sections.  One way that this can happen
730  * is via the following sequence of events: (1) CPU 0 enters an RCU
731  * read-side critical section, (2) CPU 1 invokes call_rcu() to register
732  * an RCU callback, (3) CPU 0 exits the RCU read-side critical section,
733  * (4) CPU 2 enters a RCU read-side critical section, (5) the RCU
734  * callback is invoked.  This is legal, because the RCU read-side critical
735  * section that was running concurrently with the call_rcu() (and which
736  * therefore might be referencing something that the corresponding RCU
737  * callback would free up) has completed before the corresponding
738  * RCU callback is invoked.
739  *
740  * RCU read-side critical sections may be nested.  Any deferred actions
741  * will be deferred until the outermost RCU read-side critical section
742  * completes.
743  *
744  * You can avoid reading and understanding the next paragraph by
745  * following this rule: don't put anything in an rcu_read_lock() RCU
746  * read-side critical section that would block in a !PREEMPT kernel.
747  * But if you want the full story, read on!
748  *
749  * In non-preemptible RCU implementations (TREE_RCU and TINY_RCU), it
750  * is illegal to block while in an RCU read-side critical section.  In
751  * preemptible RCU implementations (TREE_PREEMPT_RCU and TINY_PREEMPT_RCU)
752  * in CONFIG_PREEMPT kernel builds, RCU read-side critical sections may
753  * be preempted, but explicit blocking is illegal.  Finally, in preemptible
754  * RCU implementations in real-time (CONFIG_PREEMPT_RT) kernel builds,
755  * RCU read-side critical sections may be preempted and they may also
756  * block, but only when acquiring spinlocks that are subject to priority
757  * inheritance.
758  */
759 static inline void rcu_read_lock(void)
760 {
761         __rcu_read_lock();
762         __acquire(RCU);
763         rcu_lock_acquire(&rcu_lock_map);
764         rcu_lockdep_assert(!rcu_is_cpu_idle(),
765                            "rcu_read_lock() used illegally while idle");
766 }
767
768 /*
769  * So where is rcu_write_lock()?  It does not exist, as there is no
770  * way for writers to lock out RCU readers.  This is a feature, not
771  * a bug -- this property is what provides RCU's performance benefits.
772  * Of course, writers must coordinate with each other.  The normal
773  * spinlock primitives work well for this, but any other technique may be
774  * used as well.  RCU does not care how the writers keep out of each
775  * others' way, as long as they do so.
776  */
777
778 /**
779  * rcu_read_unlock() - marks the end of an RCU read-side critical section.
780  *
781  * See rcu_read_lock() for more information.
782  */
783 static inline void rcu_read_unlock(void)
784 {
785         rcu_lockdep_assert(!rcu_is_cpu_idle(),
786                            "rcu_read_unlock() used illegally while idle");
787         rcu_lock_release(&rcu_lock_map);
788         __release(RCU);
789         __rcu_read_unlock();
790 }
791
792 /**
793  * rcu_read_lock_bh() - mark the beginning of an RCU-bh critical section
794  *
795  * This is equivalent of rcu_read_lock(), but to be used when updates
796  * are being done using call_rcu_bh() or synchronize_rcu_bh(). Since
797  * both call_rcu_bh() and synchronize_rcu_bh() consider completion of a
798  * softirq handler to be a quiescent state, a process in RCU read-side
799  * critical section must be protected by disabling softirqs. Read-side
800  * critical sections in interrupt context can use just rcu_read_lock(),
801  * though this should at least be commented to avoid confusing people
802  * reading the code.
803  *
804  * Note that rcu_read_lock_bh() and the matching rcu_read_unlock_bh()
805  * must occur in the same context, for example, it is illegal to invoke
806  * rcu_read_unlock_bh() from one task if the matching rcu_read_lock_bh()
807  * was invoked from some other task.
808  */
809 static inline void rcu_read_lock_bh(void)
810 {
811         local_bh_disable();
812         __acquire(RCU_BH);
813         rcu_lock_acquire(&rcu_bh_lock_map);
814         rcu_lockdep_assert(!rcu_is_cpu_idle(),
815                            "rcu_read_lock_bh() used illegally while idle");
816 }
817
818 /*
819  * rcu_read_unlock_bh - marks the end of a softirq-only RCU critical section
820  *
821  * See rcu_read_lock_bh() for more information.
822  */
823 static inline void rcu_read_unlock_bh(void)
824 {
825         rcu_lockdep_assert(!rcu_is_cpu_idle(),
826                            "rcu_read_unlock_bh() used illegally while idle");
827         rcu_lock_release(&rcu_bh_lock_map);
828         __release(RCU_BH);
829         local_bh_enable();
830 }
831
832 /**
833  * rcu_read_lock_sched() - mark the beginning of a RCU-sched critical section
834  *
835  * This is equivalent of rcu_read_lock(), but to be used when updates
836  * are being done using call_rcu_sched() or synchronize_rcu_sched().
837  * Read-side critical sections can also be introduced by anything that
838  * disables preemption, including local_irq_disable() and friends.
839  *
840  * Note that rcu_read_lock_sched() and the matching rcu_read_unlock_sched()
841  * must occur in the same context, for example, it is illegal to invoke
842  * rcu_read_unlock_sched() from process context if the matching
843  * rcu_read_lock_sched() was invoked from an NMI handler.
844  */
845 static inline void rcu_read_lock_sched(void)
846 {
847         preempt_disable();
848         __acquire(RCU_SCHED);
849         rcu_lock_acquire(&rcu_sched_lock_map);
850         rcu_lockdep_assert(!rcu_is_cpu_idle(),
851                            "rcu_read_lock_sched() used illegally while idle");
852 }
853
854 /* Used by lockdep and tracing: cannot be traced, cannot call lockdep. */
855 static inline notrace void rcu_read_lock_sched_notrace(void)
856 {
857         preempt_disable_notrace();
858         __acquire(RCU_SCHED);
859 }
860
861 /*
862  * rcu_read_unlock_sched - marks the end of a RCU-classic critical section
863  *
864  * See rcu_read_lock_sched for more information.
865  */
866 static inline void rcu_read_unlock_sched(void)
867 {
868         rcu_lockdep_assert(!rcu_is_cpu_idle(),
869                            "rcu_read_unlock_sched() used illegally while idle");
870         rcu_lock_release(&rcu_sched_lock_map);
871         __release(RCU_SCHED);
872         preempt_enable();
873 }
874
875 /* Used by lockdep and tracing: cannot be traced, cannot call lockdep. */
876 static inline notrace void rcu_read_unlock_sched_notrace(void)
877 {
878         __release(RCU_SCHED);
879         preempt_enable_notrace();
880 }
881
882 /**
883  * rcu_assign_pointer() - assign to RCU-protected pointer
884  * @p: pointer to assign to
885  * @v: value to assign (publish)
886  *
887  * Assigns the specified value to the specified RCU-protected
888  * pointer, ensuring that any concurrent RCU readers will see
889  * any prior initialization.
890  *
891  * Inserts memory barriers on architectures that require them
892  * (which is most of them), and also prevents the compiler from
893  * reordering the code that initializes the structure after the pointer
894  * assignment.  More importantly, this call documents which pointers
895  * will be dereferenced by RCU read-side code.
896  *
897  * In some special cases, you may use RCU_INIT_POINTER() instead
898  * of rcu_assign_pointer().  RCU_INIT_POINTER() is a bit faster due
899  * to the fact that it does not constrain either the CPU or the compiler.
900  * That said, using RCU_INIT_POINTER() when you should have used
901  * rcu_assign_pointer() is a very bad thing that results in
902  * impossible-to-diagnose memory corruption.  So please be careful.
903  * See the RCU_INIT_POINTER() comment header for details.
904  */
905 #define rcu_assign_pointer(p, v) \
906         __rcu_assign_pointer((p), (v), __rcu)
907
908 /**
909  * RCU_INIT_POINTER() - initialize an RCU protected pointer
910  *
911  * Initialize an RCU-protected pointer in special cases where readers
912  * do not need ordering constraints on the CPU or the compiler.  These
913  * special cases are:
914  *
915  * 1.   This use of RCU_INIT_POINTER() is NULLing out the pointer -or-
916  * 2.   The caller has taken whatever steps are required to prevent
917  *      RCU readers from concurrently accessing this pointer -or-
918  * 3.   The referenced data structure has already been exposed to
919  *      readers either at compile time or via rcu_assign_pointer() -and-
920  *      a.      You have not made -any- reader-visible changes to
921  *              this structure since then -or-
922  *      b.      It is OK for readers accessing this structure from its
923  *              new location to see the old state of the structure.  (For
924  *              example, the changes were to statistical counters or to
925  *              other state where exact synchronization is not required.)
926  *
927  * Failure to follow these rules governing use of RCU_INIT_POINTER() will
928  * result in impossible-to-diagnose memory corruption.  As in the structures
929  * will look OK in crash dumps, but any concurrent RCU readers might
930  * see pre-initialized values of the referenced data structure.  So
931  * please be very careful how you use RCU_INIT_POINTER()!!!
932  *
933  * If you are creating an RCU-protected linked structure that is accessed
934  * by a single external-to-structure RCU-protected pointer, then you may
935  * use RCU_INIT_POINTER() to initialize the internal RCU-protected
936  * pointers, but you must use rcu_assign_pointer() to initialize the
937  * external-to-structure pointer -after- you have completely initialized
938  * the reader-accessible portions of the linked structure.
939  */
940 #define RCU_INIT_POINTER(p, v) \
941         do { \
942                 p = (typeof(*v) __force __rcu *)(v); \
943         } while (0)
944
945 /**
946  * RCU_POINTER_INITIALIZER() - statically initialize an RCU protected pointer
947  *
948  * GCC-style initialization for an RCU-protected pointer in a structure field.
949  */
950 #define RCU_POINTER_INITIALIZER(p, v) \
951                 .p = (typeof(*v) __force __rcu *)(v)
952
953 /*
954  * Does the specified offset indicate that the corresponding rcu_head
955  * structure can be handled by kfree_rcu()?
956  */
957 #define __is_kfree_rcu_offset(offset) ((offset) < 4096)
958
959 /*
960  * Helper macro for kfree_rcu() to prevent argument-expansion eyestrain.
961  */
962 #define __kfree_rcu(head, offset) \
963         do { \
964                 BUILD_BUG_ON(!__is_kfree_rcu_offset(offset)); \
965                 kfree_call_rcu(head, (void (*)(struct rcu_head *))(unsigned long)(offset)); \
966         } while (0)
967
968 /**
969  * kfree_rcu() - kfree an object after a grace period.
970  * @ptr:        pointer to kfree
971  * @rcu_head:   the name of the struct rcu_head within the type of @ptr.
972  *
973  * Many rcu callbacks functions just call kfree() on the base structure.
974  * These functions are trivial, but their size adds up, and furthermore
975  * when they are used in a kernel module, that module must invoke the
976  * high-latency rcu_barrier() function at module-unload time.
977  *
978  * The kfree_rcu() function handles this issue.  Rather than encoding a
979  * function address in the embedded rcu_head structure, kfree_rcu() instead
980  * encodes the offset of the rcu_head structure within the base structure.
981  * Because the functions are not allowed in the low-order 4096 bytes of
982  * kernel virtual memory, offsets up to 4095 bytes can be accommodated.
983  * If the offset is larger than 4095 bytes, a compile-time error will
984  * be generated in __kfree_rcu().  If this error is triggered, you can
985  * either fall back to use of call_rcu() or rearrange the structure to
986  * position the rcu_head structure into the first 4096 bytes.
987  *
988  * Note that the allowable offset might decrease in the future, for example,
989  * to allow something like kmem_cache_free_rcu().
990  *
991  * The BUILD_BUG_ON check must not involve any function calls, hence the
992  * checks are done in macros here.
993  */
994 #define kfree_rcu(ptr, rcu_head)                                        \
995         __kfree_rcu(&((ptr)->rcu_head), offsetof(typeof(*(ptr)), rcu_head))
996
997 #endif /* __LINUX_RCUPDATE_H */