Preempt-RCU: implementation
[linux-3.10.git] / kernel / rcupreempt.c
1 /*
2  * Read-Copy Update mechanism for mutual exclusion, realtime implementation
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, 2006
19  *
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.
25  *
26  * Papers:  http://www.rdrop.com/users/paulmck/RCU
27  *
28  * Design Document: http://lwn.net/Articles/253651/
29  *
30  * For detailed explanation of Read-Copy Update mechanism see -
31  *              Documentation/RCU/ *.txt
32  *
33  */
34 #include <linux/types.h>
35 #include <linux/kernel.h>
36 #include <linux/init.h>
37 #include <linux/spinlock.h>
38 #include <linux/smp.h>
39 #include <linux/rcupdate.h>
40 #include <linux/interrupt.h>
41 #include <linux/sched.h>
42 #include <asm/atomic.h>
43 #include <linux/bitops.h>
44 #include <linux/module.h>
45 #include <linux/completion.h>
46 #include <linux/moduleparam.h>
47 #include <linux/percpu.h>
48 #include <linux/notifier.h>
49 #include <linux/rcupdate.h>
50 #include <linux/cpu.h>
51 #include <linux/random.h>
52 #include <linux/delay.h>
53 #include <linux/byteorder/swabb.h>
54 #include <linux/cpumask.h>
55 #include <linux/rcupreempt_trace.h>
56
57 /*
58  * Macro that prevents the compiler from reordering accesses, but does
59  * absolutely -nothing- to prevent CPUs from reordering.  This is used
60  * only to mediate communication between mainline code and hardware
61  * interrupt and NMI handlers.
62  */
63 #define ACCESS_ONCE(x) (*(volatile typeof(x) *)&(x))
64
65 /*
66  * PREEMPT_RCU data structures.
67  */
68
69 /*
70  * GP_STAGES specifies the number of times the state machine has
71  * to go through the all the rcu_try_flip_states (see below)
72  * in a single Grace Period.
73  *
74  * GP in GP_STAGES stands for Grace Period ;)
75  */
76 #define GP_STAGES    2
77 struct rcu_data {
78         spinlock_t      lock;           /* Protect rcu_data fields. */
79         long            completed;      /* Number of last completed batch. */
80         int             waitlistcount;
81         struct tasklet_struct rcu_tasklet;
82         struct rcu_head *nextlist;
83         struct rcu_head **nexttail;
84         struct rcu_head *waitlist[GP_STAGES];
85         struct rcu_head **waittail[GP_STAGES];
86         struct rcu_head *donelist;
87         struct rcu_head **donetail;
88         long rcu_flipctr[2];
89 #ifdef CONFIG_RCU_TRACE
90         struct rcupreempt_trace trace;
91 #endif /* #ifdef CONFIG_RCU_TRACE */
92 };
93
94 /*
95  * States for rcu_try_flip() and friends.
96  */
97
98 enum rcu_try_flip_states {
99
100         /*
101          * Stay here if nothing is happening. Flip the counter if somthing
102          * starts happening. Denoted by "I"
103          */
104         rcu_try_flip_idle_state,
105
106         /*
107          * Wait here for all CPUs to notice that the counter has flipped. This
108          * prevents the old set of counters from ever being incremented once
109          * we leave this state, which in turn is necessary because we cannot
110          * test any individual counter for zero -- we can only check the sum.
111          * Denoted by "A".
112          */
113         rcu_try_flip_waitack_state,
114
115         /*
116          * Wait here for the sum of the old per-CPU counters to reach zero.
117          * Denoted by "Z".
118          */
119         rcu_try_flip_waitzero_state,
120
121         /*
122          * Wait here for each of the other CPUs to execute a memory barrier.
123          * This is necessary to ensure that these other CPUs really have
124          * completed executing their RCU read-side critical sections, despite
125          * their CPUs wildly reordering memory. Denoted by "M".
126          */
127         rcu_try_flip_waitmb_state,
128 };
129
130 struct rcu_ctrlblk {
131         spinlock_t      fliplock;       /* Protect state-machine transitions. */
132         long            completed;      /* Number of last completed batch. */
133         enum rcu_try_flip_states rcu_try_flip_state; /* The current state of
134                                                         the rcu state machine */
135 };
136
137 static DEFINE_PER_CPU(struct rcu_data, rcu_data);
138 static struct rcu_ctrlblk rcu_ctrlblk = {
139         .fliplock = __SPIN_LOCK_UNLOCKED(rcu_ctrlblk.fliplock),
140         .completed = 0,
141         .rcu_try_flip_state = rcu_try_flip_idle_state,
142 };
143
144
145 #ifdef CONFIG_RCU_TRACE
146 static char *rcu_try_flip_state_names[] =
147         { "idle", "waitack", "waitzero", "waitmb" };
148 #endif /* #ifdef CONFIG_RCU_TRACE */
149
150 /*
151  * Enum and per-CPU flag to determine when each CPU has seen
152  * the most recent counter flip.
153  */
154
155 enum rcu_flip_flag_values {
156         rcu_flip_seen,          /* Steady/initial state, last flip seen. */
157                                 /* Only GP detector can update. */
158         rcu_flipped             /* Flip just completed, need confirmation. */
159                                 /* Only corresponding CPU can update. */
160 };
161 static DEFINE_PER_CPU_SHARED_ALIGNED(enum rcu_flip_flag_values, rcu_flip_flag)
162                                                                 = rcu_flip_seen;
163
164 /*
165  * Enum and per-CPU flag to determine when each CPU has executed the
166  * needed memory barrier to fence in memory references from its last RCU
167  * read-side critical section in the just-completed grace period.
168  */
169
170 enum rcu_mb_flag_values {
171         rcu_mb_done,            /* Steady/initial state, no mb()s required. */
172                                 /* Only GP detector can update. */
173         rcu_mb_needed           /* Flip just completed, need an mb(). */
174                                 /* Only corresponding CPU can update. */
175 };
176 static DEFINE_PER_CPU_SHARED_ALIGNED(enum rcu_mb_flag_values, rcu_mb_flag)
177                                                                 = rcu_mb_done;
178
179 /*
180  * RCU_DATA_ME: find the current CPU's rcu_data structure.
181  * RCU_DATA_CPU: find the specified CPU's rcu_data structure.
182  */
183 #define RCU_DATA_ME()           (&__get_cpu_var(rcu_data))
184 #define RCU_DATA_CPU(cpu)       (&per_cpu(rcu_data, cpu))
185
186 /*
187  * Helper macro for tracing when the appropriate rcu_data is not
188  * cached in a local variable, but where the CPU number is so cached.
189  */
190 #define RCU_TRACE_CPU(f, cpu) RCU_TRACE(f, &(RCU_DATA_CPU(cpu)->trace));
191
192 /*
193  * Helper macro for tracing when the appropriate rcu_data is not
194  * cached in a local variable.
195  */
196 #define RCU_TRACE_ME(f) RCU_TRACE(f, &(RCU_DATA_ME()->trace));
197
198 /*
199  * Helper macro for tracing when the appropriate rcu_data is pointed
200  * to by a local variable.
201  */
202 #define RCU_TRACE_RDP(f, rdp) RCU_TRACE(f, &((rdp)->trace));
203
204 /*
205  * Return the number of RCU batches processed thus far.  Useful
206  * for debug and statistics.
207  */
208 long rcu_batches_completed(void)
209 {
210         return rcu_ctrlblk.completed;
211 }
212 EXPORT_SYMBOL_GPL(rcu_batches_completed);
213
214 EXPORT_SYMBOL_GPL(rcu_batches_completed_bh);
215
216 void __rcu_read_lock(void)
217 {
218         int idx;
219         struct task_struct *t = current;
220         int nesting;
221
222         nesting = ACCESS_ONCE(t->rcu_read_lock_nesting);
223         if (nesting != 0) {
224
225                 /* An earlier rcu_read_lock() covers us, just count it. */
226
227                 t->rcu_read_lock_nesting = nesting + 1;
228
229         } else {
230                 unsigned long flags;
231
232                 /*
233                  * We disable interrupts for the following reasons:
234                  * - If we get scheduling clock interrupt here, and we
235                  *   end up acking the counter flip, it's like a promise
236                  *   that we will never increment the old counter again.
237                  *   Thus we will break that promise if that
238                  *   scheduling clock interrupt happens between the time
239                  *   we pick the .completed field and the time that we
240                  *   increment our counter.
241                  *
242                  * - We don't want to be preempted out here.
243                  *
244                  * NMIs can still occur, of course, and might themselves
245                  * contain rcu_read_lock().
246                  */
247
248                 local_irq_save(flags);
249
250                 /*
251                  * Outermost nesting of rcu_read_lock(), so increment
252                  * the current counter for the current CPU.  Use volatile
253                  * casts to prevent the compiler from reordering.
254                  */
255
256                 idx = ACCESS_ONCE(rcu_ctrlblk.completed) & 0x1;
257                 ACCESS_ONCE(RCU_DATA_ME()->rcu_flipctr[idx])++;
258
259                 /*
260                  * Now that the per-CPU counter has been incremented, we
261                  * are protected from races with rcu_read_lock() invoked
262                  * from NMI handlers on this CPU.  We can therefore safely
263                  * increment the nesting counter, relieving further NMIs
264                  * of the need to increment the per-CPU counter.
265                  */
266
267                 ACCESS_ONCE(t->rcu_read_lock_nesting) = nesting + 1;
268
269                 /*
270                  * Now that we have preventing any NMIs from storing
271                  * to the ->rcu_flipctr_idx, we can safely use it to
272                  * remember which counter to decrement in the matching
273                  * rcu_read_unlock().
274                  */
275
276                 ACCESS_ONCE(t->rcu_flipctr_idx) = idx;
277                 local_irq_restore(flags);
278         }
279 }
280 EXPORT_SYMBOL_GPL(__rcu_read_lock);
281
282 void __rcu_read_unlock(void)
283 {
284         int idx;
285         struct task_struct *t = current;
286         int nesting;
287
288         nesting = ACCESS_ONCE(t->rcu_read_lock_nesting);
289         if (nesting > 1) {
290
291                 /*
292                  * We are still protected by the enclosing rcu_read_lock(),
293                  * so simply decrement the counter.
294                  */
295
296                 t->rcu_read_lock_nesting = nesting - 1;
297
298         } else {
299                 unsigned long flags;
300
301                 /*
302                  * Disable local interrupts to prevent the grace-period
303                  * detection state machine from seeing us half-done.
304                  * NMIs can still occur, of course, and might themselves
305                  * contain rcu_read_lock() and rcu_read_unlock().
306                  */
307
308                 local_irq_save(flags);
309
310                 /*
311                  * Outermost nesting of rcu_read_unlock(), so we must
312                  * decrement the current counter for the current CPU.
313                  * This must be done carefully, because NMIs can
314                  * occur at any point in this code, and any rcu_read_lock()
315                  * and rcu_read_unlock() pairs in the NMI handlers
316                  * must interact non-destructively with this code.
317                  * Lots of volatile casts, and -very- careful ordering.
318                  *
319                  * Changes to this code, including this one, must be
320                  * inspected, validated, and tested extremely carefully!!!
321                  */
322
323                 /*
324                  * First, pick up the index.
325                  */
326
327                 idx = ACCESS_ONCE(t->rcu_flipctr_idx);
328
329                 /*
330                  * Now that we have fetched the counter index, it is
331                  * safe to decrement the per-task RCU nesting counter.
332                  * After this, any interrupts or NMIs will increment and
333                  * decrement the per-CPU counters.
334                  */
335                 ACCESS_ONCE(t->rcu_read_lock_nesting) = nesting - 1;
336
337                 /*
338                  * It is now safe to decrement this task's nesting count.
339                  * NMIs that occur after this statement will route their
340                  * rcu_read_lock() calls through this "else" clause, and
341                  * will thus start incrementing the per-CPU counter on
342                  * their own.  They will also clobber ->rcu_flipctr_idx,
343                  * but that is OK, since we have already fetched it.
344                  */
345
346                 ACCESS_ONCE(RCU_DATA_ME()->rcu_flipctr[idx])--;
347                 local_irq_restore(flags);
348         }
349 }
350 EXPORT_SYMBOL_GPL(__rcu_read_unlock);
351
352 /*
353  * If a global counter flip has occurred since the last time that we
354  * advanced callbacks, advance them.  Hardware interrupts must be
355  * disabled when calling this function.
356  */
357 static void __rcu_advance_callbacks(struct rcu_data *rdp)
358 {
359         int cpu;
360         int i;
361         int wlc = 0;
362
363         if (rdp->completed != rcu_ctrlblk.completed) {
364                 if (rdp->waitlist[GP_STAGES - 1] != NULL) {
365                         *rdp->donetail = rdp->waitlist[GP_STAGES - 1];
366                         rdp->donetail = rdp->waittail[GP_STAGES - 1];
367                         RCU_TRACE_RDP(rcupreempt_trace_move2done, rdp);
368                 }
369                 for (i = GP_STAGES - 2; i >= 0; i--) {
370                         if (rdp->waitlist[i] != NULL) {
371                                 rdp->waitlist[i + 1] = rdp->waitlist[i];
372                                 rdp->waittail[i + 1] = rdp->waittail[i];
373                                 wlc++;
374                         } else {
375                                 rdp->waitlist[i + 1] = NULL;
376                                 rdp->waittail[i + 1] =
377                                         &rdp->waitlist[i + 1];
378                         }
379                 }
380                 if (rdp->nextlist != NULL) {
381                         rdp->waitlist[0] = rdp->nextlist;
382                         rdp->waittail[0] = rdp->nexttail;
383                         wlc++;
384                         rdp->nextlist = NULL;
385                         rdp->nexttail = &rdp->nextlist;
386                         RCU_TRACE_RDP(rcupreempt_trace_move2wait, rdp);
387                 } else {
388                         rdp->waitlist[0] = NULL;
389                         rdp->waittail[0] = &rdp->waitlist[0];
390                 }
391                 rdp->waitlistcount = wlc;
392                 rdp->completed = rcu_ctrlblk.completed;
393         }
394
395         /*
396          * Check to see if this CPU needs to report that it has seen
397          * the most recent counter flip, thereby declaring that all
398          * subsequent rcu_read_lock() invocations will respect this flip.
399          */
400
401         cpu = raw_smp_processor_id();
402         if (per_cpu(rcu_flip_flag, cpu) == rcu_flipped) {
403                 smp_mb();  /* Subsequent counter accesses must see new value */
404                 per_cpu(rcu_flip_flag, cpu) = rcu_flip_seen;
405                 smp_mb();  /* Subsequent RCU read-side critical sections */
406                            /*  seen -after- acknowledgement. */
407         }
408 }
409
410 /*
411  * Get here when RCU is idle.  Decide whether we need to
412  * move out of idle state, and return non-zero if so.
413  * "Straightforward" approach for the moment, might later
414  * use callback-list lengths, grace-period duration, or
415  * some such to determine when to exit idle state.
416  * Might also need a pre-idle test that does not acquire
417  * the lock, but let's get the simple case working first...
418  */
419
420 static int
421 rcu_try_flip_idle(void)
422 {
423         int cpu;
424
425         RCU_TRACE_ME(rcupreempt_trace_try_flip_i1);
426         if (!rcu_pending(smp_processor_id())) {
427                 RCU_TRACE_ME(rcupreempt_trace_try_flip_ie1);
428                 return 0;
429         }
430
431         /*
432          * Do the flip.
433          */
434
435         RCU_TRACE_ME(rcupreempt_trace_try_flip_g1);
436         rcu_ctrlblk.completed++;  /* stands in for rcu_try_flip_g2 */
437
438         /*
439          * Need a memory barrier so that other CPUs see the new
440          * counter value before they see the subsequent change of all
441          * the rcu_flip_flag instances to rcu_flipped.
442          */
443
444         smp_mb();       /* see above block comment. */
445
446         /* Now ask each CPU for acknowledgement of the flip. */
447
448         for_each_possible_cpu(cpu)
449                 per_cpu(rcu_flip_flag, cpu) = rcu_flipped;
450
451         return 1;
452 }
453
454 /*
455  * Wait for CPUs to acknowledge the flip.
456  */
457
458 static int
459 rcu_try_flip_waitack(void)
460 {
461         int cpu;
462
463         RCU_TRACE_ME(rcupreempt_trace_try_flip_a1);
464         for_each_possible_cpu(cpu)
465                 if (per_cpu(rcu_flip_flag, cpu) != rcu_flip_seen) {
466                         RCU_TRACE_ME(rcupreempt_trace_try_flip_ae1);
467                         return 0;
468                 }
469
470         /*
471          * Make sure our checks above don't bleed into subsequent
472          * waiting for the sum of the counters to reach zero.
473          */
474
475         smp_mb();       /* see above block comment. */
476         RCU_TRACE_ME(rcupreempt_trace_try_flip_a2);
477         return 1;
478 }
479
480 /*
481  * Wait for collective ``last'' counter to reach zero,
482  * then tell all CPUs to do an end-of-grace-period memory barrier.
483  */
484
485 static int
486 rcu_try_flip_waitzero(void)
487 {
488         int cpu;
489         int lastidx = !(rcu_ctrlblk.completed & 0x1);
490         int sum = 0;
491
492         /* Check to see if the sum of the "last" counters is zero. */
493
494         RCU_TRACE_ME(rcupreempt_trace_try_flip_z1);
495         for_each_possible_cpu(cpu)
496                 sum += RCU_DATA_CPU(cpu)->rcu_flipctr[lastidx];
497         if (sum != 0) {
498                 RCU_TRACE_ME(rcupreempt_trace_try_flip_ze1);
499                 return 0;
500         }
501
502         /*
503          * This ensures that the other CPUs see the call for
504          * memory barriers -after- the sum to zero has been
505          * detected here
506          */
507         smp_mb();  /*  ^^^^^^^^^^^^ */
508
509         /* Call for a memory barrier from each CPU. */
510         for_each_possible_cpu(cpu)
511                 per_cpu(rcu_mb_flag, cpu) = rcu_mb_needed;
512
513         RCU_TRACE_ME(rcupreempt_trace_try_flip_z2);
514         return 1;
515 }
516
517 /*
518  * Wait for all CPUs to do their end-of-grace-period memory barrier.
519  * Return 0 once all CPUs have done so.
520  */
521
522 static int
523 rcu_try_flip_waitmb(void)
524 {
525         int cpu;
526
527         RCU_TRACE_ME(rcupreempt_trace_try_flip_m1);
528         for_each_possible_cpu(cpu)
529                 if (per_cpu(rcu_mb_flag, cpu) != rcu_mb_done) {
530                         RCU_TRACE_ME(rcupreempt_trace_try_flip_me1);
531                         return 0;
532                 }
533
534         smp_mb(); /* Ensure that the above checks precede any following flip. */
535         RCU_TRACE_ME(rcupreempt_trace_try_flip_m2);
536         return 1;
537 }
538
539 /*
540  * Attempt a single flip of the counters.  Remember, a single flip does
541  * -not- constitute a grace period.  Instead, the interval between
542  * at least GP_STAGES consecutive flips is a grace period.
543  *
544  * If anyone is nuts enough to run this CONFIG_PREEMPT_RCU implementation
545  * on a large SMP, they might want to use a hierarchical organization of
546  * the per-CPU-counter pairs.
547  */
548 static void rcu_try_flip(void)
549 {
550         unsigned long flags;
551
552         RCU_TRACE_ME(rcupreempt_trace_try_flip_1);
553         if (unlikely(!spin_trylock_irqsave(&rcu_ctrlblk.fliplock, flags))) {
554                 RCU_TRACE_ME(rcupreempt_trace_try_flip_e1);
555                 return;
556         }
557
558         /*
559          * Take the next transition(s) through the RCU grace-period
560          * flip-counter state machine.
561          */
562
563         switch (rcu_ctrlblk.rcu_try_flip_state) {
564         case rcu_try_flip_idle_state:
565                 if (rcu_try_flip_idle())
566                         rcu_ctrlblk.rcu_try_flip_state =
567                                 rcu_try_flip_waitack_state;
568                 break;
569         case rcu_try_flip_waitack_state:
570                 if (rcu_try_flip_waitack())
571                         rcu_ctrlblk.rcu_try_flip_state =
572                                 rcu_try_flip_waitzero_state;
573                 break;
574         case rcu_try_flip_waitzero_state:
575                 if (rcu_try_flip_waitzero())
576                         rcu_ctrlblk.rcu_try_flip_state =
577                                 rcu_try_flip_waitmb_state;
578                 break;
579         case rcu_try_flip_waitmb_state:
580                 if (rcu_try_flip_waitmb())
581                         rcu_ctrlblk.rcu_try_flip_state =
582                                 rcu_try_flip_idle_state;
583         }
584         spin_unlock_irqrestore(&rcu_ctrlblk.fliplock, flags);
585 }
586
587 /*
588  * Check to see if this CPU needs to do a memory barrier in order to
589  * ensure that any prior RCU read-side critical sections have committed
590  * their counter manipulations and critical-section memory references
591  * before declaring the grace period to be completed.
592  */
593 static void rcu_check_mb(int cpu)
594 {
595         if (per_cpu(rcu_mb_flag, cpu) == rcu_mb_needed) {
596                 smp_mb();  /* Ensure RCU read-side accesses are visible. */
597                 per_cpu(rcu_mb_flag, cpu) = rcu_mb_done;
598         }
599 }
600
601 void rcu_check_callbacks(int cpu, int user)
602 {
603         unsigned long flags;
604         struct rcu_data *rdp = RCU_DATA_CPU(cpu);
605
606         rcu_check_mb(cpu);
607         if (rcu_ctrlblk.completed == rdp->completed)
608                 rcu_try_flip();
609         spin_lock_irqsave(&rdp->lock, flags);
610         RCU_TRACE_RDP(rcupreempt_trace_check_callbacks, rdp);
611         __rcu_advance_callbacks(rdp);
612         if (rdp->donelist == NULL) {
613                 spin_unlock_irqrestore(&rdp->lock, flags);
614         } else {
615                 spin_unlock_irqrestore(&rdp->lock, flags);
616                 raise_softirq(RCU_SOFTIRQ);
617         }
618 }
619
620 /*
621  * Needed by dynticks, to make sure all RCU processing has finished
622  * when we go idle:
623  */
624 void rcu_advance_callbacks(int cpu, int user)
625 {
626         unsigned long flags;
627         struct rcu_data *rdp = RCU_DATA_CPU(cpu);
628
629         if (rcu_ctrlblk.completed == rdp->completed) {
630                 rcu_try_flip();
631                 if (rcu_ctrlblk.completed == rdp->completed)
632                         return;
633         }
634         spin_lock_irqsave(&rdp->lock, flags);
635         RCU_TRACE_RDP(rcupreempt_trace_check_callbacks, rdp);
636         __rcu_advance_callbacks(rdp);
637         spin_unlock_irqrestore(&rdp->lock, flags);
638 }
639
640 static void rcu_process_callbacks(struct softirq_action *unused)
641 {
642         unsigned long flags;
643         struct rcu_head *next, *list;
644         struct rcu_data *rdp = RCU_DATA_ME();
645
646         spin_lock_irqsave(&rdp->lock, flags);
647         list = rdp->donelist;
648         if (list == NULL) {
649                 spin_unlock_irqrestore(&rdp->lock, flags);
650                 return;
651         }
652         rdp->donelist = NULL;
653         rdp->donetail = &rdp->donelist;
654         RCU_TRACE_RDP(rcupreempt_trace_done_remove, rdp);
655         spin_unlock_irqrestore(&rdp->lock, flags);
656         while (list) {
657                 next = list->next;
658                 list->func(list);
659                 list = next;
660                 RCU_TRACE_ME(rcupreempt_trace_invoke);
661         }
662 }
663
664 void call_rcu(struct rcu_head *head, void (*func)(struct rcu_head *rcu))
665 {
666         unsigned long flags;
667         struct rcu_data *rdp;
668
669         head->func = func;
670         head->next = NULL;
671         local_irq_save(flags);
672         rdp = RCU_DATA_ME();
673         spin_lock(&rdp->lock);
674         __rcu_advance_callbacks(rdp);
675         *rdp->nexttail = head;
676         rdp->nexttail = &head->next;
677         RCU_TRACE_RDP(rcupreempt_trace_next_add, rdp);
678         spin_unlock(&rdp->lock);
679         local_irq_restore(flags);
680 }
681 EXPORT_SYMBOL_GPL(call_rcu);
682
683 /*
684  * Wait until all currently running preempt_disable() code segments
685  * (including hardware-irq-disable segments) complete.  Note that
686  * in -rt this does -not- necessarily result in all currently executing
687  * interrupt -handlers- having completed.
688  */
689 void __synchronize_sched(void)
690 {
691         cpumask_t oldmask;
692         int cpu;
693
694         if (sched_getaffinity(0, &oldmask) < 0)
695                 oldmask = cpu_possible_map;
696         for_each_online_cpu(cpu) {
697                 sched_setaffinity(0, cpumask_of_cpu(cpu));
698                 schedule();
699         }
700         sched_setaffinity(0, oldmask);
701 }
702 EXPORT_SYMBOL_GPL(__synchronize_sched);
703
704 /*
705  * Check to see if any future RCU-related work will need to be done
706  * by the current CPU, even if none need be done immediately, returning
707  * 1 if so.  Assumes that notifiers would take care of handling any
708  * outstanding requests from the RCU core.
709  *
710  * This function is part of the RCU implementation; it is -not-
711  * an exported member of the RCU API.
712  */
713 int rcu_needs_cpu(int cpu)
714 {
715         struct rcu_data *rdp = RCU_DATA_CPU(cpu);
716
717         return (rdp->donelist != NULL ||
718                 !!rdp->waitlistcount ||
719                 rdp->nextlist != NULL);
720 }
721
722 int rcu_pending(int cpu)
723 {
724         struct rcu_data *rdp = RCU_DATA_CPU(cpu);
725
726         /* The CPU has at least one callback queued somewhere. */
727
728         if (rdp->donelist != NULL ||
729             !!rdp->waitlistcount ||
730             rdp->nextlist != NULL)
731                 return 1;
732
733         /* The RCU core needs an acknowledgement from this CPU. */
734
735         if ((per_cpu(rcu_flip_flag, cpu) == rcu_flipped) ||
736             (per_cpu(rcu_mb_flag, cpu) == rcu_mb_needed))
737                 return 1;
738
739         /* This CPU has fallen behind the global grace-period number. */
740
741         if (rdp->completed != rcu_ctrlblk.completed)
742                 return 1;
743
744         /* Nothing needed from this CPU. */
745
746         return 0;
747 }
748
749 void __init __rcu_init(void)
750 {
751         int cpu;
752         int i;
753         struct rcu_data *rdp;
754
755         printk(KERN_NOTICE "Preemptible RCU implementation.\n");
756         for_each_possible_cpu(cpu) {
757                 rdp = RCU_DATA_CPU(cpu);
758                 spin_lock_init(&rdp->lock);
759                 rdp->completed = 0;
760                 rdp->waitlistcount = 0;
761                 rdp->nextlist = NULL;
762                 rdp->nexttail = &rdp->nextlist;
763                 for (i = 0; i < GP_STAGES; i++) {
764                         rdp->waitlist[i] = NULL;
765                         rdp->waittail[i] = &rdp->waitlist[i];
766                 }
767                 rdp->donelist = NULL;
768                 rdp->donetail = &rdp->donelist;
769                 rdp->rcu_flipctr[0] = 0;
770                 rdp->rcu_flipctr[1] = 0;
771         }
772         open_softirq(RCU_SOFTIRQ, rcu_process_callbacks, NULL);
773 }
774
775 /*
776  * Deprecated, use synchronize_rcu() or synchronize_sched() instead.
777  */
778 void synchronize_kernel(void)
779 {
780         synchronize_rcu();
781 }
782
783 #ifdef CONFIG_RCU_TRACE
784 long *rcupreempt_flipctr(int cpu)
785 {
786         return &RCU_DATA_CPU(cpu)->rcu_flipctr[0];
787 }
788 EXPORT_SYMBOL_GPL(rcupreempt_flipctr);
789
790 int rcupreempt_flip_flag(int cpu)
791 {
792         return per_cpu(rcu_flip_flag, cpu);
793 }
794 EXPORT_SYMBOL_GPL(rcupreempt_flip_flag);
795
796 int rcupreempt_mb_flag(int cpu)
797 {
798         return per_cpu(rcu_mb_flag, cpu);
799 }
800 EXPORT_SYMBOL_GPL(rcupreempt_mb_flag);
801
802 char *rcupreempt_try_flip_state_name(void)
803 {
804         return rcu_try_flip_state_names[rcu_ctrlblk.rcu_try_flip_state];
805 }
806 EXPORT_SYMBOL_GPL(rcupreempt_try_flip_state_name);
807
808 struct rcupreempt_trace *rcupreempt_trace_cpu(int cpu)
809 {
810         struct rcu_data *rdp = RCU_DATA_CPU(cpu);
811
812         return &rdp->trace;
813 }
814 EXPORT_SYMBOL_GPL(rcupreempt_trace_cpu);
815
816 #endif /* #ifdef RCU_TRACE */