2 * Read-Copy Update mechanism for mutual exclusion, realtime implementation
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.
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.
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.
18 * Copyright IBM Corporation, 2006
20 * Authors: Paul E. McKenney <paulmck@us.ibm.com>
21 * With thanks to Esben Nielsen, Bill Huey, and Ingo Molnar
22 * for pushing me away from locks and towards counters, and
23 * to Suparna Bhattacharya for pushing me completely away
24 * from atomic instructions on the read side.
26 * - Added handling of Dynamic Ticks
27 * Copyright 2007 - Paul E. Mckenney <paulmck@us.ibm.com>
28 * - Steven Rostedt <srostedt@redhat.com>
30 * Papers: http://www.rdrop.com/users/paulmck/RCU
32 * Design Document: http://lwn.net/Articles/253651/
34 * For detailed explanation of Read-Copy Update mechanism see -
35 * Documentation/RCU/ *.txt
38 #include <linux/types.h>
39 #include <linux/kernel.h>
40 #include <linux/init.h>
41 #include <linux/spinlock.h>
42 #include <linux/smp.h>
43 #include <linux/rcupdate.h>
44 #include <linux/interrupt.h>
45 #include <linux/sched.h>
46 #include <asm/atomic.h>
47 #include <linux/bitops.h>
48 #include <linux/module.h>
49 #include <linux/kthread.h>
50 #include <linux/completion.h>
51 #include <linux/moduleparam.h>
52 #include <linux/percpu.h>
53 #include <linux/notifier.h>
54 #include <linux/rcupdate.h>
55 #include <linux/cpu.h>
56 #include <linux/random.h>
57 #include <linux/delay.h>
58 #include <linux/byteorder/swabb.h>
59 #include <linux/cpumask.h>
60 #include <linux/rcupreempt_trace.h>
63 * Macro that prevents the compiler from reordering accesses, but does
64 * absolutely -nothing- to prevent CPUs from reordering. This is used
65 * only to mediate communication between mainline code and hardware
66 * interrupt and NMI handlers.
68 #define ACCESS_ONCE(x) (*(volatile typeof(x) *)&(x))
71 * PREEMPT_RCU data structures.
75 * GP_STAGES specifies the number of times the state machine has
76 * to go through the all the rcu_try_flip_states (see below)
77 * in a single Grace Period.
79 * GP in GP_STAGES stands for Grace Period ;)
83 spinlock_t lock
; /* Protect rcu_data fields. */
84 long completed
; /* Number of last completed batch. */
86 struct tasklet_struct rcu_tasklet
;
87 struct rcu_head
*nextlist
;
88 struct rcu_head
**nexttail
;
89 struct rcu_head
*waitlist
[GP_STAGES
];
90 struct rcu_head
**waittail
[GP_STAGES
];
91 struct rcu_head
*donelist
; /* from waitlist & waitschedlist */
92 struct rcu_head
**donetail
;
94 struct rcu_head
*nextschedlist
;
95 struct rcu_head
**nextschedtail
;
96 struct rcu_head
*waitschedlist
;
97 struct rcu_head
**waitschedtail
;
98 int rcu_sched_sleeping
;
99 #ifdef CONFIG_RCU_TRACE
100 struct rcupreempt_trace trace
;
101 #endif /* #ifdef CONFIG_RCU_TRACE */
105 * States for rcu_try_flip() and friends.
108 enum rcu_try_flip_states
{
111 * Stay here if nothing is happening. Flip the counter if somthing
112 * starts happening. Denoted by "I"
114 rcu_try_flip_idle_state
,
117 * Wait here for all CPUs to notice that the counter has flipped. This
118 * prevents the old set of counters from ever being incremented once
119 * we leave this state, which in turn is necessary because we cannot
120 * test any individual counter for zero -- we can only check the sum.
123 rcu_try_flip_waitack_state
,
126 * Wait here for the sum of the old per-CPU counters to reach zero.
129 rcu_try_flip_waitzero_state
,
132 * Wait here for each of the other CPUs to execute a memory barrier.
133 * This is necessary to ensure that these other CPUs really have
134 * completed executing their RCU read-side critical sections, despite
135 * their CPUs wildly reordering memory. Denoted by "M".
137 rcu_try_flip_waitmb_state
,
141 * States for rcu_ctrlblk.rcu_sched_sleep.
144 enum rcu_sched_sleep_states
{
145 rcu_sched_not_sleeping
, /* Not sleeping, callbacks need GP. */
146 rcu_sched_sleep_prep
, /* Thinking of sleeping, rechecking. */
147 rcu_sched_sleeping
, /* Sleeping, awaken if GP needed. */
151 spinlock_t fliplock
; /* Protect state-machine transitions. */
152 long completed
; /* Number of last completed batch. */
153 enum rcu_try_flip_states rcu_try_flip_state
; /* The current state of
154 the rcu state machine */
155 spinlock_t schedlock
; /* Protect rcu_sched sleep state. */
156 enum rcu_sched_sleep_states sched_sleep
; /* rcu_sched state. */
157 wait_queue_head_t sched_wq
; /* Place for rcu_sched to sleep. */
160 static DEFINE_PER_CPU(struct rcu_data
, rcu_data
);
161 static struct rcu_ctrlblk rcu_ctrlblk
= {
162 .fliplock
= __SPIN_LOCK_UNLOCKED(rcu_ctrlblk
.fliplock
),
164 .rcu_try_flip_state
= rcu_try_flip_idle_state
,
165 .schedlock
= __SPIN_LOCK_UNLOCKED(rcu_ctrlblk
.schedlock
),
166 .sched_sleep
= rcu_sched_not_sleeping
,
167 .sched_wq
= __WAIT_QUEUE_HEAD_INITIALIZER(rcu_ctrlblk
.sched_wq
),
170 static struct task_struct
*rcu_sched_grace_period_task
;
172 #ifdef CONFIG_RCU_TRACE
173 static char *rcu_try_flip_state_names
[] =
174 { "idle", "waitack", "waitzero", "waitmb" };
175 #endif /* #ifdef CONFIG_RCU_TRACE */
177 static cpumask_t rcu_cpu_online_map __read_mostly
= CPU_MASK_NONE
;
180 * Enum and per-CPU flag to determine when each CPU has seen
181 * the most recent counter flip.
184 enum rcu_flip_flag_values
{
185 rcu_flip_seen
, /* Steady/initial state, last flip seen. */
186 /* Only GP detector can update. */
187 rcu_flipped
/* Flip just completed, need confirmation. */
188 /* Only corresponding CPU can update. */
190 static DEFINE_PER_CPU_SHARED_ALIGNED(enum rcu_flip_flag_values
, rcu_flip_flag
)
194 * Enum and per-CPU flag to determine when each CPU has executed the
195 * needed memory barrier to fence in memory references from its last RCU
196 * read-side critical section in the just-completed grace period.
199 enum rcu_mb_flag_values
{
200 rcu_mb_done
, /* Steady/initial state, no mb()s required. */
201 /* Only GP detector can update. */
202 rcu_mb_needed
/* Flip just completed, need an mb(). */
203 /* Only corresponding CPU can update. */
205 static DEFINE_PER_CPU_SHARED_ALIGNED(enum rcu_mb_flag_values
, rcu_mb_flag
)
209 * RCU_DATA_ME: find the current CPU's rcu_data structure.
210 * RCU_DATA_CPU: find the specified CPU's rcu_data structure.
212 #define RCU_DATA_ME() (&__get_cpu_var(rcu_data))
213 #define RCU_DATA_CPU(cpu) (&per_cpu(rcu_data, cpu))
216 * Helper macro for tracing when the appropriate rcu_data is not
217 * cached in a local variable, but where the CPU number is so cached.
219 #define RCU_TRACE_CPU(f, cpu) RCU_TRACE(f, &(RCU_DATA_CPU(cpu)->trace));
222 * Helper macro for tracing when the appropriate rcu_data is not
223 * cached in a local variable.
225 #define RCU_TRACE_ME(f) RCU_TRACE(f, &(RCU_DATA_ME()->trace));
228 * Helper macro for tracing when the appropriate rcu_data is pointed
229 * to by a local variable.
231 #define RCU_TRACE_RDP(f, rdp) RCU_TRACE(f, &((rdp)->trace));
233 #define RCU_SCHED_BATCH_TIME (HZ / 50)
236 * Return the number of RCU batches processed thus far. Useful
237 * for debug and statistics.
239 long rcu_batches_completed(void)
241 return rcu_ctrlblk
.completed
;
243 EXPORT_SYMBOL_GPL(rcu_batches_completed
);
245 void __rcu_read_lock(void)
248 struct task_struct
*t
= current
;
251 nesting
= ACCESS_ONCE(t
->rcu_read_lock_nesting
);
254 /* An earlier rcu_read_lock() covers us, just count it. */
256 t
->rcu_read_lock_nesting
= nesting
+ 1;
262 * We disable interrupts for the following reasons:
263 * - If we get scheduling clock interrupt here, and we
264 * end up acking the counter flip, it's like a promise
265 * that we will never increment the old counter again.
266 * Thus we will break that promise if that
267 * scheduling clock interrupt happens between the time
268 * we pick the .completed field and the time that we
269 * increment our counter.
271 * - We don't want to be preempted out here.
273 * NMIs can still occur, of course, and might themselves
274 * contain rcu_read_lock().
277 local_irq_save(flags
);
280 * Outermost nesting of rcu_read_lock(), so increment
281 * the current counter for the current CPU. Use volatile
282 * casts to prevent the compiler from reordering.
285 idx
= ACCESS_ONCE(rcu_ctrlblk
.completed
) & 0x1;
286 ACCESS_ONCE(RCU_DATA_ME()->rcu_flipctr
[idx
])++;
289 * Now that the per-CPU counter has been incremented, we
290 * are protected from races with rcu_read_lock() invoked
291 * from NMI handlers on this CPU. We can therefore safely
292 * increment the nesting counter, relieving further NMIs
293 * of the need to increment the per-CPU counter.
296 ACCESS_ONCE(t
->rcu_read_lock_nesting
) = nesting
+ 1;
299 * Now that we have preventing any NMIs from storing
300 * to the ->rcu_flipctr_idx, we can safely use it to
301 * remember which counter to decrement in the matching
305 ACCESS_ONCE(t
->rcu_flipctr_idx
) = idx
;
306 local_irq_restore(flags
);
309 EXPORT_SYMBOL_GPL(__rcu_read_lock
);
311 void __rcu_read_unlock(void)
314 struct task_struct
*t
= current
;
317 nesting
= ACCESS_ONCE(t
->rcu_read_lock_nesting
);
321 * We are still protected by the enclosing rcu_read_lock(),
322 * so simply decrement the counter.
325 t
->rcu_read_lock_nesting
= nesting
- 1;
331 * Disable local interrupts to prevent the grace-period
332 * detection state machine from seeing us half-done.
333 * NMIs can still occur, of course, and might themselves
334 * contain rcu_read_lock() and rcu_read_unlock().
337 local_irq_save(flags
);
340 * Outermost nesting of rcu_read_unlock(), so we must
341 * decrement the current counter for the current CPU.
342 * This must be done carefully, because NMIs can
343 * occur at any point in this code, and any rcu_read_lock()
344 * and rcu_read_unlock() pairs in the NMI handlers
345 * must interact non-destructively with this code.
346 * Lots of volatile casts, and -very- careful ordering.
348 * Changes to this code, including this one, must be
349 * inspected, validated, and tested extremely carefully!!!
353 * First, pick up the index.
356 idx
= ACCESS_ONCE(t
->rcu_flipctr_idx
);
359 * Now that we have fetched the counter index, it is
360 * safe to decrement the per-task RCU nesting counter.
361 * After this, any interrupts or NMIs will increment and
362 * decrement the per-CPU counters.
364 ACCESS_ONCE(t
->rcu_read_lock_nesting
) = nesting
- 1;
367 * It is now safe to decrement this task's nesting count.
368 * NMIs that occur after this statement will route their
369 * rcu_read_lock() calls through this "else" clause, and
370 * will thus start incrementing the per-CPU counter on
371 * their own. They will also clobber ->rcu_flipctr_idx,
372 * but that is OK, since we have already fetched it.
375 ACCESS_ONCE(RCU_DATA_ME()->rcu_flipctr
[idx
])--;
376 local_irq_restore(flags
);
379 EXPORT_SYMBOL_GPL(__rcu_read_unlock
);
382 * If a global counter flip has occurred since the last time that we
383 * advanced callbacks, advance them. Hardware interrupts must be
384 * disabled when calling this function.
386 static void __rcu_advance_callbacks(struct rcu_data
*rdp
)
392 if (rdp
->completed
!= rcu_ctrlblk
.completed
) {
393 if (rdp
->waitlist
[GP_STAGES
- 1] != NULL
) {
394 *rdp
->donetail
= rdp
->waitlist
[GP_STAGES
- 1];
395 rdp
->donetail
= rdp
->waittail
[GP_STAGES
- 1];
396 RCU_TRACE_RDP(rcupreempt_trace_move2done
, rdp
);
398 for (i
= GP_STAGES
- 2; i
>= 0; i
--) {
399 if (rdp
->waitlist
[i
] != NULL
) {
400 rdp
->waitlist
[i
+ 1] = rdp
->waitlist
[i
];
401 rdp
->waittail
[i
+ 1] = rdp
->waittail
[i
];
404 rdp
->waitlist
[i
+ 1] = NULL
;
405 rdp
->waittail
[i
+ 1] =
406 &rdp
->waitlist
[i
+ 1];
409 if (rdp
->nextlist
!= NULL
) {
410 rdp
->waitlist
[0] = rdp
->nextlist
;
411 rdp
->waittail
[0] = rdp
->nexttail
;
413 rdp
->nextlist
= NULL
;
414 rdp
->nexttail
= &rdp
->nextlist
;
415 RCU_TRACE_RDP(rcupreempt_trace_move2wait
, rdp
);
417 rdp
->waitlist
[0] = NULL
;
418 rdp
->waittail
[0] = &rdp
->waitlist
[0];
420 rdp
->waitlistcount
= wlc
;
421 rdp
->completed
= rcu_ctrlblk
.completed
;
425 * Check to see if this CPU needs to report that it has seen
426 * the most recent counter flip, thereby declaring that all
427 * subsequent rcu_read_lock() invocations will respect this flip.
430 cpu
= raw_smp_processor_id();
431 if (per_cpu(rcu_flip_flag
, cpu
) == rcu_flipped
) {
432 smp_mb(); /* Subsequent counter accesses must see new value */
433 per_cpu(rcu_flip_flag
, cpu
) = rcu_flip_seen
;
434 smp_mb(); /* Subsequent RCU read-side critical sections */
435 /* seen -after- acknowledgement. */
439 DEFINE_PER_CPU_SHARED_ALIGNED(struct rcu_dyntick_sched
, rcu_dyntick_sched
) = {
444 static DEFINE_PER_CPU(int, rcu_update_flag
);
447 * rcu_irq_enter - Called from Hard irq handlers and NMI/SMI.
449 * If the CPU was idle with dynamic ticks active, this updates the
450 * rcu_dyntick_sched.dynticks to let the RCU handling know that the
453 void rcu_irq_enter(void)
455 int cpu
= smp_processor_id();
456 struct rcu_dyntick_sched
*rdssp
= &per_cpu(rcu_dyntick_sched
, cpu
);
458 if (per_cpu(rcu_update_flag
, cpu
))
459 per_cpu(rcu_update_flag
, cpu
)++;
462 * Only update if we are coming from a stopped ticks mode
463 * (rcu_dyntick_sched.dynticks is even).
465 if (!in_interrupt() &&
466 (rdssp
->dynticks
& 0x1) == 0) {
468 * The following might seem like we could have a race
469 * with NMI/SMIs. But this really isn't a problem.
470 * Here we do a read/modify/write, and the race happens
471 * when an NMI/SMI comes in after the read and before
472 * the write. But NMI/SMIs will increment this counter
473 * twice before returning, so the zero bit will not
474 * be corrupted by the NMI/SMI which is the most important
477 * The only thing is that we would bring back the counter
478 * to a postion that it was in during the NMI/SMI.
479 * But the zero bit would be set, so the rest of the
480 * counter would again be ignored.
482 * On return from the IRQ, the counter may have the zero
483 * bit be 0 and the counter the same as the return from
484 * the NMI/SMI. If the state machine was so unlucky to
485 * see that, it still doesn't matter, since all
486 * RCU read-side critical sections on this CPU would
487 * have already completed.
491 * The following memory barrier ensures that any
492 * rcu_read_lock() primitives in the irq handler
493 * are seen by other CPUs to follow the above
494 * increment to rcu_dyntick_sched.dynticks. This is
495 * required in order for other CPUs to correctly
496 * determine when it is safe to advance the RCU
497 * grace-period state machine.
499 smp_mb(); /* see above block comment. */
501 * Since we can't determine the dynamic tick mode from
502 * the rcu_dyntick_sched.dynticks after this routine,
503 * we use a second flag to acknowledge that we came
504 * from an idle state with ticks stopped.
506 per_cpu(rcu_update_flag
, cpu
)++;
508 * If we take an NMI/SMI now, they will also increment
509 * the rcu_update_flag, and will not update the
510 * rcu_dyntick_sched.dynticks on exit. That is for
517 * rcu_irq_exit - Called from exiting Hard irq context.
519 * If the CPU was idle with dynamic ticks active, update the
520 * rcu_dyntick_sched.dynticks to put let the RCU handling be
521 * aware that the CPU is going back to idle with no ticks.
523 void rcu_irq_exit(void)
525 int cpu
= smp_processor_id();
526 struct rcu_dyntick_sched
*rdssp
= &per_cpu(rcu_dyntick_sched
, cpu
);
529 * rcu_update_flag is set if we interrupted the CPU
530 * when it was idle with ticks stopped.
531 * Once this occurs, we keep track of interrupt nesting
532 * because a NMI/SMI could also come in, and we still
533 * only want the IRQ that started the increment of the
534 * rcu_dyntick_sched.dynticks to be the one that modifies
537 if (per_cpu(rcu_update_flag
, cpu
)) {
538 if (--per_cpu(rcu_update_flag
, cpu
))
541 /* This must match the interrupt nesting */
542 WARN_ON(in_interrupt());
545 * If an NMI/SMI happens now we are still
546 * protected by the rcu_dyntick_sched.dynticks being odd.
550 * The following memory barrier ensures that any
551 * rcu_read_unlock() primitives in the irq handler
552 * are seen by other CPUs to preceed the following
553 * increment to rcu_dyntick_sched.dynticks. This
554 * is required in order for other CPUs to determine
555 * when it is safe to advance the RCU grace-period
558 smp_mb(); /* see above block comment. */
560 WARN_ON(rdssp
->dynticks
& 0x1);
564 static void dyntick_save_progress_counter(int cpu
)
566 struct rcu_dyntick_sched
*rdssp
= &per_cpu(rcu_dyntick_sched
, cpu
);
568 rdssp
->dynticks_snap
= rdssp
->dynticks
;
572 rcu_try_flip_waitack_needed(int cpu
)
576 struct rcu_dyntick_sched
*rdssp
= &per_cpu(rcu_dyntick_sched
, cpu
);
578 curr
= rdssp
->dynticks
;
579 snap
= rdssp
->dynticks_snap
;
580 smp_mb(); /* force ordering with cpu entering/leaving dynticks. */
583 * If the CPU remained in dynticks mode for the entire time
584 * and didn't take any interrupts, NMIs, SMIs, or whatever,
585 * then it cannot be in the middle of an rcu_read_lock(), so
586 * the next rcu_read_lock() it executes must use the new value
587 * of the counter. So we can safely pretend that this CPU
588 * already acknowledged the counter.
591 if ((curr
== snap
) && ((curr
& 0x1) == 0))
595 * If the CPU passed through or entered a dynticks idle phase with
596 * no active irq handlers, then, as above, we can safely pretend
597 * that this CPU already acknowledged the counter.
600 if ((curr
- snap
) > 2 || (snap
& 0x1) == 0)
603 /* We need this CPU to explicitly acknowledge the counter flip. */
609 rcu_try_flip_waitmb_needed(int cpu
)
613 struct rcu_dyntick_sched
*rdssp
= &per_cpu(rcu_dyntick_sched
, cpu
);
615 curr
= rdssp
->dynticks
;
616 snap
= rdssp
->dynticks_snap
;
617 smp_mb(); /* force ordering with cpu entering/leaving dynticks. */
620 * If the CPU remained in dynticks mode for the entire time
621 * and didn't take any interrupts, NMIs, SMIs, or whatever,
622 * then it cannot have executed an RCU read-side critical section
623 * during that time, so there is no need for it to execute a
627 if ((curr
== snap
) && ((curr
& 0x1) == 0))
631 * If the CPU either entered or exited an outermost interrupt,
632 * SMI, NMI, or whatever handler, then we know that it executed
633 * a memory barrier when doing so. So we don't need another one.
638 /* We need the CPU to execute a memory barrier. */
643 static void dyntick_save_progress_counter_sched(int cpu
)
645 struct rcu_dyntick_sched
*rdssp
= &per_cpu(rcu_dyntick_sched
, cpu
);
647 rdssp
->sched_dynticks_snap
= rdssp
->dynticks
;
650 static int rcu_qsctr_inc_needed_dyntick(int cpu
)
654 struct rcu_dyntick_sched
*rdssp
= &per_cpu(rcu_dyntick_sched
, cpu
);
656 curr
= rdssp
->dynticks
;
657 snap
= rdssp
->sched_dynticks_snap
;
658 smp_mb(); /* force ordering with cpu entering/leaving dynticks. */
661 * If the CPU remained in dynticks mode for the entire time
662 * and didn't take any interrupts, NMIs, SMIs, or whatever,
663 * then it cannot be in the middle of an rcu_read_lock(), so
664 * the next rcu_read_lock() it executes must use the new value
665 * of the counter. Therefore, this CPU has been in a quiescent
666 * state the entire time, and we don't need to wait for it.
669 if ((curr
== snap
) && ((curr
& 0x1) == 0))
673 * If the CPU passed through or entered a dynticks idle phase with
674 * no active irq handlers, then, as above, this CPU has already
675 * passed through a quiescent state.
678 if ((curr
- snap
) > 2 || (snap
& 0x1) == 0)
681 /* We need this CPU to go through a quiescent state. */
686 #else /* !CONFIG_NO_HZ */
688 # define dyntick_save_progress_counter(cpu) do { } while (0)
689 # define rcu_try_flip_waitack_needed(cpu) (1)
690 # define rcu_try_flip_waitmb_needed(cpu) (1)
692 # define dyntick_save_progress_counter_sched(cpu) do { } while (0)
693 # define rcu_qsctr_inc_needed_dyntick(cpu) (1)
695 #endif /* CONFIG_NO_HZ */
697 static void save_qsctr_sched(int cpu
)
699 struct rcu_dyntick_sched
*rdssp
= &per_cpu(rcu_dyntick_sched
, cpu
);
701 rdssp
->sched_qs_snap
= rdssp
->sched_qs
;
704 static inline int rcu_qsctr_inc_needed(int cpu
)
706 struct rcu_dyntick_sched
*rdssp
= &per_cpu(rcu_dyntick_sched
, cpu
);
709 * If there has been a quiescent state, no more need to wait
713 if (rdssp
->sched_qs
!= rdssp
->sched_qs_snap
) {
714 smp_mb(); /* force ordering with cpu entering schedule(). */
718 /* We need this CPU to go through a quiescent state. */
724 * Get here when RCU is idle. Decide whether we need to
725 * move out of idle state, and return non-zero if so.
726 * "Straightforward" approach for the moment, might later
727 * use callback-list lengths, grace-period duration, or
728 * some such to determine when to exit idle state.
729 * Might also need a pre-idle test that does not acquire
730 * the lock, but let's get the simple case working first...
734 rcu_try_flip_idle(void)
738 RCU_TRACE_ME(rcupreempt_trace_try_flip_i1
);
739 if (!rcu_pending(smp_processor_id())) {
740 RCU_TRACE_ME(rcupreempt_trace_try_flip_ie1
);
748 RCU_TRACE_ME(rcupreempt_trace_try_flip_g1
);
749 rcu_ctrlblk
.completed
++; /* stands in for rcu_try_flip_g2 */
752 * Need a memory barrier so that other CPUs see the new
753 * counter value before they see the subsequent change of all
754 * the rcu_flip_flag instances to rcu_flipped.
757 smp_mb(); /* see above block comment. */
759 /* Now ask each CPU for acknowledgement of the flip. */
761 for_each_cpu_mask(cpu
, rcu_cpu_online_map
) {
762 per_cpu(rcu_flip_flag
, cpu
) = rcu_flipped
;
763 dyntick_save_progress_counter(cpu
);
770 * Wait for CPUs to acknowledge the flip.
774 rcu_try_flip_waitack(void)
778 RCU_TRACE_ME(rcupreempt_trace_try_flip_a1
);
779 for_each_cpu_mask(cpu
, rcu_cpu_online_map
)
780 if (rcu_try_flip_waitack_needed(cpu
) &&
781 per_cpu(rcu_flip_flag
, cpu
) != rcu_flip_seen
) {
782 RCU_TRACE_ME(rcupreempt_trace_try_flip_ae1
);
787 * Make sure our checks above don't bleed into subsequent
788 * waiting for the sum of the counters to reach zero.
791 smp_mb(); /* see above block comment. */
792 RCU_TRACE_ME(rcupreempt_trace_try_flip_a2
);
797 * Wait for collective ``last'' counter to reach zero,
798 * then tell all CPUs to do an end-of-grace-period memory barrier.
802 rcu_try_flip_waitzero(void)
805 int lastidx
= !(rcu_ctrlblk
.completed
& 0x1);
808 /* Check to see if the sum of the "last" counters is zero. */
810 RCU_TRACE_ME(rcupreempt_trace_try_flip_z1
);
811 for_each_cpu_mask(cpu
, rcu_cpu_online_map
)
812 sum
+= RCU_DATA_CPU(cpu
)->rcu_flipctr
[lastidx
];
814 RCU_TRACE_ME(rcupreempt_trace_try_flip_ze1
);
819 * This ensures that the other CPUs see the call for
820 * memory barriers -after- the sum to zero has been
823 smp_mb(); /* ^^^^^^^^^^^^ */
825 /* Call for a memory barrier from each CPU. */
826 for_each_cpu_mask(cpu
, rcu_cpu_online_map
) {
827 per_cpu(rcu_mb_flag
, cpu
) = rcu_mb_needed
;
828 dyntick_save_progress_counter(cpu
);
831 RCU_TRACE_ME(rcupreempt_trace_try_flip_z2
);
836 * Wait for all CPUs to do their end-of-grace-period memory barrier.
837 * Return 0 once all CPUs have done so.
841 rcu_try_flip_waitmb(void)
845 RCU_TRACE_ME(rcupreempt_trace_try_flip_m1
);
846 for_each_cpu_mask(cpu
, rcu_cpu_online_map
)
847 if (rcu_try_flip_waitmb_needed(cpu
) &&
848 per_cpu(rcu_mb_flag
, cpu
) != rcu_mb_done
) {
849 RCU_TRACE_ME(rcupreempt_trace_try_flip_me1
);
853 smp_mb(); /* Ensure that the above checks precede any following flip. */
854 RCU_TRACE_ME(rcupreempt_trace_try_flip_m2
);
859 * Attempt a single flip of the counters. Remember, a single flip does
860 * -not- constitute a grace period. Instead, the interval between
861 * at least GP_STAGES consecutive flips is a grace period.
863 * If anyone is nuts enough to run this CONFIG_PREEMPT_RCU implementation
864 * on a large SMP, they might want to use a hierarchical organization of
865 * the per-CPU-counter pairs.
867 static void rcu_try_flip(void)
871 RCU_TRACE_ME(rcupreempt_trace_try_flip_1
);
872 if (unlikely(!spin_trylock_irqsave(&rcu_ctrlblk
.fliplock
, flags
))) {
873 RCU_TRACE_ME(rcupreempt_trace_try_flip_e1
);
878 * Take the next transition(s) through the RCU grace-period
879 * flip-counter state machine.
882 switch (rcu_ctrlblk
.rcu_try_flip_state
) {
883 case rcu_try_flip_idle_state
:
884 if (rcu_try_flip_idle())
885 rcu_ctrlblk
.rcu_try_flip_state
=
886 rcu_try_flip_waitack_state
;
888 case rcu_try_flip_waitack_state
:
889 if (rcu_try_flip_waitack())
890 rcu_ctrlblk
.rcu_try_flip_state
=
891 rcu_try_flip_waitzero_state
;
893 case rcu_try_flip_waitzero_state
:
894 if (rcu_try_flip_waitzero())
895 rcu_ctrlblk
.rcu_try_flip_state
=
896 rcu_try_flip_waitmb_state
;
898 case rcu_try_flip_waitmb_state
:
899 if (rcu_try_flip_waitmb())
900 rcu_ctrlblk
.rcu_try_flip_state
=
901 rcu_try_flip_idle_state
;
903 spin_unlock_irqrestore(&rcu_ctrlblk
.fliplock
, flags
);
907 * Check to see if this CPU needs to do a memory barrier in order to
908 * ensure that any prior RCU read-side critical sections have committed
909 * their counter manipulations and critical-section memory references
910 * before declaring the grace period to be completed.
912 static void rcu_check_mb(int cpu
)
914 if (per_cpu(rcu_mb_flag
, cpu
) == rcu_mb_needed
) {
915 smp_mb(); /* Ensure RCU read-side accesses are visible. */
916 per_cpu(rcu_mb_flag
, cpu
) = rcu_mb_done
;
920 void rcu_check_callbacks(int cpu
, int user
)
923 struct rcu_data
*rdp
= RCU_DATA_CPU(cpu
);
926 * If this CPU took its interrupt from user mode or from the
927 * idle loop, and this is not a nested interrupt, then
928 * this CPU has to have exited all prior preept-disable
929 * sections of code. So increment the counter to note this.
931 * The memory barrier is needed to handle the case where
932 * writes from a preempt-disable section of code get reordered
933 * into schedule() by this CPU's write buffer. So the memory
934 * barrier makes sure that the rcu_qsctr_inc() is seen by other
935 * CPUs to happen after any such write.
939 (idle_cpu(cpu
) && !in_softirq() &&
940 hardirq_count() <= (1 << HARDIRQ_SHIFT
))) {
941 smp_mb(); /* Guard against aggressive schedule(). */
946 if (rcu_ctrlblk
.completed
== rdp
->completed
)
948 spin_lock_irqsave(&rdp
->lock
, flags
);
949 RCU_TRACE_RDP(rcupreempt_trace_check_callbacks
, rdp
);
950 __rcu_advance_callbacks(rdp
);
951 if (rdp
->donelist
== NULL
) {
952 spin_unlock_irqrestore(&rdp
->lock
, flags
);
954 spin_unlock_irqrestore(&rdp
->lock
, flags
);
955 raise_softirq(RCU_SOFTIRQ
);
960 * Needed by dynticks, to make sure all RCU processing has finished
963 void rcu_advance_callbacks(int cpu
, int user
)
966 struct rcu_data
*rdp
= RCU_DATA_CPU(cpu
);
968 if (rcu_ctrlblk
.completed
== rdp
->completed
) {
970 if (rcu_ctrlblk
.completed
== rdp
->completed
)
973 spin_lock_irqsave(&rdp
->lock
, flags
);
974 RCU_TRACE_RDP(rcupreempt_trace_check_callbacks
, rdp
);
975 __rcu_advance_callbacks(rdp
);
976 spin_unlock_irqrestore(&rdp
->lock
, flags
);
979 #ifdef CONFIG_HOTPLUG_CPU
980 #define rcu_offline_cpu_enqueue(srclist, srctail, dstlist, dsttail) do { \
981 *dsttail = srclist; \
982 if (srclist != NULL) { \
989 void rcu_offline_cpu(int cpu
)
992 struct rcu_head
*list
= NULL
;
994 struct rcu_data
*rdp
= RCU_DATA_CPU(cpu
);
995 struct rcu_head
*schedlist
= NULL
;
996 struct rcu_head
**schedtail
= &schedlist
;
997 struct rcu_head
**tail
= &list
;
1000 * Remove all callbacks from the newly dead CPU, retaining order.
1001 * Otherwise rcu_barrier() will fail
1004 spin_lock_irqsave(&rdp
->lock
, flags
);
1005 rcu_offline_cpu_enqueue(rdp
->donelist
, rdp
->donetail
, list
, tail
);
1006 for (i
= GP_STAGES
- 1; i
>= 0; i
--)
1007 rcu_offline_cpu_enqueue(rdp
->waitlist
[i
], rdp
->waittail
[i
],
1009 rcu_offline_cpu_enqueue(rdp
->nextlist
, rdp
->nexttail
, list
, tail
);
1010 rcu_offline_cpu_enqueue(rdp
->waitschedlist
, rdp
->waitschedtail
,
1011 schedlist
, schedtail
);
1012 rcu_offline_cpu_enqueue(rdp
->nextschedlist
, rdp
->nextschedtail
,
1013 schedlist
, schedtail
);
1014 rdp
->rcu_sched_sleeping
= 0;
1015 spin_unlock_irqrestore(&rdp
->lock
, flags
);
1016 rdp
->waitlistcount
= 0;
1018 /* Disengage the newly dead CPU from the grace-period computation. */
1020 spin_lock_irqsave(&rcu_ctrlblk
.fliplock
, flags
);
1022 if (per_cpu(rcu_flip_flag
, cpu
) == rcu_flipped
) {
1023 smp_mb(); /* Subsequent counter accesses must see new value */
1024 per_cpu(rcu_flip_flag
, cpu
) = rcu_flip_seen
;
1025 smp_mb(); /* Subsequent RCU read-side critical sections */
1026 /* seen -after- acknowledgement. */
1029 RCU_DATA_ME()->rcu_flipctr
[0] += RCU_DATA_CPU(cpu
)->rcu_flipctr
[0];
1030 RCU_DATA_ME()->rcu_flipctr
[1] += RCU_DATA_CPU(cpu
)->rcu_flipctr
[1];
1032 RCU_DATA_CPU(cpu
)->rcu_flipctr
[0] = 0;
1033 RCU_DATA_CPU(cpu
)->rcu_flipctr
[1] = 0;
1035 cpu_clear(cpu
, rcu_cpu_online_map
);
1037 spin_unlock_irqrestore(&rcu_ctrlblk
.fliplock
, flags
);
1040 * Place the removed callbacks on the current CPU's queue.
1041 * Make them all start a new grace period: simple approach,
1042 * in theory could starve a given set of callbacks, but
1043 * you would need to be doing some serious CPU hotplugging
1044 * to make this happen. If this becomes a problem, adding
1045 * a synchronize_rcu() to the hotplug path would be a simple
1049 local_irq_save(flags
); /* disable preempt till we know what lock. */
1050 rdp
= RCU_DATA_ME();
1051 spin_lock(&rdp
->lock
);
1052 *rdp
->nexttail
= list
;
1054 rdp
->nexttail
= tail
;
1055 *rdp
->nextschedtail
= schedlist
;
1057 rdp
->nextschedtail
= schedtail
;
1058 spin_unlock_irqrestore(&rdp
->lock
, flags
);
1061 void __devinit
rcu_online_cpu(int cpu
)
1063 unsigned long flags
;
1064 struct rcu_data
*rdp
;
1066 spin_lock_irqsave(&rcu_ctrlblk
.fliplock
, flags
);
1067 cpu_set(cpu
, rcu_cpu_online_map
);
1068 spin_unlock_irqrestore(&rcu_ctrlblk
.fliplock
, flags
);
1071 * The rcu_sched grace-period processing might have bypassed
1072 * this CPU, given that it was not in the rcu_cpu_online_map
1073 * when the grace-period scan started. This means that the
1074 * grace-period task might sleep. So make sure that if this
1075 * should happen, the first callback posted to this CPU will
1076 * wake up the grace-period task if need be.
1079 rdp
= RCU_DATA_CPU(cpu
);
1080 spin_lock_irqsave(&rdp
->lock
, flags
);
1081 rdp
->rcu_sched_sleeping
= 1;
1082 spin_unlock_irqrestore(&rdp
->lock
, flags
);
1085 #else /* #ifdef CONFIG_HOTPLUG_CPU */
1087 void rcu_offline_cpu(int cpu
)
1091 void __devinit
rcu_online_cpu(int cpu
)
1095 #endif /* #else #ifdef CONFIG_HOTPLUG_CPU */
1097 static void rcu_process_callbacks(struct softirq_action
*unused
)
1099 unsigned long flags
;
1100 struct rcu_head
*next
, *list
;
1101 struct rcu_data
*rdp
;
1103 local_irq_save(flags
);
1104 rdp
= RCU_DATA_ME();
1105 spin_lock(&rdp
->lock
);
1106 list
= rdp
->donelist
;
1108 spin_unlock_irqrestore(&rdp
->lock
, flags
);
1111 rdp
->donelist
= NULL
;
1112 rdp
->donetail
= &rdp
->donelist
;
1113 RCU_TRACE_RDP(rcupreempt_trace_done_remove
, rdp
);
1114 spin_unlock_irqrestore(&rdp
->lock
, flags
);
1119 RCU_TRACE_ME(rcupreempt_trace_invoke
);
1123 void call_rcu(struct rcu_head
*head
, void (*func
)(struct rcu_head
*rcu
))
1125 unsigned long flags
;
1126 struct rcu_data
*rdp
;
1130 local_irq_save(flags
);
1131 rdp
= RCU_DATA_ME();
1132 spin_lock(&rdp
->lock
);
1133 __rcu_advance_callbacks(rdp
);
1134 *rdp
->nexttail
= head
;
1135 rdp
->nexttail
= &head
->next
;
1136 RCU_TRACE_RDP(rcupreempt_trace_next_add
, rdp
);
1137 spin_unlock_irqrestore(&rdp
->lock
, flags
);
1139 EXPORT_SYMBOL_GPL(call_rcu
);
1141 void call_rcu_sched(struct rcu_head
*head
, void (*func
)(struct rcu_head
*rcu
))
1143 unsigned long flags
;
1144 struct rcu_data
*rdp
;
1149 local_irq_save(flags
);
1150 rdp
= RCU_DATA_ME();
1151 spin_lock(&rdp
->lock
);
1152 *rdp
->nextschedtail
= head
;
1153 rdp
->nextschedtail
= &head
->next
;
1154 if (rdp
->rcu_sched_sleeping
) {
1156 /* Grace-period processing might be sleeping... */
1158 rdp
->rcu_sched_sleeping
= 0;
1161 spin_unlock_irqrestore(&rdp
->lock
, flags
);
1164 /* Wake up grace-period processing, unless someone beat us. */
1166 spin_lock_irqsave(&rcu_ctrlblk
.schedlock
, flags
);
1167 if (rcu_ctrlblk
.sched_sleep
!= rcu_sched_sleeping
)
1169 rcu_ctrlblk
.sched_sleep
= rcu_sched_not_sleeping
;
1170 spin_unlock_irqrestore(&rcu_ctrlblk
.schedlock
, flags
);
1172 wake_up_interruptible(&rcu_ctrlblk
.sched_wq
);
1175 EXPORT_SYMBOL_GPL(call_rcu_sched
);
1178 * Wait until all currently running preempt_disable() code segments
1179 * (including hardware-irq-disable segments) complete. Note that
1180 * in -rt this does -not- necessarily result in all currently executing
1181 * interrupt -handlers- having completed.
1183 synchronize_rcu_xxx(__synchronize_sched
, call_rcu_sched
)
1184 EXPORT_SYMBOL_GPL(__synchronize_sched
);
1187 * kthread function that manages call_rcu_sched grace periods.
1189 static int rcu_sched_grace_period(void *arg
)
1191 int couldsleep
; /* might sleep after current pass. */
1192 int couldsleepnext
= 0; /* might sleep after next pass. */
1194 unsigned long flags
;
1195 struct rcu_data
*rdp
;
1199 * Each pass through the following loop handles one
1200 * rcu_sched grace period cycle.
1203 /* Save each CPU's current state. */
1205 for_each_online_cpu(cpu
) {
1206 dyntick_save_progress_counter_sched(cpu
);
1207 save_qsctr_sched(cpu
);
1211 * Sleep for about an RCU grace-period's worth to
1212 * allow better batching and to consume less CPU.
1214 schedule_timeout_interruptible(RCU_SCHED_BATCH_TIME
);
1217 * If there was nothing to do last time, prepare to
1218 * sleep at the end of the current grace period cycle.
1220 couldsleep
= couldsleepnext
;
1223 spin_lock_irqsave(&rcu_ctrlblk
.schedlock
, flags
);
1224 rcu_ctrlblk
.sched_sleep
= rcu_sched_sleep_prep
;
1225 spin_unlock_irqrestore(&rcu_ctrlblk
.schedlock
, flags
);
1229 * Wait on each CPU in turn to have either visited
1230 * a quiescent state or been in dynticks-idle mode.
1232 for_each_online_cpu(cpu
) {
1233 while (rcu_qsctr_inc_needed(cpu
) &&
1234 rcu_qsctr_inc_needed_dyntick(cpu
)) {
1235 /* resched_cpu(cpu); @@@ */
1236 schedule_timeout_interruptible(1);
1240 /* Advance callbacks for each CPU. */
1242 for_each_online_cpu(cpu
) {
1244 rdp
= RCU_DATA_CPU(cpu
);
1245 spin_lock_irqsave(&rdp
->lock
, flags
);
1248 * We are running on this CPU irq-disabled, so no
1249 * CPU can go offline until we re-enable irqs.
1250 * The current CPU might have already gone
1251 * offline (between the for_each_offline_cpu and
1252 * the spin_lock_irqsave), but in that case all its
1253 * callback lists will be empty, so no harm done.
1255 * Advance the callbacks! We share normal RCU's
1256 * donelist, since callbacks are invoked the
1257 * same way in either case.
1259 if (rdp
->waitschedlist
!= NULL
) {
1260 *rdp
->donetail
= rdp
->waitschedlist
;
1261 rdp
->donetail
= rdp
->waitschedtail
;
1264 * Next rcu_check_callbacks() will
1265 * do the required raise_softirq().
1268 if (rdp
->nextschedlist
!= NULL
) {
1269 rdp
->waitschedlist
= rdp
->nextschedlist
;
1270 rdp
->waitschedtail
= rdp
->nextschedtail
;
1274 rdp
->waitschedlist
= NULL
;
1275 rdp
->waitschedtail
= &rdp
->waitschedlist
;
1277 rdp
->nextschedlist
= NULL
;
1278 rdp
->nextschedtail
= &rdp
->nextschedlist
;
1280 /* Mark sleep intention. */
1282 rdp
->rcu_sched_sleeping
= couldsleep
;
1284 spin_unlock_irqrestore(&rdp
->lock
, flags
);
1287 /* If we saw callbacks on the last scan, go deal with them. */
1292 /* Attempt to block... */
1294 spin_lock_irqsave(&rcu_ctrlblk
.schedlock
, flags
);
1295 if (rcu_ctrlblk
.sched_sleep
!= rcu_sched_sleep_prep
) {
1298 * Someone posted a callback after we scanned.
1299 * Go take care of it.
1301 spin_unlock_irqrestore(&rcu_ctrlblk
.schedlock
, flags
);
1306 /* Block until the next person posts a callback. */
1308 rcu_ctrlblk
.sched_sleep
= rcu_sched_sleeping
;
1309 spin_unlock_irqrestore(&rcu_ctrlblk
.schedlock
, flags
);
1311 __wait_event_interruptible(rcu_ctrlblk
.sched_wq
,
1312 rcu_ctrlblk
.sched_sleep
!= rcu_sched_sleeping
,
1316 * Signals would prevent us from sleeping, and we cannot
1317 * do much with them in any case. So flush them.
1320 flush_signals(current
);
1323 } while (!kthread_should_stop());
1329 * Check to see if any future RCU-related work will need to be done
1330 * by the current CPU, even if none need be done immediately, returning
1331 * 1 if so. Assumes that notifiers would take care of handling any
1332 * outstanding requests from the RCU core.
1334 * This function is part of the RCU implementation; it is -not-
1335 * an exported member of the RCU API.
1337 int rcu_needs_cpu(int cpu
)
1339 struct rcu_data
*rdp
= RCU_DATA_CPU(cpu
);
1341 return (rdp
->donelist
!= NULL
||
1342 !!rdp
->waitlistcount
||
1343 rdp
->nextlist
!= NULL
||
1344 rdp
->nextschedlist
!= NULL
||
1345 rdp
->waitschedlist
!= NULL
);
1348 int rcu_pending(int cpu
)
1350 struct rcu_data
*rdp
= RCU_DATA_CPU(cpu
);
1352 /* The CPU has at least one callback queued somewhere. */
1354 if (rdp
->donelist
!= NULL
||
1355 !!rdp
->waitlistcount
||
1356 rdp
->nextlist
!= NULL
||
1357 rdp
->nextschedlist
!= NULL
||
1358 rdp
->waitschedlist
!= NULL
)
1361 /* The RCU core needs an acknowledgement from this CPU. */
1363 if ((per_cpu(rcu_flip_flag
, cpu
) == rcu_flipped
) ||
1364 (per_cpu(rcu_mb_flag
, cpu
) == rcu_mb_needed
))
1367 /* This CPU has fallen behind the global grace-period number. */
1369 if (rdp
->completed
!= rcu_ctrlblk
.completed
)
1372 /* Nothing needed from this CPU. */
1377 static int __cpuinit
rcu_cpu_notify(struct notifier_block
*self
,
1378 unsigned long action
, void *hcpu
)
1380 long cpu
= (long)hcpu
;
1383 case CPU_UP_PREPARE
:
1384 case CPU_UP_PREPARE_FROZEN
:
1385 rcu_online_cpu(cpu
);
1387 case CPU_UP_CANCELED
:
1388 case CPU_UP_CANCELED_FROZEN
:
1390 case CPU_DEAD_FROZEN
:
1391 rcu_offline_cpu(cpu
);
1399 static struct notifier_block __cpuinitdata rcu_nb
= {
1400 .notifier_call
= rcu_cpu_notify
,
1403 void __init
__rcu_init(void)
1407 struct rcu_data
*rdp
;
1409 printk(KERN_NOTICE
"Preemptible RCU implementation.\n");
1410 for_each_possible_cpu(cpu
) {
1411 rdp
= RCU_DATA_CPU(cpu
);
1412 spin_lock_init(&rdp
->lock
);
1414 rdp
->waitlistcount
= 0;
1415 rdp
->nextlist
= NULL
;
1416 rdp
->nexttail
= &rdp
->nextlist
;
1417 for (i
= 0; i
< GP_STAGES
; i
++) {
1418 rdp
->waitlist
[i
] = NULL
;
1419 rdp
->waittail
[i
] = &rdp
->waitlist
[i
];
1421 rdp
->donelist
= NULL
;
1422 rdp
->donetail
= &rdp
->donelist
;
1423 rdp
->rcu_flipctr
[0] = 0;
1424 rdp
->rcu_flipctr
[1] = 0;
1425 rdp
->nextschedlist
= NULL
;
1426 rdp
->nextschedtail
= &rdp
->nextschedlist
;
1427 rdp
->waitschedlist
= NULL
;
1428 rdp
->waitschedtail
= &rdp
->waitschedlist
;
1429 rdp
->rcu_sched_sleeping
= 0;
1431 register_cpu_notifier(&rcu_nb
);
1434 * We don't need protection against CPU-Hotplug here
1436 * a) If a CPU comes online while we are iterating over the
1437 * cpu_online_map below, we would only end up making a
1438 * duplicate call to rcu_online_cpu() which sets the corresponding
1439 * CPU's mask in the rcu_cpu_online_map.
1441 * b) A CPU cannot go offline at this point in time since the user
1442 * does not have access to the sysfs interface, nor do we
1443 * suspend the system.
1445 for_each_online_cpu(cpu
)
1446 rcu_cpu_notify(&rcu_nb
, CPU_UP_PREPARE
, (void *)(long) cpu
);
1448 open_softirq(RCU_SOFTIRQ
, rcu_process_callbacks
, NULL
);
1452 * Late-boot-time RCU initialization that must wait until after scheduler
1453 * has been initialized.
1455 void __init
rcu_init_sched(void)
1457 rcu_sched_grace_period_task
= kthread_run(rcu_sched_grace_period
,
1459 "rcu_sched_grace_period");
1460 WARN_ON(IS_ERR(rcu_sched_grace_period_task
));
1463 #ifdef CONFIG_RCU_TRACE
1464 long *rcupreempt_flipctr(int cpu
)
1466 return &RCU_DATA_CPU(cpu
)->rcu_flipctr
[0];
1468 EXPORT_SYMBOL_GPL(rcupreempt_flipctr
);
1470 int rcupreempt_flip_flag(int cpu
)
1472 return per_cpu(rcu_flip_flag
, cpu
);
1474 EXPORT_SYMBOL_GPL(rcupreempt_flip_flag
);
1476 int rcupreempt_mb_flag(int cpu
)
1478 return per_cpu(rcu_mb_flag
, cpu
);
1480 EXPORT_SYMBOL_GPL(rcupreempt_mb_flag
);
1482 char *rcupreempt_try_flip_state_name(void)
1484 return rcu_try_flip_state_names
[rcu_ctrlblk
.rcu_try_flip_state
];
1486 EXPORT_SYMBOL_GPL(rcupreempt_try_flip_state_name
);
1488 struct rcupreempt_trace
*rcupreempt_trace_cpu(int cpu
)
1490 struct rcu_data
*rdp
= RCU_DATA_CPU(cpu
);
1494 EXPORT_SYMBOL_GPL(rcupreempt_trace_cpu
);
1496 #endif /* #ifdef RCU_TRACE */