rcu: Add a TINY_PREEMPT_RCU
[linux-2.6.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/cache.h>
37 #include <linux/spinlock.h>
38 #include <linux/threads.h>
39 #include <linux/cpumask.h>
40 #include <linux/seqlock.h>
41 #include <linux/lockdep.h>
42 #include <linux/completion.h>
43 #include <linux/debugobjects.h>
44 #include <linux/compiler.h>
45
46 #ifdef CONFIG_RCU_TORTURE_TEST
47 extern int rcutorture_runnable; /* for sysctl */
48 #endif /* #ifdef CONFIG_RCU_TORTURE_TEST */
49
50 /**
51  * struct rcu_head - callback structure for use with RCU
52  * @next: next update requests in a list
53  * @func: actual update function to call after the grace period.
54  */
55 struct rcu_head {
56         struct rcu_head *next;
57         void (*func)(struct rcu_head *head);
58 };
59
60 /* Exported common interfaces */
61 extern void rcu_barrier_bh(void);
62 extern void rcu_barrier_sched(void);
63 extern void synchronize_sched_expedited(void);
64 extern int sched_expedited_torture_stats(char *page);
65
66 /* Internal to kernel */
67 extern void rcu_init(void);
68
69 #if defined(CONFIG_TREE_RCU) || defined(CONFIG_TREE_PREEMPT_RCU)
70 #include <linux/rcutree.h>
71 #elif defined(CONFIG_TINY_RCU) || defined(CONFIG_TINY_PREEMPT_RCU)
72 #include <linux/rcutiny.h>
73 #else
74 #error "Unknown RCU implementation specified to kernel configuration"
75 #endif
76
77 /*
78  * init_rcu_head_on_stack()/destroy_rcu_head_on_stack() are needed for dynamic
79  * initialization and destruction of rcu_head on the stack. rcu_head structures
80  * allocated dynamically in the heap or defined statically don't need any
81  * initialization.
82  */
83 #ifdef CONFIG_DEBUG_OBJECTS_RCU_HEAD
84 extern void init_rcu_head_on_stack(struct rcu_head *head);
85 extern void destroy_rcu_head_on_stack(struct rcu_head *head);
86 #else /* !CONFIG_DEBUG_OBJECTS_RCU_HEAD */
87 static inline void init_rcu_head_on_stack(struct rcu_head *head)
88 {
89 }
90
91 static inline void destroy_rcu_head_on_stack(struct rcu_head *head)
92 {
93 }
94 #endif  /* #else !CONFIG_DEBUG_OBJECTS_RCU_HEAD */
95
96 #ifdef CONFIG_DEBUG_LOCK_ALLOC
97
98 extern struct lockdep_map rcu_lock_map;
99 # define rcu_read_acquire() \
100                 lock_acquire(&rcu_lock_map, 0, 0, 2, 1, NULL, _THIS_IP_)
101 # define rcu_read_release()     lock_release(&rcu_lock_map, 1, _THIS_IP_)
102
103 extern struct lockdep_map rcu_bh_lock_map;
104 # define rcu_read_acquire_bh() \
105                 lock_acquire(&rcu_bh_lock_map, 0, 0, 2, 1, NULL, _THIS_IP_)
106 # define rcu_read_release_bh()  lock_release(&rcu_bh_lock_map, 1, _THIS_IP_)
107
108 extern struct lockdep_map rcu_sched_lock_map;
109 # define rcu_read_acquire_sched() \
110                 lock_acquire(&rcu_sched_lock_map, 0, 0, 2, 1, NULL, _THIS_IP_)
111 # define rcu_read_release_sched() \
112                 lock_release(&rcu_sched_lock_map, 1, _THIS_IP_)
113
114 extern int debug_lockdep_rcu_enabled(void);
115
116 /**
117  * rcu_read_lock_held() - might we be in RCU read-side critical section?
118  *
119  * If CONFIG_DEBUG_LOCK_ALLOC is selected, returns nonzero iff in an RCU
120  * read-side critical section.  In absence of CONFIG_DEBUG_LOCK_ALLOC,
121  * this assumes we are in an RCU read-side critical section unless it can
122  * prove otherwise.  This is useful for debug checks in functions that
123  * require that they be called within an RCU read-side critical section.
124  *
125  * Checks debug_lockdep_rcu_enabled() to prevent false positives during boot
126  * and while lockdep is disabled.
127  */
128 static inline int rcu_read_lock_held(void)
129 {
130         if (!debug_lockdep_rcu_enabled())
131                 return 1;
132         return lock_is_held(&rcu_lock_map);
133 }
134
135 /*
136  * rcu_read_lock_bh_held() is defined out of line to avoid #include-file
137  * hell.
138  */
139 extern int rcu_read_lock_bh_held(void);
140
141 /**
142  * rcu_read_lock_sched_held() - might we be in RCU-sched read-side critical section?
143  *
144  * If CONFIG_DEBUG_LOCK_ALLOC is selected, returns nonzero iff in an
145  * RCU-sched read-side critical section.  In absence of
146  * CONFIG_DEBUG_LOCK_ALLOC, this assumes we are in an RCU-sched read-side
147  * critical section unless it can prove otherwise.  Note that disabling
148  * of preemption (including disabling irqs) counts as an RCU-sched
149  * read-side critical section.  This is useful for debug checks in functions
150  * that required that they be called within an RCU-sched read-side
151  * critical section.
152  *
153  * Check debug_lockdep_rcu_enabled() to prevent false positives during boot
154  * and while lockdep is disabled.
155  */
156 #ifdef CONFIG_PREEMPT
157 static inline int rcu_read_lock_sched_held(void)
158 {
159         int lockdep_opinion = 0;
160
161         if (!debug_lockdep_rcu_enabled())
162                 return 1;
163         if (debug_locks)
164                 lockdep_opinion = lock_is_held(&rcu_sched_lock_map);
165         return lockdep_opinion || preempt_count() != 0 || irqs_disabled();
166 }
167 #else /* #ifdef CONFIG_PREEMPT */
168 static inline int rcu_read_lock_sched_held(void)
169 {
170         return 1;
171 }
172 #endif /* #else #ifdef CONFIG_PREEMPT */
173
174 #else /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
175
176 # define rcu_read_acquire()             do { } while (0)
177 # define rcu_read_release()             do { } while (0)
178 # define rcu_read_acquire_bh()          do { } while (0)
179 # define rcu_read_release_bh()          do { } while (0)
180 # define rcu_read_acquire_sched()       do { } while (0)
181 # define rcu_read_release_sched()       do { } while (0)
182
183 static inline int rcu_read_lock_held(void)
184 {
185         return 1;
186 }
187
188 static inline int rcu_read_lock_bh_held(void)
189 {
190         return 1;
191 }
192
193 #ifdef CONFIG_PREEMPT
194 static inline int rcu_read_lock_sched_held(void)
195 {
196         return preempt_count() != 0 || irqs_disabled();
197 }
198 #else /* #ifdef CONFIG_PREEMPT */
199 static inline int rcu_read_lock_sched_held(void)
200 {
201         return 1;
202 }
203 #endif /* #else #ifdef CONFIG_PREEMPT */
204
205 #endif /* #else #ifdef CONFIG_DEBUG_LOCK_ALLOC */
206
207 #ifdef CONFIG_PROVE_RCU
208
209 extern int rcu_my_thread_group_empty(void);
210
211 /**
212  * rcu_lockdep_assert - emit lockdep splat if specified condition not met
213  * @c: condition to check
214  */
215 #define rcu_lockdep_assert(c)                                           \
216         do {                                                            \
217                 static bool __warned;                                   \
218                 if (debug_lockdep_rcu_enabled() && !__warned && !(c)) { \
219                         __warned = true;                                \
220                         lockdep_rcu_dereference(__FILE__, __LINE__);    \
221                 }                                                       \
222         } while (0)
223
224 #else /* #ifdef CONFIG_PROVE_RCU */
225
226 #define rcu_lockdep_assert(c) do { } while (0)
227
228 #endif /* #else #ifdef CONFIG_PROVE_RCU */
229
230 /*
231  * Helper functions for rcu_dereference_check(), rcu_dereference_protected()
232  * and rcu_assign_pointer().  Some of these could be folded into their
233  * callers, but they are left separate in order to ease introduction of
234  * multiple flavors of pointers to match the multiple flavors of RCU
235  * (e.g., __rcu_bh, * __rcu_sched, and __srcu), should this make sense in
236  * the future.
237  */
238 #define __rcu_access_pointer(p, space) \
239         ({ \
240                 typeof(*p) *_________p1 = (typeof(*p)*__force )ACCESS_ONCE(p); \
241                 (void) (((typeof (*p) space *)p) == p); \
242                 ((typeof(*p) __force __kernel *)(_________p1)); \
243         })
244 #define __rcu_dereference_check(p, c, space) \
245         ({ \
246                 typeof(*p) *_________p1 = (typeof(*p)*__force )ACCESS_ONCE(p); \
247                 rcu_lockdep_assert(c); \
248                 (void) (((typeof (*p) space *)p) == p); \
249                 smp_read_barrier_depends(); \
250                 ((typeof(*p) __force __kernel *)(_________p1)); \
251         })
252 #define __rcu_dereference_protected(p, c, space) \
253         ({ \
254                 rcu_lockdep_assert(c); \
255                 (void) (((typeof (*p) space *)p) == p); \
256                 ((typeof(*p) __force __kernel *)(p)); \
257         })
258
259 #define __rcu_dereference_index_check(p, c) \
260         ({ \
261                 typeof(p) _________p1 = ACCESS_ONCE(p); \
262                 rcu_lockdep_assert(c); \
263                 smp_read_barrier_depends(); \
264                 (_________p1); \
265         })
266 #define __rcu_assign_pointer(p, v, space) \
267         ({ \
268                 if (!__builtin_constant_p(v) || \
269                     ((v) != NULL)) \
270                         smp_wmb(); \
271                 (p) = (typeof(*v) __force space *)(v); \
272         })
273
274
275 /**
276  * rcu_access_pointer() - fetch RCU pointer with no dereferencing
277  * @p: The pointer to read
278  *
279  * Return the value of the specified RCU-protected pointer, but omit the
280  * smp_read_barrier_depends() and keep the ACCESS_ONCE().  This is useful
281  * when the value of this pointer is accessed, but the pointer is not
282  * dereferenced, for example, when testing an RCU-protected pointer against
283  * NULL.  Although rcu_access_pointer() may also be used in cases where
284  * update-side locks prevent the value of the pointer from changing, you
285  * should instead use rcu_dereference_protected() for this use case.
286  */
287 #define rcu_access_pointer(p) __rcu_access_pointer((p), __rcu)
288
289 /**
290  * rcu_dereference_check() - rcu_dereference with debug checking
291  * @p: The pointer to read, prior to dereferencing
292  * @c: The conditions under which the dereference will take place
293  *
294  * Do an rcu_dereference(), but check that the conditions under which the
295  * dereference will take place are correct.  Typically the conditions
296  * indicate the various locking conditions that should be held at that
297  * point.  The check should return true if the conditions are satisfied.
298  * An implicit check for being in an RCU read-side critical section
299  * (rcu_read_lock()) is included.
300  *
301  * For example:
302  *
303  *      bar = rcu_dereference_check(foo->bar, lockdep_is_held(&foo->lock));
304  *
305  * could be used to indicate to lockdep that foo->bar may only be dereferenced
306  * if either rcu_read_lock() is held, or that the lock required to replace
307  * the bar struct at foo->bar is held.
308  *
309  * Note that the list of conditions may also include indications of when a lock
310  * need not be held, for example during initialisation or destruction of the
311  * target struct:
312  *
313  *      bar = rcu_dereference_check(foo->bar, lockdep_is_held(&foo->lock) ||
314  *                                            atomic_read(&foo->usage) == 0);
315  *
316  * Inserts memory barriers on architectures that require them
317  * (currently only the Alpha), prevents the compiler from refetching
318  * (and from merging fetches), and, more importantly, documents exactly
319  * which pointers are protected by RCU and checks that the pointer is
320  * annotated as __rcu.
321  */
322 #define rcu_dereference_check(p, c) \
323         __rcu_dereference_check((p), rcu_read_lock_held() || (c), __rcu)
324
325 /**
326  * rcu_dereference_bh_check() - rcu_dereference_bh with debug checking
327  * @p: The pointer to read, prior to dereferencing
328  * @c: The conditions under which the dereference will take place
329  *
330  * This is the RCU-bh counterpart to rcu_dereference_check().
331  */
332 #define rcu_dereference_bh_check(p, c) \
333         __rcu_dereference_check((p), rcu_read_lock_bh_held() || (c), __rcu)
334
335 /**
336  * rcu_dereference_sched_check() - rcu_dereference_sched with debug checking
337  * @p: The pointer to read, prior to dereferencing
338  * @c: The conditions under which the dereference will take place
339  *
340  * This is the RCU-sched counterpart to rcu_dereference_check().
341  */
342 #define rcu_dereference_sched_check(p, c) \
343         __rcu_dereference_check((p), rcu_read_lock_sched_held() || (c), \
344                                 __rcu)
345
346 #define rcu_dereference_raw(p) rcu_dereference_check(p, 1) /*@@@ needed? @@@*/
347
348 /**
349  * rcu_dereference_index_check() - rcu_dereference for indices with debug checking
350  * @p: The pointer to read, prior to dereferencing
351  * @c: The conditions under which the dereference will take place
352  *
353  * Similar to rcu_dereference_check(), but omits the sparse checking.
354  * This allows rcu_dereference_index_check() to be used on integers,
355  * which can then be used as array indices.  Attempting to use
356  * rcu_dereference_check() on an integer will give compiler warnings
357  * because the sparse address-space mechanism relies on dereferencing
358  * the RCU-protected pointer.  Dereferencing integers is not something
359  * that even gcc will put up with.
360  *
361  * Note that this function does not implicitly check for RCU read-side
362  * critical sections.  If this function gains lots of uses, it might
363  * make sense to provide versions for each flavor of RCU, but it does
364  * not make sense as of early 2010.
365  */
366 #define rcu_dereference_index_check(p, c) \
367         __rcu_dereference_index_check((p), (c))
368
369 /**
370  * rcu_dereference_protected() - fetch RCU pointer when updates prevented
371  * @p: The pointer to read, prior to dereferencing
372  * @c: The conditions under which the dereference will take place
373  *
374  * Return the value of the specified RCU-protected pointer, but omit
375  * both the smp_read_barrier_depends() and the ACCESS_ONCE().  This
376  * is useful in cases where update-side locks prevent the value of the
377  * pointer from changing.  Please note that this primitive does -not-
378  * prevent the compiler from repeating this reference or combining it
379  * with other references, so it should not be used without protection
380  * of appropriate locks.
381  *
382  * This function is only for update-side use.  Using this function
383  * when protected only by rcu_read_lock() will result in infrequent
384  * but very ugly failures.
385  */
386 #define rcu_dereference_protected(p, c) \
387         __rcu_dereference_protected((p), (c), __rcu)
388
389 /**
390  * rcu_dereference_bh_protected() - fetch RCU-bh pointer when updates prevented
391  * @p: The pointer to read, prior to dereferencing
392  * @c: The conditions under which the dereference will take place
393  *
394  * This is the RCU-bh counterpart to rcu_dereference_protected().
395  */
396 #define rcu_dereference_bh_protected(p, c) \
397         __rcu_dereference_protected((p), (c), __rcu)
398
399 /**
400  * rcu_dereference_sched_protected() - fetch RCU-sched pointer when updates prevented
401  * @p: The pointer to read, prior to dereferencing
402  * @c: The conditions under which the dereference will take place
403  *
404  * This is the RCU-sched counterpart to rcu_dereference_protected().
405  */
406 #define rcu_dereference_sched_protected(p, c) \
407         __rcu_dereference_protected((p), (c), __rcu)
408
409
410 /**
411  * rcu_dereference() - fetch RCU-protected pointer for dereferencing
412  * @p: The pointer to read, prior to dereferencing
413  *
414  * This is a simple wrapper around rcu_dereference_check().
415  */
416 #define rcu_dereference(p) rcu_dereference_check(p, 0)
417
418 /**
419  * rcu_dereference_bh() - fetch an RCU-bh-protected pointer for dereferencing
420  * @p: The pointer to read, prior to dereferencing
421  *
422  * Makes rcu_dereference_check() do the dirty work.
423  */
424 #define rcu_dereference_bh(p) rcu_dereference_bh_check(p, 0)
425
426 /**
427  * rcu_dereference_sched() - fetch RCU-sched-protected pointer for dereferencing
428  * @p: The pointer to read, prior to dereferencing
429  *
430  * Makes rcu_dereference_check() do the dirty work.
431  */
432 #define rcu_dereference_sched(p) rcu_dereference_sched_check(p, 0)
433
434 /**
435  * rcu_read_lock() - mark the beginning of an RCU read-side critical section
436  *
437  * When synchronize_rcu() is invoked on one CPU while other CPUs
438  * are within RCU read-side critical sections, then the
439  * synchronize_rcu() is guaranteed to block until after all the other
440  * CPUs exit their critical sections.  Similarly, if call_rcu() is invoked
441  * on one CPU while other CPUs are within RCU read-side critical
442  * sections, invocation of the corresponding RCU callback is deferred
443  * until after the all the other CPUs exit their critical sections.
444  *
445  * Note, however, that RCU callbacks are permitted to run concurrently
446  * with new RCU read-side critical sections.  One way that this can happen
447  * is via the following sequence of events: (1) CPU 0 enters an RCU
448  * read-side critical section, (2) CPU 1 invokes call_rcu() to register
449  * an RCU callback, (3) CPU 0 exits the RCU read-side critical section,
450  * (4) CPU 2 enters a RCU read-side critical section, (5) the RCU
451  * callback is invoked.  This is legal, because the RCU read-side critical
452  * section that was running concurrently with the call_rcu() (and which
453  * therefore might be referencing something that the corresponding RCU
454  * callback would free up) has completed before the corresponding
455  * RCU callback is invoked.
456  *
457  * RCU read-side critical sections may be nested.  Any deferred actions
458  * will be deferred until the outermost RCU read-side critical section
459  * completes.
460  *
461  * It is illegal to block while in an RCU read-side critical section.
462  */
463 static inline void rcu_read_lock(void)
464 {
465         __rcu_read_lock();
466         __acquire(RCU);
467         rcu_read_acquire();
468 }
469
470 /*
471  * So where is rcu_write_lock()?  It does not exist, as there is no
472  * way for writers to lock out RCU readers.  This is a feature, not
473  * a bug -- this property is what provides RCU's performance benefits.
474  * Of course, writers must coordinate with each other.  The normal
475  * spinlock primitives work well for this, but any other technique may be
476  * used as well.  RCU does not care how the writers keep out of each
477  * others' way, as long as they do so.
478  */
479
480 /**
481  * rcu_read_unlock() - marks the end of an RCU read-side critical section.
482  *
483  * See rcu_read_lock() for more information.
484  */
485 static inline void rcu_read_unlock(void)
486 {
487         rcu_read_release();
488         __release(RCU);
489         __rcu_read_unlock();
490 }
491
492 /**
493  * rcu_read_lock_bh() - mark the beginning of an RCU-bh critical section
494  *
495  * This is equivalent of rcu_read_lock(), but to be used when updates
496  * are being done using call_rcu_bh() or synchronize_rcu_bh(). Since
497  * both call_rcu_bh() and synchronize_rcu_bh() consider completion of a
498  * softirq handler to be a quiescent state, a process in RCU read-side
499  * critical section must be protected by disabling softirqs. Read-side
500  * critical sections in interrupt context can use just rcu_read_lock(),
501  * though this should at least be commented to avoid confusing people
502  * reading the code.
503  */
504 static inline void rcu_read_lock_bh(void)
505 {
506         __rcu_read_lock_bh();
507         __acquire(RCU_BH);
508         rcu_read_acquire_bh();
509 }
510
511 /*
512  * rcu_read_unlock_bh - marks the end of a softirq-only RCU critical section
513  *
514  * See rcu_read_lock_bh() for more information.
515  */
516 static inline void rcu_read_unlock_bh(void)
517 {
518         rcu_read_release_bh();
519         __release(RCU_BH);
520         __rcu_read_unlock_bh();
521 }
522
523 /**
524  * rcu_read_lock_sched() - mark the beginning of a RCU-sched critical section
525  *
526  * This is equivalent of rcu_read_lock(), but to be used when updates
527  * are being done using call_rcu_sched() or synchronize_rcu_sched().
528  * Read-side critical sections can also be introduced by anything that
529  * disables preemption, including local_irq_disable() and friends.
530  */
531 static inline void rcu_read_lock_sched(void)
532 {
533         preempt_disable();
534         __acquire(RCU_SCHED);
535         rcu_read_acquire_sched();
536 }
537
538 /* Used by lockdep and tracing: cannot be traced, cannot call lockdep. */
539 static inline notrace void rcu_read_lock_sched_notrace(void)
540 {
541         preempt_disable_notrace();
542         __acquire(RCU_SCHED);
543 }
544
545 /*
546  * rcu_read_unlock_sched - marks the end of a RCU-classic critical section
547  *
548  * See rcu_read_lock_sched for more information.
549  */
550 static inline void rcu_read_unlock_sched(void)
551 {
552         rcu_read_release_sched();
553         __release(RCU_SCHED);
554         preempt_enable();
555 }
556
557 /* Used by lockdep and tracing: cannot be traced, cannot call lockdep. */
558 static inline notrace void rcu_read_unlock_sched_notrace(void)
559 {
560         __release(RCU_SCHED);
561         preempt_enable_notrace();
562 }
563
564 /**
565  * rcu_assign_pointer() - assign to RCU-protected pointer
566  * @p: pointer to assign to
567  * @v: value to assign (publish)
568  *
569  * Assigns the specified value to the specified RCU-protected
570  * pointer, ensuring that any concurrent RCU readers will see
571  * any prior initialization.  Returns the value assigned.
572  *
573  * Inserts memory barriers on architectures that require them
574  * (pretty much all of them other than x86), and also prevents
575  * the compiler from reordering the code that initializes the
576  * structure after the pointer assignment.  More importantly, this
577  * call documents which pointers will be dereferenced by RCU read-side
578  * code.
579  */
580 #define rcu_assign_pointer(p, v) \
581         __rcu_assign_pointer((p), (v), __rcu)
582
583 /**
584  * RCU_INIT_POINTER() - initialize an RCU protected pointer
585  *
586  * Initialize an RCU-protected pointer in such a way to avoid RCU-lockdep
587  * splats.
588  */
589 #define RCU_INIT_POINTER(p, v) \
590                 p = (typeof(*v) __force __rcu *)(v)
591
592 /* Infrastructure to implement the synchronize_() primitives. */
593
594 struct rcu_synchronize {
595         struct rcu_head head;
596         struct completion completion;
597 };
598
599 extern void wakeme_after_rcu(struct rcu_head  *head);
600
601 /**
602  * call_rcu() - Queue an RCU callback for invocation after a grace period.
603  * @head: structure to be used for queueing the RCU updates.
604  * @func: actual callback function to be invoked after the grace period
605  *
606  * The callback function will be invoked some time after a full grace
607  * period elapses, in other words after all pre-existing RCU read-side
608  * critical sections have completed.  However, the callback function
609  * might well execute concurrently with RCU read-side critical sections
610  * that started after call_rcu() was invoked.  RCU read-side critical
611  * sections are delimited by rcu_read_lock() and rcu_read_unlock(),
612  * and may be nested.
613  */
614 extern void call_rcu(struct rcu_head *head,
615                               void (*func)(struct rcu_head *head));
616
617 /**
618  * call_rcu_bh() - Queue an RCU for invocation after a quicker grace period.
619  * @head: structure to be used for queueing the RCU updates.
620  * @func: actual callback function to be invoked after the grace period
621  *
622  * The callback function will be invoked some time after a full grace
623  * period elapses, in other words after all currently executing RCU
624  * read-side critical sections have completed. call_rcu_bh() assumes
625  * that the read-side critical sections end on completion of a softirq
626  * handler. This means that read-side critical sections in process
627  * context must not be interrupted by softirqs. This interface is to be
628  * used when most of the read-side critical sections are in softirq context.
629  * RCU read-side critical sections are delimited by :
630  *  - rcu_read_lock() and  rcu_read_unlock(), if in interrupt context.
631  *  OR
632  *  - rcu_read_lock_bh() and rcu_read_unlock_bh(), if in process context.
633  *  These may be nested.
634  */
635 extern void call_rcu_bh(struct rcu_head *head,
636                         void (*func)(struct rcu_head *head));
637
638 /*
639  * debug_rcu_head_queue()/debug_rcu_head_unqueue() are used internally
640  * by call_rcu() and rcu callback execution, and are therefore not part of the
641  * RCU API. Leaving in rcupdate.h because they are used by all RCU flavors.
642  */
643
644 #ifdef CONFIG_DEBUG_OBJECTS_RCU_HEAD
645 # define STATE_RCU_HEAD_READY   0
646 # define STATE_RCU_HEAD_QUEUED  1
647
648 extern struct debug_obj_descr rcuhead_debug_descr;
649
650 static inline void debug_rcu_head_queue(struct rcu_head *head)
651 {
652         debug_object_activate(head, &rcuhead_debug_descr);
653         debug_object_active_state(head, &rcuhead_debug_descr,
654                                   STATE_RCU_HEAD_READY,
655                                   STATE_RCU_HEAD_QUEUED);
656 }
657
658 static inline void debug_rcu_head_unqueue(struct rcu_head *head)
659 {
660         debug_object_active_state(head, &rcuhead_debug_descr,
661                                   STATE_RCU_HEAD_QUEUED,
662                                   STATE_RCU_HEAD_READY);
663         debug_object_deactivate(head, &rcuhead_debug_descr);
664 }
665 #else   /* !CONFIG_DEBUG_OBJECTS_RCU_HEAD */
666 static inline void debug_rcu_head_queue(struct rcu_head *head)
667 {
668 }
669
670 static inline void debug_rcu_head_unqueue(struct rcu_head *head)
671 {
672 }
673 #endif  /* #else !CONFIG_DEBUG_OBJECTS_RCU_HEAD */
674
675 #endif /* __LINUX_RCUPDATE_H */