rcu: Express Tiny RCU updates in terms of RCU rather than RCU-sched

This commit renames Tiny RCU functions so that the lowest level of
functionality is RCU (e.g., synchronize_rcu()) rather than RCU-sched
(e.g., synchronize_sched()).  This provides greater naming compatibility
with Tree RCU, which will in turn permit more LoC removal once
the RCU-sched and RCU-bh update-side API is removed.

Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
[ paulmck: Fix Tiny call_rcu()'s EXPORT_SYMBOL() in response to a bug
  report from kbuild test robot. ]

diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index 94474bb6b5c4200a5e2f625129641810af76d7c4..1207c6c9bd8b6c86fa240f6b083de70456ab3d05 100644 (file)
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -49,15 +49,14 @@
 
 /* Exported common interfaces */
 
-#ifdef CONFIG_TINY_RCU
-#define        call_rcu        call_rcu_sched
-#else
-void call_rcu(struct rcu_head *head, rcu_callback_t func);
+#ifndef CONFIG_TINY_RCU
+void synchronize_sched(void);
+void call_rcu_sched(struct rcu_head *head, rcu_callback_t func);
 #endif
 
-void call_rcu_sched(struct rcu_head *head, rcu_callback_t func);
-void synchronize_sched(void);
+void call_rcu(struct rcu_head *head, rcu_callback_t func);
 void rcu_barrier_tasks(void);
+void synchronize_rcu(void);
 
 static inline void call_rcu_bh(struct rcu_head *head, rcu_callback_t func)
 {
@@ -68,7 +67,6 @@ static inline void call_rcu_bh(struct rcu_head *head, rcu_callback_t func)
 
 void __rcu_read_lock(void);
 void __rcu_read_unlock(void);
-void synchronize_rcu(void);
 
 /*
  * Defined as a macro as it is a very low level header included from

diff --git a/include/linux/rcutiny.h b/include/linux/rcutiny.h
index df2c0895c5e7dd183219c0ce773c2e938c319dcd..e66fb8bc2127025d35ad8b3508ca9d6ee918e4e8 100644 (file)
--- a/include/linux/rcutiny.h
+++ b/include/linux/rcutiny.h
@@ -36,9 +36,9 @@ static inline int rcu_dynticks_snap(struct rcu_dynticks *rdtp)
 /* Never flag non-existent other CPUs! */
 static inline bool rcu_eqs_special_set(int cpu) { return false; }
 
-static inline void synchronize_rcu(void)
+static inline void synchronize_sched(void)
 {
-       synchronize_sched();
+       synchronize_rcu();
 }
 
 static inline unsigned long get_state_synchronize_rcu(void)
@@ -61,16 +61,11 @@ static inline void cond_synchronize_sched(unsigned long oldstate)
        might_sleep();
 }
 
-static inline void synchronize_rcu_expedited(void)
-{
-       synchronize_sched();    /* Only one CPU, so pretty fast anyway!!! */
-}
+extern void rcu_barrier(void);
 
-extern void rcu_barrier_sched(void);
-
-static inline void rcu_barrier(void)
+static inline void rcu_barrier_sched(void)
 {
-       rcu_barrier_sched();  /* Only one CPU, so only one list of callbacks! */
+       rcu_barrier();  /* Only one CPU, so only one list of callbacks! */
 }
 
 static inline void rcu_barrier_bh(void)
@@ -88,27 +83,36 @@ static inline void synchronize_rcu_bh_expedited(void)
        synchronize_sched();
 }
 
+static inline void synchronize_rcu_expedited(void)
+{
+       synchronize_sched();
+}
+
 static inline void synchronize_sched_expedited(void)
 {
        synchronize_sched();
 }
 
-static inline void kfree_call_rcu(struct rcu_head *head,
-                                 rcu_callback_t func)
+static inline void call_rcu_sched(struct rcu_head *head, rcu_callback_t func)
+{
+       call_rcu(head, func);
+}
+
+static inline void kfree_call_rcu(struct rcu_head *head, rcu_callback_t func)
 {
        call_rcu(head, func);
 }
 
-void rcu_sched_qs(void);
+void rcu_qs(void);
 
 static inline void rcu_softirq_qs(void)
 {
-       rcu_sched_qs();
+       rcu_qs();
 }
 
 #define rcu_note_context_switch(preempt) \
        do { \
-               rcu_sched_qs(); \
+               rcu_qs(); \
                rcu_tasks_qs(current); \
        } while (0)
 

diff --git a/include/linux/rcutree.h b/include/linux/rcutree.h
index 0c44720f0e844e8fe8e0712811fcfc29c0576708..6d30a0809300ad0505c1ba2cd057e6c64e926fb2 100644 (file)
--- a/include/linux/rcutree.h
+++ b/include/linux/rcutree.h
@@ -45,7 +45,6 @@ static inline void rcu_virt_note_context_switch(int cpu)
        rcu_note_context_switch(false);
 }
 
