Preempt-RCU: implementation

This patch implements a new version of RCU which allows its read-side
critical sections to be preempted. It uses a set of counter pairs
to keep track of the read-side critical sections and flips them
when all tasks exit read-side critical section. The details
of this implementation can be found in this paper -

	http://www.rdrop.com/users/paulmck/RCU/OLSrtRCU.2006.08.11a.pdf

and the article-

	http://lwn.net/Articles/253651/

This patch was developed as a part of the -rt kernel development and
meant to provide better latencies when read-side critical sections of
RCU don't disable preemption.  As a consequence of keeping track of RCU
readers, the readers have a slight overhead (optimizations in the paper).
This implementation co-exists with the "classic" RCU implementations
and can be switched to at compiler.

Also includes RCU tracing summarized in debugfs.

[ akpm@linux-foundation.org: build fixes on non-preempt architectures ]

Signed-off-by: Gautham R Shenoy <ego@in.ibm.com>
Signed-off-by: Dipankar Sarma <dipankar@in.ibm.com>
Signed-off-by: Paul E. McKenney <paulmck@us.ibm.com>
Reviewed-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>

1 files changed, 816 insertions, 0 deletions

diff --git a/kernel/rcupreempt.c b/kernel/rcupreempt.c
new file mode 100644
index 000000000000..a5aabb1677f8
--- /dev/null
+++ b/kernel/rcupreempt.c
@@ -0,0 +1,816 @@
+/*
+ * Read-Copy Update mechanism for mutual exclusion, realtime implementation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * Copyright IBM Corporation, 2006
+ *
+ * Authors: Paul E. McKenney <paulmck@us.ibm.com>
+ *              With thanks to Esben Nielsen, Bill Huey, and Ingo Molnar
+ *              for pushing me away from locks and towards counters, and
+ *              to Suparna Bhattacharya for pushing me completely away
+ *              from atomic instructions on the read side.
+ *
+ * Papers:  http://www.rdrop.com/users/paulmck/RCU
+ *
+ * Design Document: http://lwn.net/Articles/253651/
+ *
+ * For detailed explanation of Read-Copy Update mechanism see -
+ *              Documentation/RCU/ *.txt
+ *
+ */
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/spinlock.h>
+#include <linux/smp.h>
+#include <linux/rcupdate.h>
+#include <linux/interrupt.h>
+#include <linux/sched.h>
+#include <asm/atomic.h>
+#include <linux/bitops.h>
+#include <linux/module.h>
+#include <linux/completion.h>
+#include <linux/moduleparam.h>
+#include <linux/percpu.h>
+#include <linux/notifier.h>
+#include <linux/rcupdate.h>
+#include <linux/cpu.h>
+#include <linux/random.h>
+#include <linux/delay.h>
+#include <linux/byteorder/swabb.h>
+#include <linux/cpumask.h>
+#include <linux/rcupreempt_trace.h>
+
+/*
+ * Macro that prevents the compiler from reordering accesses, but does
+ * absolutely -nothing- to prevent CPUs from reordering.  This is used
+ * only to mediate communication between mainline code and hardware
+ * interrupt and NMI handlers.
+ */
+#define ACCESS_ONCE(x) (*(volatile typeof(x) *)&(x))
+
+/*
+ * PREEMPT_RCU data structures.
+ */
+
+/*
+ * GP_STAGES specifies the number of times the state machine has
+ * to go through the all the rcu_try_flip_states (see below)
+ * in a single Grace Period.
+ *
+ * GP in GP_STAGES stands for Grace Period ;)
+ */
+#define GP_STAGES    2
+struct rcu_data {
+        spinlock_t      lock;           /* Protect rcu_data fields. */
+        long            completed;      /* Number of last completed batch. */
+        int             waitlistcount;
+        struct tasklet_struct rcu_tasklet;
+        struct rcu_head *nextlist;
+        struct rcu_head **nexttail;
+        struct rcu_head *waitlist[GP_STAGES];
+        struct rcu_head **waittail[GP_STAGES];
+        struct rcu_head *donelist;
+        struct rcu_head **donetail;
+        long rcu_flipctr[2];
+#ifdef CONFIG_RCU_TRACE
+        struct rcupreempt_trace trace;
+#endif /* #ifdef CONFIG_RCU_TRACE */
+};
+
+/*
+ * States for rcu_try_flip() and friends.
+ */
+
+enum rcu_try_flip_states {
+
+        /*
+         * Stay here if nothing is happening. Flip the counter if somthing
+         * starts happening. Denoted by "I"
+         */
+        rcu_try_flip_idle_state,
+
+        /*
+         * Wait here for all CPUs to notice that the counter has flipped. This
+         * prevents the old set of counters from ever being incremented once
+         * we leave this state, which in turn is necessary because we cannot
+         * test any individual counter for zero -- we can only check the sum.
+         * Denoted by "A".
+         */
+        rcu_try_flip_waitack_state,
+
+        /*
+         * Wait here for the sum of the old per-CPU counters to reach zero.
+         * Denoted by "Z".
+         */
+        rcu_try_flip_waitzero_state,
+
+        /*
+         * Wait here for each of the other CPUs to execute a memory barrier.
+         * This is necessary to ensure that these other CPUs really have
+         * completed executing their RCU read-side critical sections, despite
+         * their CPUs wildly reordering memory. Denoted by "M".
+         */
+        rcu_try_flip_waitmb_state,
+};
+
+struct rcu_ctrlblk {
+        spinlock_t      fliplock;       /* Protect state-machine transitions. */
+        long            completed;      /* Number of last completed batch. */
+        enum rcu_try_flip_states rcu_try_flip_state; /* The current state of
+                                                        the rcu state machine */
+};
+
+static DEFINE_PER_CPU(struct rcu_data, rcu_data);
+static struct rcu_ctrlblk rcu_ctrlblk = {
+        .fliplock = __SPIN_LOCK_UNLOCKED(rcu_ctrlblk.fliplock),
+        .completed = 0,
+        .rcu_try_flip_state = rcu_try_flip_idle_state,
+};
+
+
+#ifdef CONFIG_RCU_TRACE
+static char *rcu_try_flip_state_names[] =
+        { "idle", "waitack", "waitzero", "waitmb" };
+#endif /* #ifdef CONFIG_RCU_TRACE */
+
+/*
+ * Enum and per-CPU flag to determine when each CPU has seen
+ * the most recent counter flip.
+ */
+
+enum rcu_flip_flag_values {
+        rcu_flip_seen,          /* Steady/initial state, last flip seen. */
+                                /* Only GP detector can update. */
+        rcu_flipped             /* Flip just completed, need confirmation. */
+                                /* Only corresponding CPU can update. */
+};
+static DEFINE_PER_CPU_SHARED_ALIGNED(enum rcu_flip_flag_values, rcu_flip_flag)
+                                                                = rcu_flip_seen;
+
+/*
+ * Enum and per-CPU flag to determine when each CPU has executed the
+ * needed memory barrier to fence in memory references from its last RCU
+ * read-side critical section in the just-completed grace period.
+ */
+
+enum rcu_mb_flag_values {
+        rcu_mb_done,            /* Steady/initial state, no mb()s required. */
+                                /* Only GP detector can update. */
+        rcu_mb_needed           /* Flip just completed, need an mb(). */
+                                /* Only corresponding CPU can update. */
+};
+static DEFINE_PER_CPU_SHARED_ALIGNED(enum rcu_mb_flag_values, rcu_mb_flag)
+                                                                = rcu_mb_done;
+
+/*
+ * RCU_DATA_ME: find the current CPU's rcu_data structure.
+ * RCU_DATA_CPU: find the specified CPU's rcu_data structure.
+ */
+#define RCU_DATA_ME()           (&__get_cpu_var(rcu_data))
+#define RCU_DATA_CPU(cpu)       (&per_cpu(rcu_data, cpu))
+
+/*
+ * Helper macro for tracing when the appropriate rcu_data is not
+ * cached in a local variable, but where the CPU number is so cached.
+ */
+#define RCU_TRACE_CPU(f, cpu) RCU_TRACE(f, &(RCU_DATA_CPU(cpu)->trace));
+
+/*
+ * Helper macro for tracing when the appropriate rcu_data is not
+ * cached in a local variable.
+ */
+#define RCU_TRACE_ME(f) RCU_TRACE(f, &(RCU_DATA_ME()->trace));
+
+/*
+ * Helper macro for tracing when the appropriate rcu_data is pointed
+ * to by a local variable.
+ */
+#define RCU_TRACE_RDP(f, rdp) RCU_TRACE(f, &((rdp)->trace));
+
+/*
+ * Return the number of RCU batches processed thus far.  Useful
+ * for debug and statistics.
+ */
+long rcu_batches_completed(void)
+{
+        return rcu_ctrlblk.completed;
+}
+EXPORT_SYMBOL_GPL(rcu_batches_completed);
+
+EXPORT_SYMBOL_GPL(rcu_batches_completed_bh);
+
+void __rcu_read_lock(void)
+{
+        int idx;
+        struct task_struct *t = current;
+        int nesting;
+
+        nesting = ACCESS_ONCE(t->rcu_read_lock_nesting);
+        if (nesting != 0) {
+
+                /* An earlier rcu_read_lock() covers us, just count it. */
+
+                t->rcu_read_lock_nesting = nesting + 1;
+
+        } else {
+                unsigned long flags;
+
+                /*
+                 * We disable interrupts for the following reasons:
+                 * - If we get scheduling clock interrupt here, and we
+                 *   end up acking the counter flip, it's like a promise
+                 *   that we will never increment the old counter again.
+                 *   Thus we will break that promise if that
+                 *   scheduling clock interrupt happens between the time
+                 *   we pick the .completed field and the time that we
+                 *   increment our counter.
+                 *
+                 * - We don't want to be preempted out here.
+                 *
+                 * NMIs can still occur, of course, and might themselves
+                 * contain rcu_read_lock().
+                 */
+
+                local_irq_save(flags);
+
+                /*
+                 * Outermost nesting of rcu_read_lock(), so increment
+                 * the current counter for the current CPU.  Use volatile
+                 * casts to prevent the compiler from reordering.
+                 */
+
+                idx = ACCESS_ONCE(rcu_ctrlblk.completed) & 0x1;
+                ACCESS_ONCE(RCU_DATA_ME()->rcu_flipctr[idx])++;
+
+                /*
+                 * Now that the per-CPU counter has been incremented, we
+                 * are protected from races with rcu_read_lock() invoked
+                 * from NMI handlers on this CPU.  We can therefore safely
+                 * increment the nesting counter, relieving further NMIs
+                 * of the need to increment the per-CPU counter.
+                 */
+
+                ACCESS_ONCE(t->rcu_read_lock_nesting) = nesting + 1;
+
+                /*
+                 * Now that we have preventing any NMIs from storing
+                 * to the ->rcu_flipctr_idx, we can safely use it to
+                 * remember which counter to decrement in the matching
+                 * rcu_read_unlock().
+                 */
+
+                ACCESS_ONCE(t->rcu_flipctr_idx) = idx;
+                local_irq_restore(flags);
+        }
+}
+EXPORT_SYMBOL_GPL(__rcu_read_lock);
+
+void __rcu_read_unlock(void)
+{
+        int idx;
+        struct task_struct *t = current;
+        int nesting;
+
+        nesting = ACCESS_ONCE(t->rcu_read_lock_nesting);
+        if (nesting > 1) {
+
+                /*
+                 * We are still protected by the enclosing rcu_read_lock(),
+                 * so simply decrement the counter.
+                 */
+
+                t->rcu_read_lock_nesting = nesting - 1;
+
+        } else {
+                unsigned long flags;
+
+                /*
+                 * Disable local interrupts to prevent the grace-period
+                 * detection state machine from seeing us half-done.
+                 * NMIs can still occur, of course, and might themselves
+                 * contain rcu_read_lock() and rcu_read_unlock().
+                 */
+
+                local_irq_save(flags);
+
+                /*
+                 * Outermost nesting of rcu_read_unlock(), so we must
+                 * decrement the current counter for the current CPU.
+                 * This must be done carefully, because NMIs can
+                 * occur at any point in this code, and any rcu_read_lock()
+                 * and rcu_read_unlock() pairs in the NMI handlers
+                 * must interact non-destructively with this code.
+                 * Lots of volatile casts, and -very- careful ordering.
+                 *
+                 * Changes to this code, including this one, must be
+                 * inspected, validated, and tested extremely carefully!!!
+                 */
+
+                /*
+                 * First, pick up the index.
+                 */
+
+                idx = ACCESS_ONCE(t->rcu_flipctr_idx);
+
+                /*
+                 * Now that we have fetched the counter index, it is
+                 * safe to decrement the per-task RCU nesting counter.
+                 * After this, any interrupts or NMIs will increment and
+                 * decrement the per-CPU counters.
+                 */
+                ACCESS_ONCE(t->rcu_read_lock_nesting) = nesting - 1;
+
+                /*
+                 * It is now safe to decrement this task's nesting count.
+                 * NMIs that occur after this statement will route their
+                 * rcu_read_lock() calls through this "else" clause, and
+                 * will thus start incrementing the per-CPU counter on
+                 * their own.  They will also clobber ->rcu_flipctr_idx,
+                 * but that is OK, since we have already fetched it.
+                 */
+
+                ACCESS_ONCE(RCU_DATA_ME()->rcu_flipctr[idx])--;
+                local_irq_restore(flags);
+        }
+}
+EXPORT_SYMBOL_GPL(__rcu_read_unlock);
+
+/*
+ * If a global counter flip has occurred since the last time that we
+ * advanced callbacks, advance them.  Hardware interrupts must be
+ * disabled when calling this function.
+ */
+static void __rcu_advance_callbacks(struct rcu_data *rdp)
+{
+        int cpu;
+        int i;
+        int wlc = 0;
+
+        if (rdp->completed != rcu_ctrlblk.completed) {
+                if (rdp->waitlist[GP_STAGES - 1] != NULL) {
+                        *rdp->donetail = rdp->waitlist[GP_STAGES - 1];
+                        rdp->donetail = rdp->waittail[GP_STAGES - 1];
+                        RCU_TRACE_RDP(rcupreempt_trace_move2done, rdp);
+                }
+                for (i = GP_STAGES - 2; i >= 0; i--) {
+                        if (rdp->waitlist[i] != NULL) {
+                                rdp->waitlist[i + 1] = rdp->waitlist[i];
+                                rdp->waittail[i + 1] = rdp->waittail[i];
+                                wlc++;
+                        } else {
+                                rdp->waitlist[i + 1] = NULL;
+                                rdp->waittail[i + 1] =
+                                        &rdp->waitlist[i + 1];
+                        }
+                }
+                if (rdp->nextlist != NULL) {
+                        rdp->waitlist[0] = rdp->nextlist;
+                        rdp->waittail[0] = rdp->nexttail;
+                        wlc++;
+                        rdp->nextlist = NULL;
+                        rdp->nexttail = &rdp->nextlist;
+                        RCU_TRACE_RDP(rcupreempt_trace_move2wait, rdp);
+                } else {
+                        rdp->waitlist[0] = NULL;
+                        rdp->waittail[0] = &rdp->waitlist[0];
+                }
+                rdp->waitlistcount = wlc;
+                rdp->completed = rcu_ctrlblk.completed;
+        }
+
+        /*
+         * Check to see if this CPU needs to report that it has seen
+         * the most recent counter flip, thereby declaring that all
+         * subsequent rcu_read_lock() invocations will respect this flip.
+         */
+
+        cpu = raw_smp_processor_id();
+        if (per_cpu(rcu_flip_flag, cpu) == rcu_flipped) {
+                smp_mb();  /* Subsequent counter accesses must see new value */
+                per_cpu(rcu_flip_flag, cpu) = rcu_flip_seen;
+                smp_mb();  /* Subsequent RCU read-side critical sections */
+                           /*  seen -after- acknowledgement. */
+        }
+}
+
+/*
+ * Get here when RCU is idle.  Decide whether we need to
+ * move out of idle state, and return non-zero if so.
+ * "Straightforward" approach for the moment, might later
+ * use callback-list lengths, grace-period duration, or
+ * some such to determine when to exit idle state.
+ * Might also need a pre-idle test that does not acquire
+ * the lock, but let's get the simple case working first...
+ */
+
+static int
+rcu_try_flip_idle(void)
+{
+        int cpu;
+
+        RCU_TRACE_ME(rcupreempt_trace_try_flip_i1);
+        if (!rcu_pending(smp_processor_id())) {
+                RCU_TRACE_ME(rcupreempt_trace_try_flip_ie1);
+                return 0;
+        }
+
+        /*
+         * Do the flip.
+         */
+
+        RCU_TRACE_ME(rcupreempt_trace_try_flip_g1);
+        rcu_ctrlblk.completed++;  /* stands in for rcu_try_flip_g2 */
+
+        /*
+         * Need a memory barrier so that other CPUs see the new
+         * counter value before they see the subsequent change of all
+         * the rcu_flip_flag instances to rcu_flipped.
+         */
+
+        smp_mb();       /* see above block comment. */
+
+        /* Now ask each CPU for acknowledgement of the flip. */
+
+        for_each_possible_cpu(cpu)
+                per_cpu(rcu_flip_flag, cpu) = rcu_flipped;
+
+        return 1;
+}
+
+/*
+ * Wait for CPUs to acknowledge the flip.
+ */
+
+static int
+rcu_try_flip_waitack(void)
+{
+        int cpu;
+
+        RCU_TRACE_ME(rcupreempt_trace_try_flip_a1);
+        for_each_possible_cpu(cpu)
+                if (per_cpu(rcu_flip_flag, cpu) != rcu_flip_seen) {
+                        RCU_TRACE_ME(rcupreempt_trace_try_flip_ae1);
+                        return 0;
+                }
+
+        /*
+         * Make sure our checks above don't bleed into subsequent
+         * waiting for the sum of the counters to reach zero.
+         */
+
+        smp_mb();       /* see above block comment. */
+        RCU_TRACE_ME(rcupreempt_trace_try_flip_a2);
+        return 1;
+}
+
+/*
+ * Wait for collective ``last'' counter to reach zero,
+ * then tell all CPUs to do an end-of-grace-period memory barrier.
+ */
+
+static int
+rcu_try_flip_waitzero(void)
+{
+        int cpu;
+        int lastidx = !(rcu_ctrlblk.completed & 0x1);
+        int sum = 0;
+
+        /* Check to see if the sum of the "last" counters is zero. */
+
+        RCU_TRACE_ME(rcupreempt_trace_try_flip_z1);
+        for_each_possible_cpu(cpu)
+                sum += RCU_DATA_CPU(cpu)->rcu_flipctr[lastidx];
+        if (sum != 0) {
+                RCU_TRACE_ME(rcupreempt_trace_try_flip_ze1);
+                return 0;
+        }
+
+        /*
+         * This ensures that the other CPUs see the call for
+         * memory barriers -after- the sum to zero has been
+         * detected here
+         */
+        smp_mb();  /*  ^^^^^^^^^^^^ */
+
+        /* Call for a memory barrier from each CPU. */
+        for_each_possible_cpu(cpu)
+                per_cpu(rcu_mb_flag, cpu) = rcu_mb_needed;
+
+        RCU_TRACE_ME(rcupreempt_trace_try_flip_z2);
+        return 1;
+}
+
+/*
+ * Wait for all CPUs to do their end-of-grace-period memory barrier.
+ * Return 0 once all CPUs have done so.
+ */
+
+static int
+rcu_try_flip_waitmb(void)
+{
+        int cpu;
+
+        RCU_TRACE_ME(rcupreempt_trace_try_flip_m1);
+        for_each_possible_cpu(cpu)
+                if (per_cpu(rcu_mb_flag, cpu) != rcu_mb_done) {
+                        RCU_TRACE_ME(rcupreempt_trace_try_flip_me1);
+                        return 0;
+                }
+
+        smp_mb(); /* Ensure that the above checks precede any following flip. */
+        RCU_TRACE_ME(rcupreempt_trace_try_flip_m2);
+        return 1;
+}
+
+/*
+ * Attempt a single flip of the counters.  Remember, a single flip does
+ * -not- constitute a grace period.  Instead, the interval between
+ * at least GP_STAGES consecutive flips is a grace period.
+ *
+ * If anyone is nuts enough to run this CONFIG_PREEMPT_RCU implementation
+ * on a large SMP, they might want to use a hierarchical organization of
+ * the per-CPU-counter pairs.
+ */
+static void rcu_try_flip(void)
+{
+        unsigned long flags;
+
+        RCU_TRACE_ME(rcupreempt_trace_try_flip_1);
+        if (unlikely(!spin_trylock_irqsave(&rcu_ctrlblk.fliplock, flags))) {
+                RCU_TRACE_ME(rcupreempt_trace_try_flip_e1);
+                return;
+        }
+
+        /*
+         * Take the next transition(s) through the RCU grace-period
+         * flip-counter state machine.
+         */
+
+        switch (rcu_ctrlblk.rcu_try_flip_state) {
+        case rcu_try_flip_idle_state:
+                if (rcu_try_flip_idle())
+                        rcu_ctrlblk.rcu_try_flip_state =
+                                rcu_try_flip_waitack_state;
+                break;
+        case rcu_try_flip_waitack_state:
+                if (rcu_try_flip_waitack())
+                        rcu_ctrlblk.rcu_try_flip_state =
+                                rcu_try_flip_waitzero_state;
+                break;
+        case rcu_try_flip_waitzero_state:
+                if (rcu_try_flip_waitzero())
+                        rcu_ctrlblk.rcu_try_flip_state =
+                                rcu_try_flip_waitmb_state;
+                break;
+        case rcu_try_flip_waitmb_state:
+                if (rcu_try_flip_waitmb())
+                        rcu_ctrlblk.rcu_try_flip_state =
+                                rcu_try_flip_idle_state;
+        }
+        spin_unlock_irqrestore(&rcu_ctrlblk.fliplock, flags);
+}
+
+/*
+ * Check to see if this CPU needs to do a memory barrier in order to
+ * ensure that any prior RCU read-side critical sections have committed
+ * their counter manipulations and critical-section memory references
+ * before declaring the grace period to be completed.
+ */
+static void rcu_check_mb(int cpu)
+{
+        if (per_cpu(rcu_mb_flag, cpu) == rcu_mb_needed) {
+                smp_mb();  /* Ensure RCU read-side accesses are visible. */
+                per_cpu(rcu_mb_flag, cpu) = rcu_mb_done;
+        }
+}
+
+void rcu_check_callbacks(int cpu, int user)
+{
+        unsigned long flags;
+        struct rcu_data *rdp = RCU_DATA_CPU(cpu);
+
+        rcu_check_mb(cpu);
+        if (rcu_ctrlblk.completed == rdp->completed)
+                rcu_try_flip();
+        spin_lock_irqsave(&rdp->lock, flags);
+        RCU_TRACE_RDP(rcupreempt_trace_check_callbacks, rdp);
+        __rcu_advance_callbacks(rdp);
+        if (rdp->donelist == NULL) {
+                spin_unlock_irqrestore(&rdp->lock, flags);
+        } else {
+                spin_unlock_irqrestore(&rdp->lock, flags);
+                raise_softirq(RCU_SOFTIRQ);
+        }
+}
+
+/*
+ * Needed by dynticks, to make sure all RCU processing has finished
+ * when we go idle:
+ */
+void rcu_advance_callbacks(int cpu, int user)
+{
+        unsigned long flags;
+        struct rcu_data *rdp = RCU_DATA_CPU(cpu);
+
+        if (rcu_ctrlblk.completed == rdp->completed) {
+                rcu_try_flip();
+                if (rcu_ctrlblk.completed == rdp->completed)
+                        return;
+        }
+        spin_lock_irqsave(&rdp->lock, flags);
+        RCU_TRACE_RDP(rcupreempt_trace_check_callbacks, rdp);
+        __rcu_advance_callbacks(rdp);
+        spin_unlock_irqrestore(&rdp->lock, flags);
+}
+
+static void rcu_process_callbacks(struct softirq_action *unused)
+{
+        unsigned long flags;
+        struct rcu_head *next, *list;
+        struct rcu_data *rdp = RCU_DATA_ME();
+
+        spin_lock_irqsave(&rdp->lock, flags);
+        list = rdp->donelist;
+        if (list == NULL) {
+                spin_unlock_irqrestore(&rdp->lock, flags);
+                return;
+        }
+        rdp->donelist = NULL;
+        rdp->donetail = &rdp->donelist;
+        RCU_TRACE_RDP(rcupreempt_trace_done_remove, rdp);
+        spin_unlock_irqrestore(&rdp->lock, flags);
+        while (list) {
+                next = list->next;
+                list->func(list);
+                list = next;
+                RCU_TRACE_ME(rcupreempt_trace_invoke);
+        }
+}
+
+void call_rcu(struct rcu_head *head, void (*func)(struct rcu_head *rcu))
+{
+        unsigned long flags;
+        struct rcu_data *rdp;
+
+        head->func = func;
+        head->next = NULL;
+        local_irq_save(flags);
+        rdp = RCU_DATA_ME();
+        spin_lock(&rdp->lock);
+        __rcu_advance_callbacks(rdp);
+        *rdp->nexttail = head;
+        rdp->nexttail = &head->next;
+        RCU_TRACE_RDP(rcupreempt_trace_next_add, rdp);
+        spin_unlock(&rdp->lock);
+        local_irq_restore(flags);
+}
+EXPORT_SYMBOL_GPL(call_rcu);
+
+/*
+ * Wait until all currently running preempt_disable() code segments
+ * (including hardware-irq-disable segments) complete.  Note that
+ * in -rt this does -not- necessarily result in all currently executing
+ * interrupt -handlers- having completed.
+ */
+void __synchronize_sched(void)
+{
+        cpumask_t oldmask;
+        int cpu;
+
+        if (sched_getaffinity(0, &oldmask) < 0)
+                oldmask = cpu_possible_map;
+        for_each_online_cpu(cpu) {
+                sched_setaffinity(0, cpumask_of_cpu(cpu));
+                schedule();
+        }
+        sched_setaffinity(0, oldmask);
+}
+EXPORT_SYMBOL_GPL(__synchronize_sched);
+
+/*
+ * Check to see if any future RCU-related work will need to be done
+ * by the current CPU, even if none need be done immediately, returning
+ * 1 if so.  Assumes that notifiers would take care of handling any
+ * outstanding requests from the RCU core.
+ *
+ * This function is part of the RCU implementation; it is -not-
+ * an exported member of the RCU API.
+ */
+int rcu_needs_cpu(int cpu)
+{
+        struct rcu_data *rdp = RCU_DATA_CPU(cpu);
+
+        return (rdp->donelist != NULL ||
+                !!rdp->waitlistcount ||
+                rdp->nextlist != NULL);
+}
+
+int rcu_pending(int cpu)
+{
+        struct rcu_data *rdp = RCU_DATA_CPU(cpu);
+
+        /* The CPU has at least one callback queued somewhere. */
+
+        if (rdp->donelist != NULL ||
+            !!rdp->waitlistcount ||
+            rdp->nextlist != NULL)
+                return 1;
+
+        /* The RCU core needs an acknowledgement from this CPU. */
+
+        if ((per_cpu(rcu_flip_flag, cpu) == rcu_flipped) ||
+            (per_cpu(rcu_mb_flag, cpu) == rcu_mb_needed))
+                return 1;
+
+        /* This CPU has fallen behind the global grace-period number. */
+
+        if (rdp->completed != rcu_ctrlblk.completed)
+                return 1;
+
+        /* Nothing needed from this CPU. */
+
+        return 0;
+}
+
+void __init __rcu_init(void)
+{
+        int cpu;
+        int i;
+        struct rcu_data *rdp;
+
+        printk(KERN_NOTICE "Preemptible RCU implementation.\n");
+        for_each_possible_cpu(cpu) {
+                rdp = RCU_DATA_CPU(cpu);
+                spin_lock_init(&rdp->lock);
+                rdp->completed = 0;
+                rdp->waitlistcount = 0;
+                rdp->nextlist = NULL;
+                rdp->nexttail = &rdp->nextlist;
+                for (i = 0; i < GP_STAGES; i++) {
+                        rdp->waitlist[i] = NULL;
+                        rdp->waittail[i] = &rdp->waitlist[i];
+                }
+                rdp->donelist = NULL;
+                rdp->donetail = &rdp->donelist;
+                rdp->rcu_flipctr[0] = 0;
+                rdp->rcu_flipctr[1] = 0;
+        }
+        open_softirq(RCU_SOFTIRQ, rcu_process_callbacks, NULL);
+}
+
+/*
+ * Deprecated, use synchronize_rcu() or synchronize_sched() instead.
+ */
+void synchronize_kernel(void)
+{
+        synchronize_rcu();
+}
+
+#ifdef CONFIG_RCU_TRACE
+long *rcupreempt_flipctr(int cpu)
+{
+        return &RCU_DATA_CPU(cpu)->rcu_flipctr[0];
+}
+EXPORT_SYMBOL_GPL(rcupreempt_flipctr);
+
+int rcupreempt_flip_flag(int cpu)
+{
+        return per_cpu(rcu_flip_flag, cpu);
+}
+EXPORT_SYMBOL_GPL(rcupreempt_flip_flag);
+
+int rcupreempt_mb_flag(int cpu)
+{
+        return per_cpu(rcu_mb_flag, cpu);
+}
+EXPORT_SYMBOL_GPL(rcupreempt_mb_flag);
+
+char *rcupreempt_try_flip_state_name(void)
+{
+        return rcu_try_flip_state_names[rcu_ctrlblk.rcu_try_flip_state];
+}
+EXPORT_SYMBOL_GPL(rcupreempt_try_flip_state_name);
+
+struct rcupreempt_trace *rcupreempt_trace_cpu(int cpu)
+{
+        struct rcu_data *rdp = RCU_DATA_CPU(cpu);
+
+        return &rdp->trace;
+}
+EXPORT_SYMBOL_GPL(rcupreempt_trace_cpu);
+
+#endif /* #ifdef RCU_TRACE */