/*
   * Read-Copy Update mechanism for mutual exclusion
   *
   * 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, you can access it online at
   * http://www.gnu.org/licenses/gpl-2.0.html.

   *
   * Copyright IBM Corporation, 2008
   *
   * Authors: Dipankar Sarma <dipankar@in.ibm.com>
   *	    Manfred Spraul <manfred@colorfullife.com>
   *	    Paul E. McKenney <paulmck@linux.vnet.ibm.com> Hierarchical version
   *
   * Based on the original work by Paul McKenney <paulmck@us.ibm.com>
   * and inputs from Rusty Russell, Andrea Arcangeli and Andi Kleen.
   *
   * For detailed explanation of Read-Copy Update mechanism see -

   *	Documentation/RCU

   */
  #include <linux/types.h>
  #include <linux/kernel.h>
  #include <linux/init.h>
  #include <linux/spinlock.h>
  #include <linux/smp.h>

  #include <linux/rcupdate_wait.h>

  #include <linux/interrupt.h>
  #include <linux/sched.h>

  #include <linux/sched/debug.h>

  #include <linux/nmi.h>

  #include <linux/atomic.h>

  #include <linux/bitops.h>

  #include <linux/export.h>

  #include <linux/completion.h>
  #include <linux/moduleparam.h>
  #include <linux/percpu.h>
  #include <linux/notifier.h>
  #include <linux/cpu.h>
  #include <linux/mutex.h>
  #include <linux/time.h>

  #include <linux/kernel_stat.h>

  #include <linux/wait.h>
  #include <linux/kthread.h>

  #include <uapi/linux/sched/types.h>

  #include <linux/prefetch.h>

  #include <linux/delay.h>
  #include <linux/stop_machine.h>

  #include <linux/random.h>

  #include <linux/trace_events.h>

  #include <linux/suspend.h>

  #include <linux/ftrace.h>

  #include "tree.h"

  #include "rcu.h"

  #ifdef MODULE_PARAM_PREFIX
  #undef MODULE_PARAM_PREFIX
  #endif
  #define MODULE_PARAM_PREFIX "rcutree."

  /* Data structures. */

  /*
   * In order to export the rcu_state name to the tracing tools, it
   * needs to be added in the __tracepoint_string section.
   * This requires defining a separate variable tp_<sname>_varname
   * that points to the string being used, and this will allow
   * the tracing userspace tools to be able to decipher the string
   * address to the matching string.
   */

  #ifdef CONFIG_TRACING
  # define DEFINE_RCU_TPS(sname) \

  static char sname##_varname[] = #sname; \

  static const char *tp_##sname##_varname __used __tracepoint_string = sname##_varname;
  # define RCU_STATE_NAME(sname) sname##_varname
  #else
  # define DEFINE_RCU_TPS(sname)
  # define RCU_STATE_NAME(sname) __stringify(sname)
  #endif
  
  #define RCU_STATE_INITIALIZER(sname, sabbr, cr) \
  DEFINE_RCU_TPS(sname) \

  static DEFINE_PER_CPU_SHARED_ALIGNED(struct rcu_data, sname##_data); \

  struct rcu_state sname##_state = { \

  	.level = { &sname##_state.node[0] }, \

  	.rda = &sname##_data, \

  	.call = cr, \

  	.gp_state = RCU_GP_IDLE, \

  	.gpnum = 0UL - 300UL, \
  	.completed = 0UL - 300UL, \

  	.barrier_mutex = __MUTEX_INITIALIZER(sname##_state.barrier_mutex), \

  	.name = RCU_STATE_NAME(sname), \

  	.abbr = sabbr, \

  	.exp_mutex = __MUTEX_INITIALIZER(sname##_state.exp_mutex), \

  	.exp_wake_mutex = __MUTEX_INITIALIZER(sname##_state.exp_wake_mutex), \

  }

  RCU_STATE_INITIALIZER(rcu_sched, 's', call_rcu_sched);
  RCU_STATE_INITIALIZER(rcu_bh, 'b', call_rcu_bh);

  static struct rcu_state *const rcu_state_p;

  LIST_HEAD(rcu_struct_flavors);

  /* Dump rcu_node combining tree at boot to verify correct setup. */
  static bool dump_tree;
  module_param(dump_tree, bool, 0444);

  /* Control rcu_node-tree auto-balancing at boot time. */
  static bool rcu_fanout_exact;
  module_param(rcu_fanout_exact, bool, 0444);

  /* Increase (but not decrease) the RCU_FANOUT_LEAF at boot time. */
  static int rcu_fanout_leaf = RCU_FANOUT_LEAF;

  module_param(rcu_fanout_leaf, int, 0444);

  int rcu_num_lvls __read_mostly = RCU_NUM_LVLS;

  /* Number of rcu_nodes at specified level. */

  int num_rcu_lvl[] = NUM_RCU_LVL_INIT;

  int rcu_num_nodes __read_mostly = NUM_RCU_NODES; /* Total # rcu_nodes in use. */

  /* panic() on RCU Stall sysctl. */
  int sysctl_panic_on_rcu_stall __read_mostly;

  /*

   * The rcu_scheduler_active variable is initialized to the value
   * RCU_SCHEDULER_INACTIVE and transitions RCU_SCHEDULER_INIT just before the
   * first task is spawned.  So when this variable is RCU_SCHEDULER_INACTIVE,
   * RCU can assume that there is but one task, allowing RCU to (for example)

   * optimize synchronize_rcu() to a simple barrier().  When this variable

   * is RCU_SCHEDULER_INIT, RCU must actually do all the hard work required
   * to detect real grace periods.  This variable is also used to suppress
   * boot-time false positives from lockdep-RCU error checking.  Finally, it
   * transitions from RCU_SCHEDULER_INIT to RCU_SCHEDULER_RUNNING after RCU
   * is fully initialized, including all of its kthreads having been spawned.

   */

  int rcu_scheduler_active __read_mostly;
  EXPORT_SYMBOL_GPL(rcu_scheduler_active);

  /*
   * The rcu_scheduler_fully_active variable transitions from zero to one
   * during the early_initcall() processing, which is after the scheduler
   * is capable of creating new tasks.  So RCU processing (for example,
   * creating tasks for RCU priority boosting) must be delayed until after
   * rcu_scheduler_fully_active transitions from zero to one.  We also
   * currently delay invocation of any RCU callbacks until after this point.
   *
   * It might later prove better for people registering RCU callbacks during
   * early boot to take responsibility for these callbacks, but one step at
   * a time.
   */
  static int rcu_scheduler_fully_active __read_mostly;

  static void rcu_init_new_rnp(struct rcu_node *rnp_leaf);
  static void rcu_cleanup_dead_rnp(struct rcu_node *rnp_leaf);

  static void rcu_boost_kthread_setaffinity(struct rcu_node *rnp, int outgoingcpu);

  static void invoke_rcu_core(void);
  static void invoke_rcu_callbacks(struct rcu_state *rsp, struct rcu_data *rdp);

  static void rcu_report_exp_rdp(struct rcu_state *rsp,
  			       struct rcu_data *rdp, bool wake);

  static void sync_sched_exp_online_cleanup(int cpu);

  /* rcuc/rcub kthread realtime priority */

  static int kthread_prio = IS_ENABLED(CONFIG_RCU_BOOST) ? 1 : 0;

  module_param(kthread_prio, int, 0644);

  /* Delay in jiffies for grace-period initialization delays, debug only. */

  static int gp_preinit_delay;
  module_param(gp_preinit_delay, int, 0444);
  static int gp_init_delay;
  module_param(gp_init_delay, int, 0444);
  static int gp_cleanup_delay;
  module_param(gp_cleanup_delay, int, 0444);

  /*
   * Number of grace periods between delays, normalized by the duration of

   * the delay.  The longer the delay, the more the grace periods between

   * each delay.  The reason for this normalization is that it means that,
   * for non-zero delays, the overall slowdown of grace periods is constant
   * regardless of the duration of the delay.  This arrangement balances
   * the need for long delays to increase some race probabilities with the
   * need for fast grace periods to increase other race probabilities.
   */
  #define PER_RCU_NODE_PERIOD 3	/* Number of grace periods between delays. */

  /*

   * Track the rcutorture test sequence number and the update version
   * number within a given test.  The rcutorture_testseq is incremented
   * on every rcutorture module load and unload, so has an odd value
   * when a test is running.  The rcutorture_vernum is set to zero
   * when rcutorture starts and is incremented on each rcutorture update.
   * These variables enable correlating rcutorture output with the
   * RCU tracing information.
   */
  unsigned long rcutorture_testseq;
  unsigned long rcutorture_vernum;
  
  /*

   * Compute the mask of online CPUs for the specified rcu_node structure.
   * This will not be stable unless the rcu_node structure's ->lock is
   * held, but the bit corresponding to the current CPU will be stable
   * in most contexts.
   */
  unsigned long rcu_rnp_online_cpus(struct rcu_node *rnp)
  {

  	return READ_ONCE(rnp->qsmaskinitnext);

  }
  
  /*

   * Return true if an RCU grace period is in progress.  The READ_ONCE()s

   * permit this function to be invoked without holding the root rcu_node
   * structure's ->lock, but of course results can be subject to change.
   */
  static int rcu_gp_in_progress(struct rcu_state *rsp)
  {

  	return READ_ONCE(rsp->completed) != READ_ONCE(rsp->gpnum);

  }
  
  /*

   * Note a quiescent state.  Because we do not need to know

   * how many quiescent states passed, just if there was at least

   * one since the start of the grace period, this just sets a flag.

   * The caller must have disabled preemption.

   */

  void rcu_sched_qs(void)

  {

  	RCU_LOCKDEP_WARN(preemptible(), "rcu_sched_qs() invoked with preemption enabled!!!");

  	if (!__this_cpu_read(rcu_sched_data.cpu_no_qs.s))
  		return;
  	trace_rcu_grace_period(TPS("rcu_sched"),
  			       __this_cpu_read(rcu_sched_data.gpnum),
  			       TPS("cpuqs"));
  	__this_cpu_write(rcu_sched_data.cpu_no_qs.b.norm, false);
  	if (!__this_cpu_read(rcu_sched_data.cpu_no_qs.b.exp))
  		return;

  	__this_cpu_write(rcu_sched_data.cpu_no_qs.b.exp, false);
  	rcu_report_exp_rdp(&rcu_sched_state,
  			   this_cpu_ptr(&rcu_sched_data), true);

  }

  void rcu_bh_qs(void)

  {

  	RCU_LOCKDEP_WARN(preemptible(), "rcu_bh_qs() invoked with preemption enabled!!!");

  	if (__this_cpu_read(rcu_bh_data.cpu_no_qs.s)) {

  		trace_rcu_grace_period(TPS("rcu_bh"),
  				       __this_cpu_read(rcu_bh_data.gpnum),
  				       TPS("cpuqs"));

  		__this_cpu_write(rcu_bh_data.cpu_no_qs.b.norm, false);

  	}

  }

  /*
   * Steal a bit from the bottom of ->dynticks for idle entry/exit
   * control.  Initially this is for TLB flushing.
   */
  #define RCU_DYNTICK_CTRL_MASK 0x1
  #define RCU_DYNTICK_CTRL_CTR  (RCU_DYNTICK_CTRL_MASK + 1)
  #ifndef rcu_eqs_special_exit
  #define rcu_eqs_special_exit() do { } while (0)
  #endif

  
  static DEFINE_PER_CPU(struct rcu_dynticks, rcu_dynticks) = {
  	.dynticks_nesting = DYNTICK_TASK_EXIT_IDLE,

  	.dynticks = ATOMIC_INIT(RCU_DYNTICK_CTRL_CTR),

  };

  /*

   * There's a few places, currently just in the tracing infrastructure,
   * that uses rcu_irq_enter() to make sure RCU is watching. But there's
   * a small location where that will not even work. In those cases
   * rcu_irq_enter_disabled() needs to be checked to make sure rcu_irq_enter()
   * can be called.
   */
  static DEFINE_PER_CPU(bool, disable_rcu_irq_enter);
  
  bool rcu_irq_enter_disabled(void)
  {
  	return this_cpu_read(disable_rcu_irq_enter);
  }
  
  /*

   * Record entry into an extended quiescent state.  This is only to be
   * called when not already in an extended quiescent state.
   */
  static void rcu_dynticks_eqs_enter(void)
  {
  	struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);

  	int seq;

  
  	/*

  	 * CPUs seeing atomic_add_return() must see prior RCU read-side

  	 * critical sections, and we also must force ordering with the
  	 * next idle sojourn.
  	 */

  	seq = atomic_add_return(RCU_DYNTICK_CTRL_CTR, &rdtp->dynticks);
  	/* Better be in an extended quiescent state! */
  	WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) &&
  		     (seq & RCU_DYNTICK_CTRL_CTR));
  	/* Better not have special action (TLB flush) pending! */
  	WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) &&
  		     (seq & RCU_DYNTICK_CTRL_MASK));

  }
  
  /*
   * Record exit from an extended quiescent state.  This is only to be
   * called from an extended quiescent state.
   */
  static void rcu_dynticks_eqs_exit(void)
  {
  	struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);

  	int seq;

  
  	/*

  	 * CPUs seeing atomic_add_return() must see prior idle sojourns,

  	 * and we also must force ordering with the next RCU read-side
  	 * critical section.
  	 */

  	seq = atomic_add_return(RCU_DYNTICK_CTRL_CTR, &rdtp->dynticks);
  	WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) &&
  		     !(seq & RCU_DYNTICK_CTRL_CTR));
  	if (seq & RCU_DYNTICK_CTRL_MASK) {
  		atomic_andnot(RCU_DYNTICK_CTRL_MASK, &rdtp->dynticks);
  		smp_mb__after_atomic(); /* _exit after clearing mask. */
  		/* Prefer duplicate flushes to losing a flush. */
  		rcu_eqs_special_exit();
  	}

  }
  
  /*
   * Reset the current CPU's ->dynticks counter to indicate that the
   * newly onlined CPU is no longer in an extended quiescent state.
   * This will either leave the counter unchanged, or increment it
   * to the next non-quiescent value.
   *
   * The non-atomic test/increment sequence works because the upper bits
   * of the ->dynticks counter are manipulated only by the corresponding CPU,
   * or when the corresponding CPU is offline.
   */
  static void rcu_dynticks_eqs_online(void)
  {
  	struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);

  	if (atomic_read(&rdtp->dynticks) & RCU_DYNTICK_CTRL_CTR)

  		return;

  	atomic_add(RCU_DYNTICK_CTRL_CTR, &rdtp->dynticks);

  }
  
  /*

   * Is the current CPU in an extended quiescent state?
   *
   * No ordering, as we are sampling CPU-local information.
   */
  bool rcu_dynticks_curr_cpu_in_eqs(void)
  {
  	struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);

  	return !(atomic_read(&rdtp->dynticks) & RCU_DYNTICK_CTRL_CTR);

  }
  
  /*

   * Snapshot the ->dynticks counter with full ordering so as to allow
   * stable comparison of this counter with past and future snapshots.
   */

  int rcu_dynticks_snap(struct rcu_dynticks *rdtp)

  {
  	int snap = atomic_add_return(0, &rdtp->dynticks);

  	return snap & ~RCU_DYNTICK_CTRL_MASK;

  }
  
  /*

   * Return true if the snapshot returned from rcu_dynticks_snap()
   * indicates that RCU is in an extended quiescent state.
   */
  static bool rcu_dynticks_in_eqs(int snap)
  {

  	return !(snap & RCU_DYNTICK_CTRL_CTR);

  }
  
  /*
   * Return true if the CPU corresponding to the specified rcu_dynticks
   * structure has spent some time in an extended quiescent state since
   * rcu_dynticks_snap() returned the specified snapshot.
   */
  static bool rcu_dynticks_in_eqs_since(struct rcu_dynticks *rdtp, int snap)
  {
  	return snap != rcu_dynticks_snap(rdtp);
  }
  
  /*

   * Do a double-increment of the ->dynticks counter to emulate a
   * momentary idle-CPU quiescent state.
   */
  static void rcu_dynticks_momentary_idle(void)
  {
  	struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);

  	int special = atomic_add_return(2 * RCU_DYNTICK_CTRL_CTR,
  					&rdtp->dynticks);

  
  	/* It is illegal to call this from idle state. */

  	WARN_ON_ONCE(!(special & RCU_DYNTICK_CTRL_CTR));

  }

  /*
   * Set the special (bottom) bit of the specified CPU so that it
   * will take special action (such as flushing its TLB) on the
   * next exit from an extended quiescent state.  Returns true if
   * the bit was successfully set, or false if the CPU was not in
   * an extended quiescent state.
   */
  bool rcu_eqs_special_set(int cpu)
  {
  	int old;
  	int new;
  	struct rcu_dynticks *rdtp = &per_cpu(rcu_dynticks, cpu);
  
  	do {
  		old = atomic_read(&rdtp->dynticks);
  		if (old & RCU_DYNTICK_CTRL_CTR)
  			return false;
  		new = old | RCU_DYNTICK_CTRL_MASK;
  	} while (atomic_cmpxchg(&rdtp->dynticks, old, new) != old);
  	return true;

  }

  /*
   * Let the RCU core know that this CPU has gone through the scheduler,
   * which is a quiescent state.  This is called when the need for a
   * quiescent state is urgent, so we burn an atomic operation and full
   * memory barriers to let the RCU core know about it, regardless of what
   * this CPU might (or might not) do in the near future.
   *

   * We inform the RCU core by emulating a zero-duration dyntick-idle period.

   *
   * The caller must have disabled interrupts.

   */
  static void rcu_momentary_dyntick_idle(void)
  {

  	raw_cpu_write(rcu_dynticks.rcu_need_heavy_qs, false);
  	rcu_dynticks_momentary_idle();

  }

  /*
   * Note a context switch.  This is a quiescent state for RCU-sched,
   * and requires special handling for preemptible RCU.

   * The caller must have disabled interrupts.

   */

  void rcu_note_context_switch(bool preempt)

  {

  	barrier(); /* Avoid RCU read-side critical sections leaking down. */

  	trace_rcu_utilization(TPS("Start context switch"));

  	rcu_sched_qs();

  	rcu_preempt_note_context_switch(preempt);

  	/* Load rcu_urgent_qs before other flags. */
  	if (!smp_load_acquire(this_cpu_ptr(&rcu_dynticks.rcu_urgent_qs)))
  		goto out;
  	this_cpu_write(rcu_dynticks.rcu_urgent_qs, false);

  	if (unlikely(raw_cpu_read(rcu_dynticks.rcu_need_heavy_qs)))

  		rcu_momentary_dyntick_idle();

  	this_cpu_inc(rcu_dynticks.rcu_qs_ctr);

  	if (!preempt)
  		rcu_note_voluntary_context_switch_lite(current);

  out:

  	trace_rcu_utilization(TPS("End context switch"));

  	barrier(); /* Avoid RCU read-side critical sections leaking up. */

  }

  EXPORT_SYMBOL_GPL(rcu_note_context_switch);

  /*

   * Register a quiescent state for all RCU flavors.  If there is an

   * emergency, invoke rcu_momentary_dyntick_idle() to do a heavy-weight
   * dyntick-idle quiescent state visible to other CPUs (but only for those

   * RCU flavors in desperate need of a quiescent state, which will normally

   * be none of them).  Either way, do a lightweight quiescent state for
   * all RCU flavors.

   *
   * The barrier() calls are redundant in the common case when this is
   * called externally, but just in case this is called from within this
   * file.
   *

   */
  void rcu_all_qs(void)
  {

  	unsigned long flags;

  	if (!raw_cpu_read(rcu_dynticks.rcu_urgent_qs))
  		return;
  	preempt_disable();
  	/* Load rcu_urgent_qs before other flags. */
  	if (!smp_load_acquire(this_cpu_ptr(&rcu_dynticks.rcu_urgent_qs))) {
  		preempt_enable();
  		return;
  	}
  	this_cpu_write(rcu_dynticks.rcu_urgent_qs, false);

  	barrier(); /* Avoid RCU read-side critical sections leaking down. */

  	if (unlikely(raw_cpu_read(rcu_dynticks.rcu_need_heavy_qs))) {

  		local_irq_save(flags);

  		rcu_momentary_dyntick_idle();

  		local_irq_restore(flags);
  	}

  	if (unlikely(raw_cpu_read(rcu_sched_data.cpu_no_qs.b.exp)))

  		rcu_sched_qs();

  	this_cpu_inc(rcu_dynticks.rcu_qs_ctr);

  	barrier(); /* Avoid RCU read-side critical sections leaking up. */

  	preempt_enable();

  }
  EXPORT_SYMBOL_GPL(rcu_all_qs);

  #define DEFAULT_RCU_BLIMIT 10     /* Maximum callbacks per rcu_do_batch. */
  static long blimit = DEFAULT_RCU_BLIMIT;
  #define DEFAULT_RCU_QHIMARK 10000 /* If this many pending, ignore blimit. */
  static long qhimark = DEFAULT_RCU_QHIMARK;
  #define DEFAULT_RCU_QLOMARK 100   /* Once only this many pending, use blimit. */
  static long qlowmark = DEFAULT_RCU_QLOMARK;

  module_param(blimit, long, 0444);
  module_param(qhimark, long, 0444);
  module_param(qlowmark, long, 0444);

  static ulong jiffies_till_first_fqs = ULONG_MAX;
  static ulong jiffies_till_next_fqs = ULONG_MAX;

  static bool rcu_kick_kthreads;

  
  module_param(jiffies_till_first_fqs, ulong, 0644);
  module_param(jiffies_till_next_fqs, ulong, 0644);

  module_param(rcu_kick_kthreads, bool, 0644);

  /*
   * How long the grace period must be before we start recruiting
   * quiescent-state help from rcu_note_context_switch().
   */
  static ulong jiffies_till_sched_qs = HZ / 20;
  module_param(jiffies_till_sched_qs, ulong, 0644);

  static bool rcu_start_gp_advanced(struct rcu_state *rsp, struct rcu_node *rnp,

  				  struct rcu_data *rdp);

  static void force_qs_rnp(struct rcu_state *rsp, int (*f)(struct rcu_data *rsp));

  static void force_quiescent_state(struct rcu_state *rsp);

  static int rcu_pending(void);

  
  /*

   * Return the number of RCU batches started thus far for debug & stats.

   */

  unsigned long rcu_batches_started(void)
  {
  	return rcu_state_p->gpnum;
  }
  EXPORT_SYMBOL_GPL(rcu_batches_started);
  
  /*
   * Return the number of RCU-sched batches started thus far for debug & stats.

   */

  unsigned long rcu_batches_started_sched(void)
  {
  	return rcu_sched_state.gpnum;
  }
  EXPORT_SYMBOL_GPL(rcu_batches_started_sched);
  
  /*
   * Return the number of RCU BH batches started thus far for debug & stats.
   */
  unsigned long rcu_batches_started_bh(void)
  {
  	return rcu_bh_state.gpnum;
  }
  EXPORT_SYMBOL_GPL(rcu_batches_started_bh);
  
  /*
   * Return the number of RCU batches completed thus far for debug & stats.
   */
  unsigned long rcu_batches_completed(void)
  {
  	return rcu_state_p->completed;
  }
  EXPORT_SYMBOL_GPL(rcu_batches_completed);
  
  /*
   * Return the number of RCU-sched batches completed thus far for debug & stats.

   */

  unsigned long rcu_batches_completed_sched(void)

  {

  	return rcu_sched_state.completed;

  }

  EXPORT_SYMBOL_GPL(rcu_batches_completed_sched);

  
  /*

   * Return the number of RCU BH batches completed thus far for debug & stats.

   */

  unsigned long rcu_batches_completed_bh(void)

  {
  	return rcu_bh_state.completed;
  }
  EXPORT_SYMBOL_GPL(rcu_batches_completed_bh);
  
  /*

   * Return the number of RCU expedited batches completed thus far for
   * debug & stats.  Odd numbers mean that a batch is in progress, even
   * numbers mean idle.  The value returned will thus be roughly double
   * the cumulative batches since boot.
   */
  unsigned long rcu_exp_batches_completed(void)
  {
  	return rcu_state_p->expedited_sequence;
  }
  EXPORT_SYMBOL_GPL(rcu_exp_batches_completed);
  
  /*
   * Return the number of RCU-sched expedited batches completed thus far
   * for debug & stats.  Similar to rcu_exp_batches_completed().
   */
  unsigned long rcu_exp_batches_completed_sched(void)
  {
  	return rcu_sched_state.expedited_sequence;
  }
  EXPORT_SYMBOL_GPL(rcu_exp_batches_completed_sched);
  
  /*

   * Force a quiescent state.
   */
  void rcu_force_quiescent_state(void)
  {

  	force_quiescent_state(rcu_state_p);

  }
  EXPORT_SYMBOL_GPL(rcu_force_quiescent_state);
  
  /*

   * Force a quiescent state for RCU BH.
   */
  void rcu_bh_force_quiescent_state(void)
  {

  	force_quiescent_state(&rcu_bh_state);

  }
  EXPORT_SYMBOL_GPL(rcu_bh_force_quiescent_state);
  
  /*

   * Force a quiescent state for RCU-sched.
   */
  void rcu_sched_force_quiescent_state(void)
  {
  	force_quiescent_state(&rcu_sched_state);
  }
  EXPORT_SYMBOL_GPL(rcu_sched_force_quiescent_state);
  
  /*

   * Show the state of the grace-period kthreads.
   */
  void show_rcu_gp_kthreads(void)
  {
  	struct rcu_state *rsp;
  
  	for_each_rcu_flavor(rsp) {
  		pr_info("%s: wait state: %d ->state: %#lx
  ",
  			rsp->name, rsp->gp_state, rsp->gp_kthread->state);
  		/* sched_show_task(rsp->gp_kthread); */
  	}
  }
  EXPORT_SYMBOL_GPL(show_rcu_gp_kthreads);
  
  /*

   * Record the number of times rcutorture tests have been initiated and
   * terminated.  This information allows the debugfs tracing stats to be
   * correlated to the rcutorture messages, even when the rcutorture module
   * is being repeatedly loaded and unloaded.  In other words, we cannot
   * store this state in rcutorture itself.
   */
  void rcutorture_record_test_transition(void)
  {
  	rcutorture_testseq++;
  	rcutorture_vernum = 0;
  }
  EXPORT_SYMBOL_GPL(rcutorture_record_test_transition);
  
  /*

   * Send along grace-period-related data for rcutorture diagnostics.
   */
  void rcutorture_get_gp_data(enum rcutorture_type test_type, int *flags,
  			    unsigned long *gpnum, unsigned long *completed)
  {
  	struct rcu_state *rsp = NULL;
  
  	switch (test_type) {
  	case RCU_FLAVOR:

  		rsp = rcu_state_p;

  		break;
  	case RCU_BH_FLAVOR:
  		rsp = &rcu_bh_state;
  		break;
  	case RCU_SCHED_FLAVOR:
  		rsp = &rcu_sched_state;
  		break;
  	default:
  		break;
  	}

  	if (rsp == NULL)

  		return;

  	*flags = READ_ONCE(rsp->gp_flags);
  	*gpnum = READ_ONCE(rsp->gpnum);
  	*completed = READ_ONCE(rsp->completed);

  }
  EXPORT_SYMBOL_GPL(rcutorture_get_gp_data);
  
  /*

   * Record the number of writer passes through the current rcutorture test.
   * This is also used to correlate debugfs tracing stats with the rcutorture
   * messages.
   */
  void rcutorture_record_progress(unsigned long vernum)
  {
  	rcutorture_vernum++;
  }
  EXPORT_SYMBOL_GPL(rcutorture_record_progress);
  
  /*

   * Return the root node of the specified rcu_state structure.
   */
  static struct rcu_node *rcu_get_root(struct rcu_state *rsp)
  {
  	return &rsp->node[0];
  }
  
  /*
   * Is there any need for future grace periods?
   * Interrupts must be disabled.  If the caller does not hold the root
   * rnp_node structure's ->lock, the results are advisory only.
   */
  static int rcu_future_needs_gp(struct rcu_state *rsp)
  {
  	struct rcu_node *rnp = rcu_get_root(rsp);

  	int idx = (READ_ONCE(rnp->completed) + 1) & 0x1;

  	int *fp = &rnp->need_future_gp[idx];

  	RCU_LOCKDEP_WARN(!irqs_disabled(), "rcu_future_needs_gp() invoked with irqs enabled!!!");

  	return READ_ONCE(*fp);

  }
  
  /*

   * Does the current CPU require a not-yet-started grace period?
   * The caller must have disabled interrupts to prevent races with
   * normal callback registry.

   */

  static bool

  cpu_needs_another_gp(struct rcu_state *rsp, struct rcu_data *rdp)
  {

  	RCU_LOCKDEP_WARN(!irqs_disabled(), "cpu_needs_another_gp() invoked with irqs enabled!!!");

  	if (rcu_gp_in_progress(rsp))

  		return false;  /* No, a grace period is already in progress. */

  	if (rcu_future_needs_gp(rsp))

  		return true;  /* Yes, a no-CBs CPU needs one. */

  	if (!rcu_segcblist_is_enabled(&rdp->cblist))

  		return false;  /* No, this is a no-CBs (or offline) CPU. */

  	if (!rcu_segcblist_restempty(&rdp->cblist, RCU_NEXT_READY_TAIL))

  		return true;  /* Yes, CPU has newly registered callbacks. */

  	if (rcu_segcblist_future_gp_needed(&rdp->cblist,
  					   READ_ONCE(rsp->completed)))
  		return true;  /* Yes, CBs for future grace period. */

  	return false; /* No grace period needed. */

  }
  
  /*

   * rcu_eqs_enter_common - current CPU is entering an extended quiescent state

   *

   * Enter idle, doing appropriate accounting.  The caller must have
   * disabled interrupts.

   */

  static void rcu_eqs_enter_common(bool user)

  {

  	struct rcu_state *rsp;
  	struct rcu_data *rdp;

  	struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);

  	RCU_LOCKDEP_WARN(!irqs_disabled(), "rcu_eqs_enter_common() invoked with irqs enabled!!!");

  	trace_rcu_dyntick(TPS("Start"), rdtp->dynticks_nesting, 0);

  	if (IS_ENABLED(CONFIG_RCU_EQS_DEBUG) &&
  	    !user && !is_idle_task(current)) {

  		struct task_struct *idle __maybe_unused =
  			idle_task(smp_processor_id());

  		trace_rcu_dyntick(TPS("Error on entry: not idle task"), rdtp->dynticks_nesting, 0);

  		rcu_ftrace_dump(DUMP_ORIG);

  		WARN_ONCE(1, "Current pid: %d comm: %s / Idle pid: %d comm: %s",
  			  current->pid, current->comm,
  			  idle->pid, idle->comm); /* must be idle task! */

  	}

  	for_each_rcu_flavor(rsp) {
  		rdp = this_cpu_ptr(rsp->rda);
  		do_nocb_deferred_wakeup(rdp);
  	}

  	rcu_prepare_for_idle();

  	__this_cpu_inc(disable_rcu_irq_enter);

  	rdtp->dynticks_nesting = 0; /* Breaks tracing momentarily. */
  	rcu_dynticks_eqs_enter(); /* After this, tracing works again. */

  	__this_cpu_dec(disable_rcu_irq_enter);

  	rcu_dynticks_task_enter();

  
  	/*

  	 * It is illegal to enter an extended quiescent state while

  	 * in an RCU read-side critical section.
  	 */

  	RCU_LOCKDEP_WARN(lock_is_held(&rcu_lock_map),
  			 "Illegal idle entry in RCU read-side critical section.");
  	RCU_LOCKDEP_WARN(lock_is_held(&rcu_bh_lock_map),
  			 "Illegal idle entry in RCU-bh read-side critical section.");
  	RCU_LOCKDEP_WARN(lock_is_held(&rcu_sched_lock_map),
  			 "Illegal idle entry in RCU-sched read-side critical section.");

  }

  /*
   * Enter an RCU extended quiescent state, which can be either the
   * idle loop or adaptive-tickless usermode execution.

   */

  static void rcu_eqs_enter(bool user)

  {

  	struct rcu_dynticks *rdtp;

  	rdtp = this_cpu_ptr(&rcu_dynticks);

  	WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) &&

  		     (rdtp->dynticks_nesting & DYNTICK_TASK_NEST_MASK) == 0);
  	if ((rdtp->dynticks_nesting & DYNTICK_TASK_NEST_MASK) == DYNTICK_TASK_NEST_VALUE)
  		rcu_eqs_enter_common(user);
  	else

  		rdtp->dynticks_nesting -= DYNTICK_TASK_NEST_VALUE;

  }

  
  /**
   * rcu_idle_enter - inform RCU that current CPU is entering idle
   *
   * Enter idle mode, in other words, -leave- the mode in which RCU
   * read-side critical sections can occur.  (Though RCU read-side
   * critical sections can occur in irq handlers in idle, a possibility
   * handled by irq_enter() and irq_exit().)
   *
   * We crowbar the ->dynticks_nesting field to zero to allow for
   * the possibility of usermode upcalls having messed up our count
   * of interrupt nesting level during the prior busy period.
   */
  void rcu_idle_enter(void)
  {

  	RCU_LOCKDEP_WARN(!irqs_disabled(), "rcu_idle_enter() invoked with irqs enabled!!!");

  	rcu_eqs_enter(false);

  }

  #ifdef CONFIG_NO_HZ_FULL

  /**

   * rcu_user_enter - inform RCU that we are resuming userspace.
   *
   * Enter RCU idle mode right before resuming userspace.  No use of RCU
   * is permitted between this call and rcu_user_exit(). This way the
   * CPU doesn't need to maintain the tick for RCU maintenance purposes
   * when the CPU runs in userspace.
   */
  void rcu_user_enter(void)
  {

  	RCU_LOCKDEP_WARN(!irqs_disabled(), "rcu_user_enter() invoked with irqs enabled!!!");
  	rcu_eqs_enter(true);

  }

  #endif /* CONFIG_NO_HZ_FULL */

  
  /**

   * rcu_irq_exit - inform RCU that current CPU is exiting irq towards idle
   *
   * Exit from an interrupt handler, which might possibly result in entering
   * idle mode, in other words, leaving the mode in which read-side critical

   * sections can occur.  The caller must have disabled interrupts.

   *

   * This code assumes that the idle loop never does anything that might
   * result in unbalanced calls to irq_enter() and irq_exit().  If your
   * architecture violates this assumption, RCU will give you what you
   * deserve, good and hard.  But very infrequently and irreproducibly.
   *
   * Use things like work queues to work around this limitation.
   *
   * You have been warned.

   */

  void rcu_irq_exit(void)

  {

  	struct rcu_dynticks *rdtp;

  	RCU_LOCKDEP_WARN(!irqs_disabled(), "rcu_irq_exit() invoked with irqs enabled!!!");

  	rdtp = this_cpu_ptr(&rcu_dynticks);

  
  	/* Page faults can happen in NMI handlers, so check... */

  	if (rdtp->dynticks_nmi_nesting)

  		return;

  	WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) &&

  		     rdtp->dynticks_nesting < 1);
  	if (rdtp->dynticks_nesting <= 1) {
  		rcu_eqs_enter_common(true);
  	} else {
  		trace_rcu_dyntick(TPS("--="), rdtp->dynticks_nesting, rdtp->dynticks_nesting - 1);
  		rdtp->dynticks_nesting--;
  	}

  }
  
  /*
   * Wrapper for rcu_irq_exit() where interrupts are enabled.
   */
  void rcu_irq_exit_irqson(void)
  {
  	unsigned long flags;
  
  	local_irq_save(flags);
  	rcu_irq_exit();

  	local_irq_restore(flags);
  }
  
  /*

   * rcu_eqs_exit_common - current CPU moving away from extended quiescent state

   *
   * If the new value of the ->dynticks_nesting counter was previously zero,
   * we really have exited idle, and must do the appropriate accounting.
   * The caller must have disabled interrupts.
   */

  static void rcu_eqs_exit_common(long long oldval, int user)

  {

  	RCU_TRACE(struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);)

  	rcu_dynticks_task_exit();

  	rcu_dynticks_eqs_exit();

  	rcu_cleanup_after_idle();

  	trace_rcu_dyntick(TPS("End"), oldval, rdtp->dynticks_nesting);

  	if (IS_ENABLED(CONFIG_RCU_EQS_DEBUG) &&
  	    !user && !is_idle_task(current)) {

  		struct task_struct *idle __maybe_unused =
  			idle_task(smp_processor_id());

  		trace_rcu_dyntick(TPS("Error on exit: not idle task"),

  				  oldval, rdtp->dynticks_nesting);

  		rcu_ftrace_dump(DUMP_ORIG);

  		WARN_ONCE(1, "Current pid: %d comm: %s / Idle pid: %d comm: %s",
  			  current->pid, current->comm,
  			  idle->pid, idle->comm); /* must be idle task! */

  	}
  }

  /*
   * Exit an RCU extended quiescent state, which can be either the
   * idle loop or adaptive-tickless usermode execution.

   */

  static void rcu_eqs_exit(bool user)

  {

  	struct rcu_dynticks *rdtp;
  	long long oldval;

  	RCU_LOCKDEP_WARN(!irqs_disabled(), "rcu_eqs_exit() invoked with irqs enabled!!!");

  	rdtp = this_cpu_ptr(&rcu_dynticks);

  	oldval = rdtp->dynticks_nesting;

  	WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) && oldval < 0);

  	if (oldval & DYNTICK_TASK_NEST_MASK) {

  		rdtp->dynticks_nesting += DYNTICK_TASK_NEST_VALUE;

  	} else {

  		__this_cpu_inc(disable_rcu_irq_enter);

  		rdtp->dynticks_nesting = DYNTICK_TASK_EXIT_IDLE;

  		rcu_eqs_exit_common(oldval, user);

  		__this_cpu_dec(disable_rcu_irq_enter);

  	}

  }

  
  /**
   * rcu_idle_exit - inform RCU that current CPU is leaving idle
   *
   * Exit idle mode, in other words, -enter- the mode in which RCU
   * read-side critical sections can occur.
   *
   * We crowbar the ->dynticks_nesting field to DYNTICK_TASK_NEST to
   * allow for the possibility of usermode upcalls messing up our count
   * of interrupt nesting level during the busy period that is just
   * now starting.
   */
  void rcu_idle_exit(void)
  {

  	unsigned long flags;
  
  	local_irq_save(flags);

  	rcu_eqs_exit(false);

  	local_irq_restore(flags);

  }

  #ifdef CONFIG_NO_HZ_FULL

  /**

   * rcu_user_exit - inform RCU that we are exiting userspace.
   *
   * Exit RCU idle mode while entering the kernel because it can
   * run a RCU read side critical section anytime.
   */
  void rcu_user_exit(void)
  {

  	rcu_eqs_exit(1);

  }

  #endif /* CONFIG_NO_HZ_FULL */

  
  /**

   * rcu_irq_enter - inform RCU that current CPU is entering irq away from idle
   *
   * Enter an interrupt handler, which might possibly result in exiting
   * idle mode, in other words, entering the mode in which read-side critical

   * sections can occur.  The caller must have disabled interrupts.

   *
   * Note that the Linux kernel is fully capable of entering an interrupt
   * handler that it never exits, for example when doing upcalls to
   * user mode!  This code assumes that the idle loop never does upcalls to
   * user mode.  If your architecture does do upcalls from the idle loop (or
   * does anything else that results in unbalanced calls to the irq_enter()
   * and irq_exit() functions), RCU will give you what you deserve, good
   * and hard.  But very infrequently and irreproducibly.
   *
   * Use things like work queues to work around this limitation.
   *
   * You have been warned.
   */
  void rcu_irq_enter(void)
  {

  	struct rcu_dynticks *rdtp;
  	long long oldval;

  	RCU_LOCKDEP_WARN(!irqs_disabled(), "rcu_irq_enter() invoked with irqs enabled!!!");

  	rdtp = this_cpu_ptr(&rcu_dynticks);

  
  	/* Page faults can happen in NMI handlers, so check... */

  	if (rdtp->dynticks_nmi_nesting)

  		return;

  	oldval = rdtp->dynticks_nesting;
  	rdtp->dynticks_nesting++;

  	WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) &&
  		     rdtp->dynticks_nesting == 0);

  	if (oldval)

  		trace_rcu_dyntick(TPS("++="), oldval, rdtp->dynticks_nesting);

  	else

  		rcu_eqs_exit_common(oldval, true);

  }
  
  /*
   * Wrapper for rcu_irq_enter() where interrupts are enabled.
   */
  void rcu_irq_enter_irqson(void)
  {
  	unsigned long flags;
  
  	local_irq_save(flags);
  	rcu_irq_enter();

  	local_irq_restore(flags);

  }
  
  /**
   * rcu_nmi_enter - inform RCU of entry to NMI context
   *

   * If the CPU was idle from RCU's viewpoint, update rdtp->dynticks and
   * rdtp->dynticks_nmi_nesting to let the RCU grace-period handling know
   * that the CPU is active.  This implementation permits nested NMIs, as
   * long as the nesting level does not overflow an int.  (You will probably
   * run out of stack space first.)

   */
  void rcu_nmi_enter(void)
  {

  	struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);

  	int incby = 2;

  	/* Complain about underflow. */
  	WARN_ON_ONCE(rdtp->dynticks_nmi_nesting < 0);
  
  	/*
  	 * If idle from RCU viewpoint, atomically increment ->dynticks
  	 * to mark non-idle and increment ->dynticks_nmi_nesting by one.
  	 * Otherwise, increment ->dynticks_nmi_nesting by two.  This means
  	 * if ->dynticks_nmi_nesting is equal to one, we are guaranteed
  	 * to be in the outermost NMI handler that interrupted an RCU-idle
  	 * period (observation due to Andy Lutomirski).
  	 */

  	if (rcu_dynticks_curr_cpu_in_eqs()) {

  		rcu_dynticks_eqs_exit();

  		incby = 1;
  	}
  	rdtp->dynticks_nmi_nesting += incby;
  	barrier();

  }
  
  /**
   * rcu_nmi_exit - inform RCU of exit from NMI context
   *

   * If we are returning from the outermost NMI handler that interrupted an
   * RCU-idle period, update rdtp->dynticks and rdtp->dynticks_nmi_nesting
   * to let the RCU grace-period handling know that the CPU is back to
   * being RCU-idle.

   */
  void rcu_nmi_exit(void)
  {

  	struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);

  	/*
  	 * Check for ->dynticks_nmi_nesting underflow and bad ->dynticks.
  	 * (We are exiting an NMI handler, so RCU better be paying attention
  	 * to us!)
  	 */
  	WARN_ON_ONCE(rdtp->dynticks_nmi_nesting <= 0);

  	WARN_ON_ONCE(rcu_dynticks_curr_cpu_in_eqs());

  
  	/*
  	 * If the nesting level is not 1, the CPU wasn't RCU-idle, so
  	 * leave it in non-RCU-idle state.
  	 */
  	if (rdtp->dynticks_nmi_nesting != 1) {
  		rdtp->dynticks_nmi_nesting -= 2;

  		return;

  	}
  
  	/* This NMI interrupted an RCU-idle CPU, restore RCU-idleness. */
  	rdtp->dynticks_nmi_nesting = 0;

  	rcu_dynticks_eqs_enter();

  }
  
  /**

   * rcu_is_watching - see if RCU thinks that the current CPU is idle

   *

   * Return true if RCU is watching the running CPU, which means that this
   * CPU can safely enter RCU read-side critical sections.  In other words,
   * if the current CPU is in its idle loop and is neither in an interrupt

   * or NMI handler, return true.

   */

  bool notrace rcu_is_watching(void)

  {

  	bool ret;

  	preempt_disable_notrace();

  	ret = !rcu_dynticks_curr_cpu_in_eqs();

  	preempt_enable_notrace();

  	return ret;

  }

  EXPORT_SYMBOL_GPL(rcu_is_watching);

  /*
   * If a holdout task is actually running, request an urgent quiescent
   * state from its CPU.  This is unsynchronized, so migrations can cause
   * the request to go to the wrong CPU.  Which is OK, all that will happen
   * is that the CPU's next context switch will be a bit slower and next
   * time around this task will generate another request.
   */
  void rcu_request_urgent_qs_task(struct task_struct *t)
  {
  	int cpu;
  
  	barrier();
  	cpu = task_cpu(t);
  	if (!task_curr(t))
  		return; /* This task is not running on that CPU. */
  	smp_store_release(per_cpu_ptr(&rcu_dynticks.rcu_urgent_qs, cpu), true);
  }

  #if defined(CONFIG_PROVE_RCU) && defined(CONFIG_HOTPLUG_CPU)

  
  /*
   * Is the current CPU online?  Disable preemption to avoid false positives
   * that could otherwise happen due to the current CPU number being sampled,
   * this task being preempted, its old CPU being taken offline, resuming
   * on some other CPU, then determining that its old CPU is now offline.
   * It is OK to use RCU on an offline processor during initial boot, hence

   * the check for rcu_scheduler_fully_active.  Note also that it is OK
   * for a CPU coming online to use RCU for one jiffy prior to marking itself
   * online in the cpu_online_mask.  Similarly, it is OK for a CPU going
   * offline to continue to use RCU for one jiffy after marking itself
   * offline in the cpu_online_mask.  This leniency is necessary given the
   * non-atomic nature of the online and offline processing, for example,

   * the fact that a CPU enters the scheduler after completing the teardown
   * of the CPU.

   *

   * This is also why RCU internally marks CPUs online during in the
   * preparation phase and offline after the CPU has been taken down.

   *
   * Disable checking if in an NMI handler because we cannot safely report
   * errors from NMI handlers anyway.
   */
  bool rcu_lockdep_current_cpu_online(void)
  {

  	struct rcu_data *rdp;
  	struct rcu_node *rnp;

  	bool ret;
  
  	if (in_nmi())

  		return true;

  	preempt_disable();

  	rdp = this_cpu_ptr(&rcu_sched_data);

  	rnp = rdp->mynode;

  	ret = (rdp->grpmask & rcu_rnp_online_cpus(rnp)) ||

  	      !rcu_scheduler_fully_active;
  	preempt_enable();
  	return ret;
  }
  EXPORT_SYMBOL_GPL(rcu_lockdep_current_cpu_online);

  #endif /* #if defined(CONFIG_PROVE_RCU) && defined(CONFIG_HOTPLUG_CPU) */

  /**

   * rcu_is_cpu_rrupt_from_idle - see if idle or immediately interrupted from idle

   *

   * If the current CPU is idle or running at a first-level (not nested)
   * interrupt from idle, return true.  The caller must have at least
   * disabled preemption.

   */

  static int rcu_is_cpu_rrupt_from_idle(void)

  {

  	return __this_cpu_read(rcu_dynticks.dynticks_nesting) <= 1;

  }

  /*

   * Snapshot the specified CPU's dynticks counter so that we can later
   * credit them with an implicit quiescent state.  Return 1 if this CPU

   * is in dynticks idle mode, which is an extended quiescent state.

   */

  static int dyntick_save_progress_counter(struct rcu_data *rdp)

  {

  	rdp->dynticks_snap = rcu_dynticks_snap(rdp->dynticks);

  	if (rcu_dynticks_in_eqs(rdp->dynticks_snap)) {

  		trace_rcu_fqs(rdp->rsp->name, rdp->gpnum, rdp->cpu, TPS("dti"));

  		if (ULONG_CMP_LT(READ_ONCE(rdp->gpnum) + ULONG_MAX / 4,

  				 rdp->mynode->gpnum))

  			WRITE_ONCE(rdp->gpwrap, true);

  		return 1;

  	}

  	return 0;

  }
  
  /*
   * Return true if the specified CPU has passed through a quiescent
   * state by virtue of being in or having passed through an dynticks
   * idle state since the last call to dyntick_save_progress_counter()

   * for this same CPU, or by virtue of having been offline.

   */

  static int rcu_implicit_dynticks_qs(struct rcu_data *rdp)

  {

  	unsigned long jtsq;

  	bool *rnhqp;

  	bool *ruqp;

  	unsigned long rjtsc;
  	struct rcu_node *rnp;

  
  	/*
  	 * If the CPU passed through or entered a dynticks idle phase with
  	 * no active irq/NMI handlers, then we can safely pretend that the CPU
  	 * already acknowledged the request to pass through a quiescent
  	 * state.  Either way, that CPU cannot possibly be in an RCU
  	 * read-side critical section that started before the beginning
  	 * of the current RCU grace period.
  	 */

  	if (rcu_dynticks_in_eqs_since(rdp->dynticks, rdp->dynticks_snap)) {

  		trace_rcu_fqs(rdp->rsp->name, rdp->gpnum, rdp->cpu, TPS("dti"));

  		rdp->dynticks_fqs++;
  		return 1;
  	}

  	/* Compute and saturate jiffies_till_sched_qs. */
  	jtsq = jiffies_till_sched_qs;
  	rjtsc = rcu_jiffies_till_stall_check();
  	if (jtsq > rjtsc / 2) {
  		WRITE_ONCE(jiffies_till_sched_qs, rjtsc);
  		jtsq = rjtsc / 2;
  	} else if (jtsq < 1) {
  		WRITE_ONCE(jiffies_till_sched_qs, 1);
  		jtsq = 1;
  	}

  	/*

  	 * Has this CPU encountered a cond_resched_rcu_qs() since the
  	 * beginning of the grace period?  For this to be the case,
  	 * the CPU has to have noticed the current grace period.  This
  	 * might not be the case for nohz_full CPUs looping in the kernel.

  	 */

  	rnp = rdp->mynode;

  	ruqp = per_cpu_ptr(&rcu_dynticks.rcu_urgent_qs, rdp->cpu);

  	if (time_after(jiffies, rdp->rsp->gp_start + jtsq) &&

  	    READ_ONCE(rdp->rcu_qs_ctr_snap) != per_cpu(rcu_dynticks.rcu_qs_ctr, rdp->cpu) &&

  	    READ_ONCE(rdp->gpnum) == rnp->gpnum && !rdp->gpwrap) {
  		trace_rcu_fqs(rdp->rsp->name, rdp->gpnum, rdp->cpu, TPS("rqc"));
  		return 1;

  	} else {
  		/* Load rcu_qs_ctr before store to rcu_urgent_qs. */
  		smp_store_release(ruqp, true);

  	}

  	/* Check for the CPU being offline. */
  	if (!(rdp->grpmask & rcu_rnp_online_cpus(rnp))) {

  		trace_rcu_fqs(rdp->rsp->name, rdp->gpnum, rdp->cpu, TPS("ofl"));

  		rdp->offline_fqs++;
  		return 1;
  	}

  
  	/*

  	 * A CPU running for an extended time within the kernel can
  	 * delay RCU grace periods.  When the CPU is in NO_HZ_FULL mode,
  	 * even context-switching back and forth between a pair of
  	 * in-kernel CPU-bound tasks cannot advance grace periods.
  	 * So if the grace period is old enough, make the CPU pay attention.
  	 * Note that the unsynchronized assignments to the per-CPU

  	 * rcu_need_heavy_qs variable are safe.  Yes, setting of

  	 * bits can be lost, but they will be set again on the next
  	 * force-quiescent-state pass.  So lost bit sets do not result
  	 * in incorrect behavior, merely in a grace period lasting
  	 * a few jiffies longer than it might otherwise.  Because
  	 * there are at most four threads involved, and because the
  	 * updates are only once every few jiffies, the probability of
  	 * lossage (and thus of slight grace-period extension) is
  	 * quite low.
  	 *
  	 * Note that if the jiffies_till_sched_qs boot/sysfs parameter
  	 * is set too high, we override with half of the RCU CPU stall
  	 * warning delay.

  	 */

  	rnhqp = &per_cpu(rcu_dynticks.rcu_need_heavy_qs, rdp->cpu);
  	if (!READ_ONCE(*rnhqp) &&
  	    (time_after(jiffies, rdp->rsp->gp_start + jtsq) ||
  	     time_after(jiffies, rdp->rsp->jiffies_resched))) {
  		WRITE_ONCE(*rnhqp, true);

  		/* Store rcu_need_heavy_qs before rcu_urgent_qs. */
  		smp_store_release(ruqp, true);

  		rdp->rsp->jiffies_resched += 5; /* Re-enable beating. */

  	}

  	/*
  	 * If more than halfway to RCU CPU stall-warning time, do
  	 * a resched_cpu() to try to loosen things up a bit.
  	 */
  	if (jiffies - rdp->rsp->gp_start > rcu_jiffies_till_stall_check() / 2)
  		resched_cpu(rdp->cpu);

  	return 0;

  }

  static void record_gp_stall_check_time(struct rcu_state *rsp)
  {

  	unsigned long j = jiffies;

  	unsigned long j1;

  
  	rsp->gp_start = j;
  	smp_wmb(); /* Record start time before stall time. */

  	j1 = rcu_jiffies_till_stall_check();

  	WRITE_ONCE(rsp->jiffies_stall, j + j1);

  	rsp->jiffies_resched = j + j1 / 2;

  	rsp->n_force_qs_gpstart = READ_ONCE(rsp->n_force_qs);

  }

  /*

   * Convert a ->gp_state value to a character string.
   */
  static const char *gp_state_getname(short gs)
  {
  	if (gs < 0 || gs >= ARRAY_SIZE(gp_state_names))
  		return "???";
  	return gp_state_names[gs];
  }
  
  /*

   * Complain about starvation of grace-period kthread.
   */
  static void rcu_check_gp_kthread_starvation(struct rcu_state *rsp)
  {
  	unsigned long gpa;
  	unsigned long j;
  
  	j = jiffies;

  	gpa = READ_ONCE(rsp->gp_activity);

  	if (j - gpa > 2 * HZ) {

  		pr_err("%s kthread starved for %ld jiffies! g%lu c%lu f%#x %s(%d) ->state=%#lx ->cpu=%d
  ",

  		       rsp->name, j - gpa,

  		       rsp->gpnum, rsp->completed,

  		       rsp->gp_flags,
  		       gp_state_getname(rsp->gp_state), rsp->gp_state,

  		       rsp->gp_kthread ? rsp->gp_kthread->state : ~0,
  		       rsp->gp_kthread ? task_cpu(rsp->gp_kthread) : -1);

  		if (rsp->gp_kthread) {

  			sched_show_task(rsp->gp_kthread);

  			wake_up_process(rsp->gp_kthread);
  		}

  	}

  }

  /*

   * Dump stacks of all tasks running on stalled CPUs.  First try using
   * NMIs, but fall back to manual remote stack tracing on architectures
   * that don't support NMI-based stack dumps.  The NMI-triggered stack
   * traces are more accurate because they are printed by the target CPU.

   */
  static void rcu_dump_cpu_stacks(struct rcu_state *rsp)
  {
  	int cpu;
  	unsigned long flags;
  	struct rcu_node *rnp;
  
  	rcu_for_each_leaf_node(rsp, rnp) {

  		raw_spin_lock_irqsave_rcu_node(rnp, flags);

  		for_each_leaf_node_possible_cpu(rnp, cpu)
  			if (rnp->qsmask & leaf_node_cpu_bit(rnp, cpu))
  				if (!trigger_single_cpu_backtrace(cpu))

  					dump_cpu_task(cpu);

  		raw_spin_unlock_irqrestore_rcu_node(rnp, flags);

  	}
  }

  /*
   * If too much time has passed in the current grace period, and if
   * so configured, go kick the relevant kthreads.
   */
  static void rcu_stall_kick_kthreads(struct rcu_state *rsp)
  {
  	unsigned long j;
  
  	if (!rcu_kick_kthreads)
  		return;
  	j = READ_ONCE(rsp->jiffies_kick_kthreads);

  	if (time_after(jiffies, j) && rsp->gp_kthread &&
  	    (rcu_gp_in_progress(rsp) || READ_ONCE(rsp->gp_flags))) {

  		WARN_ONCE(1, "Kicking %s grace-period kthread
  ", rsp->name);

  		rcu_ftrace_dump(DUMP_ALL);

  		wake_up_process(rsp->gp_kthread);
  		WRITE_ONCE(rsp->jiffies_kick_kthreads, j + HZ);
  	}
  }

  static inline void panic_on_rcu_stall(void)
  {
  	if (sysctl_panic_on_rcu_stall)
  		panic("RCU Stall
  ");
  }

  static void print_other_cpu_stall(struct rcu_state *rsp, unsigned long gpnum)

  {
  	int cpu;
  	long delta;
  	unsigned long flags;

  	unsigned long gpa;
  	unsigned long j;

  	int ndetected = 0;

  	struct rcu_node *rnp = rcu_get_root(rsp);

  	long totqlen = 0;

  	/* Kick and suppress, if so configured. */
  	rcu_stall_kick_kthreads(rsp);
  	if (rcu_cpu_stall_suppress)
  		return;

  	/* Only let one CPU complain about others per time interval. */

  	raw_spin_lock_irqsave_rcu_node(rnp, flags);

  	delta = jiffies - READ_ONCE(rsp->jiffies_stall);

  	if (delta < RCU_STALL_RAT_DELAY || !rcu_gp_in_progress(rsp)) {

  		raw_spin_unlock_irqrestore_rcu_node(rnp, flags);

  		return;
  	}

  	WRITE_ONCE(rsp->jiffies_stall,
  		   jiffies + 3 * rcu_jiffies_till_stall_check() + 3);

  	raw_spin_unlock_irqrestore_rcu_node(rnp, flags);

  	/*
  	 * OK, time to rat on our buddy...
  	 * See Documentation/RCU/stallwarn.txt for info on how to debug
  	 * RCU CPU stall warnings.
  	 */

  	pr_err("INFO: %s detected stalls on CPUs/tasks:",

  	       rsp->name);

  	print_cpu_stall_info_begin();

  	rcu_for_each_leaf_node(rsp, rnp) {

  		raw_spin_lock_irqsave_rcu_node(rnp, flags);

  		ndetected += rcu_print_task_stall(rnp);

  		if (rnp->qsmask != 0) {

  			for_each_leaf_node_possible_cpu(rnp, cpu)
  				if (rnp->qsmask & leaf_node_cpu_bit(rnp, cpu)) {
  					print_cpu_stall_info(rsp, cpu);

  					ndetected++;
  				}
  		}

  		raw_spin_unlock_irqrestore_rcu_node(rnp, flags);

  	}

  	print_cpu_stall_info_end();

  	for_each_possible_cpu(cpu)

  		totqlen += rcu_segcblist_n_cbs(&per_cpu_ptr(rsp->rda,
  							    cpu)->cblist);

  	pr_cont("(detected by %d, t=%ld jiffies, g=%ld, c=%ld, q=%lu)
  ",

  	       smp_processor_id(), (long)(jiffies - rsp->gp_start),

  	       (long)rsp->gpnum, (long)rsp->completed, totqlen);

  	if (ndetected) {

  		rcu_dump_cpu_stacks(rsp);

  
  		/* Complain about tasks blocking the grace period. */
  		rcu_print_detail_task_stall(rsp);

  	} else {

  		if (READ_ONCE(rsp->gpnum) != gpnum ||
  		    READ_ONCE(rsp->completed) == gpnum) {

  			pr_err("INFO: Stall ended before state dump start
  ");
  		} else {
  			j = jiffies;

  			gpa = READ_ONCE(rsp->gp_activity);

  			pr_err("All QSes seen, last %s kthread activity %ld (%ld-%ld), jiffies_till_next_fqs=%ld, root ->qsmask %#lx
  ",

  			       rsp->name, j - gpa, j, gpa,

  			       jiffies_till_next_fqs,
  			       rcu_get_root(rsp)->qsmask);

  			/* In this case, the current CPU might be at fault. */
  			sched_show_task(current);
  		}
  	}

  	rcu_check_gp_kthread_starvation(rsp);

  	panic_on_rcu_stall();

  	force_quiescent_state(rsp);  /* Kick them all. */

  }
  
  static void print_cpu_stall(struct rcu_state *rsp)
  {

  	int cpu;

  	unsigned long flags;
  	struct rcu_node *rnp = rcu_get_root(rsp);

  	long totqlen = 0;

  	/* Kick and suppress, if so configured. */
  	rcu_stall_kick_kthreads(rsp);
  	if (rcu_cpu_stall_suppress)
  		return;

  	/*
  	 * OK, time to rat on ourselves...
  	 * See Documentation/RCU/stallwarn.txt for info on how to debug
  	 * RCU CPU stall warnings.
  	 */

  	pr_err("INFO: %s self-detected stall on CPU", rsp->name);

  	print_cpu_stall_info_begin();
  	print_cpu_stall_info(rsp, smp_processor_id());
  	print_cpu_stall_info_end();

  	for_each_possible_cpu(cpu)

  		totqlen += rcu_segcblist_n_cbs(&per_cpu_ptr(rsp->rda,
  							    cpu)->cblist);

  	pr_cont(" (t=%lu jiffies g=%ld c=%ld q=%lu)
  ",
  		jiffies - rsp->gp_start,
  		(long)rsp->gpnum, (long)rsp->completed, totqlen);

  
  	rcu_check_gp_kthread_starvation(rsp);

  	rcu_dump_cpu_stacks(rsp);

  	raw_spin_lock_irqsave_rcu_node(rnp, flags);

  	if (ULONG_CMP_GE(jiffies, READ_ONCE(rsp->jiffies_stall)))
  		WRITE_ONCE(rsp->jiffies_stall,
  			   jiffies + 3 * rcu_jiffies_till_stall_check() + 3);

  	raw_spin_unlock_irqrestore_rcu_node(rnp, flags);

  	panic_on_rcu_stall();

  	/*
  	 * Attempt to revive the RCU machinery by forcing a context switch.
  	 *
  	 * A context switch would normally allow the RCU state machine to make
  	 * progress and it could be we're stuck in kernel space without context
  	 * switches for an entirely unreasonable amount of time.
  	 */
  	resched_cpu(smp_processor_id());

  }
  
  static void check_cpu_stall(struct rcu_state *rsp, struct rcu_data *rdp)
  {

  	unsigned long completed;
  	unsigned long gpnum;
  	unsigned long gps;

  	unsigned long j;
  	unsigned long js;

  	struct rcu_node *rnp;

  	if ((rcu_cpu_stall_suppress && !rcu_kick_kthreads) ||
  	    !rcu_gp_in_progress(rsp))

  		return;

  	rcu_stall_kick_kthreads(rsp);

  	j = jiffies;

  
  	/*
  	 * Lots of memory barriers to reject false positives.
  	 *
  	 * The idea is to pick up rsp->gpnum, then rsp->jiffies_stall,
  	 * then rsp->gp_start, and finally rsp->completed.  These values
  	 * are updated in the opposite order with memory barriers (or
  	 * equivalent) during grace-period initialization and cleanup.
  	 * Now, a false positive can occur if we get an new value of
  	 * rsp->gp_start and a old value of rsp->jiffies_stall.  But given
  	 * the memory barriers, the only way that this can happen is if one
  	 * grace period ends and another starts between these two fetches.
  	 * Detect this by comparing rsp->completed with the previous fetch
  	 * from rsp->gpnum.
  	 *
  	 * Given this check, comparisons of jiffies, rsp->jiffies_stall,
  	 * and rsp->gp_start suffice to forestall false positives.
  	 */

  	gpnum = READ_ONCE(rsp->gpnum);

  	smp_rmb(); /* Pick up ->gpnum first... */

  	js = READ_ONCE(rsp->jiffies_stall);

  	smp_rmb(); /* ...then ->jiffies_stall before the rest... */

  	gps = READ_ONCE(rsp->gp_start);

  	smp_rmb(); /* ...and finally ->gp_start before ->completed. */

  	completed = READ_ONCE(rsp->completed);

  	if (ULONG_CMP_GE(completed, gpnum) ||
  	    ULONG_CMP_LT(j, js) ||
  	    ULONG_CMP_GE(gps, js))
  		return; /* No stall or GP completed since entering function. */

  	rnp = rdp->mynode;

  	if (rcu_gp_in_progress(rsp) &&

  	    (READ_ONCE(rnp->qsmask) & rdp->grpmask)) {

  
  		/* We haven't checked in, so go dump stack. */
  		print_cpu_stall(rsp);

  	} else if (rcu_gp_in_progress(rsp) &&
  		   ULONG_CMP_GE(j, js + RCU_STALL_RAT_DELAY)) {

  		/* They had a few time units to dump stack, so complain. */