-void synchronize_rcu(void);
 static inline void synchronize_rcu_bh(void)
 {
        synchronize_rcu();

diff --git a/kernel/rcu/tiny.c b/kernel/rcu/tiny.c
index cadcf63c4889660d1e65fc6be8c6cc723c7680a1..30826fb6e438f50af2e652811d9db15a72458ecf 100644 (file)
--- a/kernel/rcu/tiny.c
+++ b/kernel/rcu/tiny.c
@@ -46,25 +46,25 @@ struct rcu_ctrlblk {
 };
 
 /* Definition for rcupdate control block. */
-static struct rcu_ctrlblk rcu_sched_ctrlblk = {
-       .donetail       = &rcu_sched_ctrlblk.rcucblist,
-       .curtail        = &rcu_sched_ctrlblk.rcucblist,
+static struct rcu_ctrlblk rcu_ctrlblk = {
+       .donetail       = &rcu_ctrlblk.rcucblist,
+       .curtail        = &rcu_ctrlblk.rcucblist,
 };
 
-void rcu_barrier_sched(void)
+void rcu_barrier(void)
 {
-       wait_rcu_gp(call_rcu_sched);
+       wait_rcu_gp(call_rcu);
 }
-EXPORT_SYMBOL(rcu_barrier_sched);
+EXPORT_SYMBOL(rcu_barrier);
 
 /* Record an rcu quiescent state.  */
-void rcu_sched_qs(void)
+void rcu_qs(void)
 {
        unsigned long flags;
 
        local_irq_save(flags);
-       if (rcu_sched_ctrlblk.donetail != rcu_sched_ctrlblk.curtail) {
-               rcu_sched_ctrlblk.donetail = rcu_sched_ctrlblk.curtail;
+       if (rcu_ctrlblk.donetail != rcu_ctrlblk.curtail) {
+               rcu_ctrlblk.donetail = rcu_ctrlblk.curtail;
                raise_softirq(RCU_SOFTIRQ);
        }
        local_irq_restore(flags);
@@ -79,7 +79,7 @@ void rcu_sched_qs(void)
 void rcu_check_callbacks(int user)
 {
        if (user)
-               rcu_sched_qs();
+               rcu_qs();
 }
 
 /* Invoke the RCU callbacks whose grace period has elapsed.  */
@@ -90,17 +90,17 @@ static __latent_entropy void rcu_process_callbacks(struct softirq_action *unused
 
        /* Move the ready-to-invoke callbacks to a local list. */
        local_irq_save(flags);
-       if (rcu_sched_ctrlblk.donetail == &rcu_sched_ctrlblk.rcucblist) {
+       if (rcu_ctrlblk.donetail == &rcu_ctrlblk.rcucblist) {
                /* No callbacks ready, so just leave. */
                local_irq_restore(flags);
                return;
        }
-       list = rcu_sched_ctrlblk.rcucblist;
-       rcu_sched_ctrlblk.rcucblist = *rcu_sched_ctrlblk.donetail;
-       *rcu_sched_ctrlblk.donetail = NULL;
-       if (rcu_sched_ctrlblk.curtail == rcu_sched_ctrlblk.donetail)
-               rcu_sched_ctrlblk.curtail = &rcu_sched_ctrlblk.rcucblist;
-       rcu_sched_ctrlblk.donetail = &rcu_sched_ctrlblk.rcucblist;
+       list = rcu_ctrlblk.rcucblist;
+       rcu_ctrlblk.rcucblist = *rcu_ctrlblk.donetail;
+       *rcu_ctrlblk.donetail = NULL;
+       if (rcu_ctrlblk.curtail == rcu_ctrlblk.donetail)
+               rcu_ctrlblk.curtail = &rcu_ctrlblk.rcucblist;
+       rcu_ctrlblk.donetail = &rcu_ctrlblk.rcucblist;
        local_irq_restore(flags);
 
        /* Invoke the callbacks on the local list. */
@@ -125,21 +125,21 @@ static __latent_entropy void rcu_process_callbacks(struct softirq_action *unused
  *
  * Cool, huh?  (Due to Josh Triplett.)
  */
-void synchronize_sched(void)
+void synchronize_rcu(void)
 {
        RCU_LOCKDEP_WARN(lock_is_held(&rcu_bh_lock_map) ||
                         lock_is_held(&rcu_lock_map) ||
                         lock_is_held(&rcu_sched_lock_map),
                         "Illegal synchronize_sched() in RCU read-side critical section");
 }
-EXPORT_SYMBOL_GPL(synchronize_sched);
+EXPORT_SYMBOL_GPL(synchronize_rcu);
 
 /*
  * Post an RCU callback to be invoked after the end of an RCU-sched grace
  * period.  But since we have but one CPU, that would be after any
  * quiescent state.
  */
-void call_rcu_sched(struct rcu_head *head, rcu_callback_t func)
+void call_rcu(struct rcu_head *head, rcu_callback_t func)
 {
        unsigned long flags;
 
@@ -148,16 +148,16 @@ void call_rcu_sched(struct rcu_head *head, rcu_callback_t func)
        head->next = NULL;
 
        local_irq_save(flags);
-       *rcu_sched_ctrlblk.curtail = head;
-       rcu_sched_ctrlblk.curtail = &head->next;
+       *rcu_ctrlblk.curtail = head;
+       rcu_ctrlblk.curtail = &head->next;
        local_irq_restore(flags);
 
        if (unlikely(is_idle_task(current))) {
-               /* force scheduling for rcu_sched_qs() */
+               /* force scheduling for rcu_qs() */
                resched_cpu(0);
        }
 }
-EXPORT_SYMBOL_GPL(call_rcu_sched);
+EXPORT_SYMBOL_GPL(call_rcu);
 
 void __init rcu_init(void)
 {