Line data    Source code

       1             : /* SPDX-License-Identifier: GPL-2.0+ */
       2             : /*
       3             :  * Read-Copy Update mechanism for mutual exclusion, the Bloatwatch edition.
       4             :  *
       5             :  * Copyright IBM Corporation, 2008
       6             :  *
       7             :  * Author: Paul E. McKenney <paulmck@linux.ibm.com>
       8             :  *
       9             :  * For detailed explanation of Read-Copy Update mechanism see -
      10             :  *              Documentation/RCU
      11             :  */
      12             : #ifndef __LINUX_TINY_H
      13             : #define __LINUX_TINY_H
      14             : 
      15             : #include <asm/param.h> /* for HZ */
      16             : 
      17             : unsigned long get_state_synchronize_rcu(void);
      18             : unsigned long start_poll_synchronize_rcu(void);
      19             : bool poll_state_synchronize_rcu(unsigned long oldstate);
      20             : 
      21             : static inline void cond_synchronize_rcu(unsigned long oldstate)
      22             : {
      23             :         might_sleep();
      24             : }
      25             : 
      26             : extern void rcu_barrier(void);
      27             : 
      28             : static inline void synchronize_rcu_expedited(void)
      29             : {
      30           0 :         synchronize_rcu();
      31             : }
      32             : 
      33             : /*
      34             :  * Add one more declaration of kvfree() here. It is
      35             :  * not so straight forward to just include <linux/mm.h>
      36             :  * where it is defined due to getting many compile
      37             :  * errors caused by that include.
      38             :  */
      39             : extern void kvfree(const void *addr);
      40             : 
      41           0 : static inline void kvfree_call_rcu(struct rcu_head *head, rcu_callback_t func)
      42             : {
      43           0 :         if (head) {
      44           0 :                 call_rcu(head, func);
      45           0 :                 return;
      46             :         }
      47             : 
      48             :         // kvfree_rcu(one_arg) call.
      49             :         might_sleep();
      50           0 :         synchronize_rcu();
      51           0 :         kvfree((void *) func);
      52             : }
      53             : 
      54             : void rcu_qs(void);
      55             : 
      56             : static inline void rcu_softirq_qs(void)
      57             : {
      58         185 :         rcu_qs();
      59             : }
      60             : 
      61             : #define rcu_note_context_switch(preempt) \
      62             :         do { \
      63             :                 rcu_qs(); \
      64             :                 rcu_tasks_qs(current, (preempt)); \
      65             :         } while (0)
      66             : 
      67             : static inline int rcu_needs_cpu(void)
      68             : {
      69             :         return 0;
      70             : }
      71             : 
      72             : /*
      73             :  * Take advantage of the fact that there is only one CPU, which
      74             :  * allows us to ignore virtualization-based context switches.
      75             :  */
      76             : static inline void rcu_virt_note_context_switch(int cpu) { }
      77             : static inline void rcu_cpu_stall_reset(void) { }
      78             : static inline int rcu_jiffies_till_stall_check(void) { return 21 * HZ; }
      79             : static inline void rcu_idle_enter(void) { }
      80             : static inline void rcu_idle_exit(void) { }
      81             : static inline void rcu_irq_enter(void) { }
      82             : static inline void rcu_irq_exit_irqson(void) { }
      83             : static inline void rcu_irq_enter_irqson(void) { }
      84             : static inline void rcu_irq_exit(void) { }
      85             : static inline void rcu_irq_exit_check_preempt(void) { }
      86             : #define rcu_is_idle_cpu(cpu) \
      87             :         (is_idle_task(current) && !in_nmi() && !in_hardirq() && !in_serving_softirq())
      88             : static inline void exit_rcu(void) { }
      89             : static inline bool rcu_preempt_need_deferred_qs(struct task_struct *t)
      90             : {
      91             :         return false;
      92             : }
      93             : static inline void rcu_preempt_deferred_qs(struct task_struct *t) { }
      94             : #ifdef CONFIG_SRCU
      95             : void rcu_scheduler_starting(void);
      96             : #else /* #ifndef CONFIG_SRCU */
      97             : static inline void rcu_scheduler_starting(void) { }
      98             : #endif /* #else #ifndef CONFIG_SRCU */
      99             : static inline void rcu_end_inkernel_boot(void) { }
     100             : static inline bool rcu_inkernel_boot_has_ended(void) { return true; }
     101             : static inline bool rcu_is_watching(void) { return true; }
     102             : static inline void rcu_momentary_dyntick_idle(void) { }
     103             : static inline void kfree_rcu_scheduler_running(void) { }
     104             : static inline bool rcu_gp_might_be_stalled(void) { return false; }
     105             : 
     106             : /* Avoid RCU read-side critical sections leaking across. */
     107         737 : static inline void rcu_all_qs(void) { barrier(); }
     108             : 
     109             : /* RCUtree hotplug events */
     110             : #define rcutree_prepare_cpu      NULL
     111             : #define rcutree_online_cpu       NULL
     112             : #define rcutree_offline_cpu      NULL
     113             : #define rcutree_dead_cpu         NULL
     114             : #define rcutree_dying_cpu        NULL
     115             : static inline void rcu_cpu_starting(unsigned int cpu) { }
     116             : 
     117             : #endif /* __LINUX_RCUTINY_H */