/*
   * 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.h>
  #include <linux/interrupt.h>
  #include <linux/sched.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 <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 "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, \

  	.orphan_lock = __RAW_SPIN_LOCK_UNLOCKED(&sname##_state.orphan_lock), \

  	.orphan_nxttail = &sname##_state.orphan_nxtlist, \
  	.orphan_donetail = &sname##_state.orphan_donelist, \

  	.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. */
  static 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 */

  #ifdef CONFIG_RCU_KTHREAD_PRIO

  static int kthread_prio = CONFIG_RCU_KTHREAD_PRIO;

  #else /* #ifdef CONFIG_RCU_KTHREAD_PRIO */
  static int kthread_prio = IS_ENABLED(CONFIG_RCU_BOOST) ? 1 : 0;
  #endif /* #else #ifdef CONFIG_RCU_KTHREAD_PRIO */

  module_param(kthread_prio, int, 0644);

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

  
  #ifdef CONFIG_RCU_TORTURE_TEST_SLOW_PREINIT
  static int gp_preinit_delay = CONFIG_RCU_TORTURE_TEST_SLOW_PREINIT_DELAY;
  module_param(gp_preinit_delay, int, 0644);
  #else /* #ifdef CONFIG_RCU_TORTURE_TEST_SLOW_PREINIT */
  static const int gp_preinit_delay;
  #endif /* #else #ifdef CONFIG_RCU_TORTURE_TEST_SLOW_PREINIT */

  #ifdef CONFIG_RCU_TORTURE_TEST_SLOW_INIT
  static int gp_init_delay = CONFIG_RCU_TORTURE_TEST_SLOW_INIT_DELAY;

  module_param(gp_init_delay, int, 0644);

  #else /* #ifdef CONFIG_RCU_TORTURE_TEST_SLOW_INIT */
  static const int gp_init_delay;
  #endif /* #else #ifdef CONFIG_RCU_TORTURE_TEST_SLOW_INIT */

  #ifdef CONFIG_RCU_TORTURE_TEST_SLOW_CLEANUP
  static int gp_cleanup_delay = CONFIG_RCU_TORTURE_TEST_SLOW_CLEANUP_DELAY;
  module_param(gp_cleanup_delay, int, 0644);
  #else /* #ifdef CONFIG_RCU_TORTURE_TEST_SLOW_CLEANUP */
  static const int gp_cleanup_delay;
  #endif /* #else #ifdef CONFIG_RCU_TORTURE_TEST_SLOW_CLEANUP */

  /*
   * Number of grace periods between delays, normalized by the duration of
   * the delay.  The longer the 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)

  {

  	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)

  {

  	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);

  	}

  }

  static DEFINE_PER_CPU(int, rcu_sched_qs_mask);
  
  static DEFINE_PER_CPU(struct rcu_dynticks, rcu_dynticks) = {
  	.dynticks_nesting = DYNTICK_TASK_EXIT_IDLE,
  	.dynticks = ATOMIC_INIT(1),
  #ifdef CONFIG_NO_HZ_FULL_SYSIDLE
  	.dynticks_idle_nesting = DYNTICK_TASK_NEST_VALUE,
  	.dynticks_idle = ATOMIC_INIT(1),
  #endif /* #ifdef CONFIG_NO_HZ_FULL_SYSIDLE */
  };

  DEFINE_PER_CPU_SHARED_ALIGNED(unsigned long, rcu_qs_ctr);
  EXPORT_PER_CPU_SYMBOL_GPL(rcu_qs_ctr);

  /*
   * 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, which we in turn do by incrementing the ->dynticks counter
   * by two.

   *
   * The caller must have disabled interrupts.

   */
  static void rcu_momentary_dyntick_idle(void)
  {

  	struct rcu_data *rdp;
  	struct rcu_dynticks *rdtp;
  	int resched_mask;
  	struct rcu_state *rsp;

  	/*
  	 * Yes, we can lose flag-setting operations.  This is OK, because
  	 * the flag will be set again after some delay.
  	 */
  	resched_mask = raw_cpu_read(rcu_sched_qs_mask);
  	raw_cpu_write(rcu_sched_qs_mask, 0);
  
  	/* Find the flavor that needs a quiescent state. */
  	for_each_rcu_flavor(rsp) {
  		rdp = raw_cpu_ptr(rsp->rda);
  		if (!(resched_mask & rsp->flavor_mask))
  			continue;
  		smp_mb(); /* rcu_sched_qs_mask before cond_resched_completed. */

  		if (READ_ONCE(rdp->mynode->completed) !=
  		    READ_ONCE(rdp->cond_resched_completed))

  			continue;
  
  		/*
  		 * Pretend to be momentarily idle for the quiescent state.
  		 * This allows the grace-period kthread to record the
  		 * quiescent state, with no need for this CPU to do anything
  		 * further.
  		 */
  		rdtp = this_cpu_ptr(&rcu_dynticks);
  		smp_mb__before_atomic(); /* Earlier stuff before QS. */
  		atomic_add(2, &rdtp->dynticks);  /* QS. */
  		smp_mb__after_atomic(); /* Later stuff after QS. */
  		break;
  	}

  }

  /*
   * 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(void)

  {

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

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

  	rcu_sched_qs();

  	rcu_preempt_note_context_switch();

  	if (unlikely(raw_cpu_read(rcu_sched_qs_mask)))
  		rcu_momentary_dyntick_idle();

  	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;

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

  	if (unlikely(raw_cpu_read(rcu_sched_qs_mask))) {
  		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))) {
  		/*
  		 * Yes, we just checked a per-CPU variable with preemption
  		 * enabled, so we might be migrated to some other CPU at
  		 * this point.  That is OK because in that case, the
  		 * migration will supply the needed quiescent state.
  		 * We might end up needlessly disabling preemption and
  		 * invoking rcu_sched_qs() on the destination CPU, but
  		 * the probability and cost are both quite low, so this
  		 * should not be a problem in practice.
  		 */
  		preempt_disable();
  		rcu_sched_qs();
  		preempt_enable();
  	}

  	this_cpu_inc(rcu_qs_ctr);

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

  }
  EXPORT_SYMBOL_GPL(rcu_all_qs);

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

  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, bool *isidle,
  				  unsigned long *maxj),
  			 bool *isidle, unsigned long *maxj);

  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) {

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

  		return;
  	}
  	*flags = 0;
  	*gpnum = 0;
  	*completed = 0;
  }
  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);
  
  /*

   * Does the CPU have callbacks ready to be invoked?
   */
  static int
  cpu_has_callbacks_ready_to_invoke(struct rcu_data *rdp)
  {

  	return &rdp->nxtlist != rdp->nxttail[RCU_DONE_TAIL] &&
  	       rdp->nxttail[RCU_DONE_TAIL] != NULL;

  }
  
  /*

   * 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];

  	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)
  {

  	int i;

  	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 (!rdp->nxttail[RCU_NEXT_TAIL])

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

  	if (*rdp->nxttail[RCU_NEXT_READY_TAIL])

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

  	for (i = RCU_WAIT_TAIL; i < RCU_NEXT_TAIL; i++)
  		if (rdp->nxttail[i - 1] != rdp->nxttail[i] &&

  		    ULONG_CMP_LT(READ_ONCE(rsp->completed),

  				 rdp->nxtcompleted[i]))

  			return true;  /* Yes, CBs for future grace period. */
  	return false; /* No grace period needed. */

  }
  
  /*

   * rcu_eqs_enter_common - current CPU is moving towards extended quiescent state

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

  static void rcu_eqs_enter_common(long long oldval, bool user)

  {

  	struct rcu_state *rsp;
  	struct rcu_data *rdp;

  	struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);

  	trace_rcu_dyntick(TPS("Start"), 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 entry: not idle task"), oldval, 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();

  	/* CPUs seeing atomic_inc() must see prior RCU read-side crit sects */

  	smp_mb__before_atomic();  /* See above. */

  	atomic_inc(&rdtp->dynticks);

  	smp_mb__after_atomic();  /* Force ordering with next sojourn. */

  	WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) &&
  		     atomic_read(&rdtp->dynticks) & 0x1);

  	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)

  {

  	long long oldval;

  	struct rcu_dynticks *rdtp;

  	rdtp = this_cpu_ptr(&rcu_dynticks);

  	oldval = rdtp->dynticks_nesting;

  	WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) &&
  		     (oldval & DYNTICK_TASK_NEST_MASK) == 0);

  	if ((oldval & DYNTICK_TASK_NEST_MASK) == DYNTICK_TASK_NEST_VALUE) {

  		rdtp->dynticks_nesting = 0;

  		rcu_eqs_enter_common(oldval, 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)
  {

  	unsigned long flags;
  
  	local_irq_save(flags);

  	rcu_eqs_enter(false);

  	rcu_sysidle_enter(0);

  	local_irq_restore(flags);

  }

  EXPORT_SYMBOL_GPL(rcu_idle_enter);

  #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_eqs_enter(1);

  }

  #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)

  {

  	long long oldval;

  	struct rcu_dynticks *rdtp;

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

  	rdtp = this_cpu_ptr(&rcu_dynticks);

  	oldval = rdtp->dynticks_nesting;

  	rdtp->dynticks_nesting--;

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

  	if (rdtp->dynticks_nesting)

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

  	else

  		rcu_eqs_enter_common(oldval, true);
  	rcu_sysidle_enter(1);

  }
  
  /*
   * 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)

  {

  	struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);

  	rcu_dynticks_task_exit();

  	smp_mb__before_atomic();  /* Force ordering w/previous sojourn. */

  	atomic_inc(&rdtp->dynticks);
  	/* CPUs seeing atomic_inc() must see later RCU read-side crit sects */

  	smp_mb__after_atomic();  /* See above. */

  	WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) &&
  		     !(atomic_read(&rdtp->dynticks) & 0x1));

  	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;

  	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 {

  		rdtp->dynticks_nesting = DYNTICK_TASK_EXIT_IDLE;

  		rcu_eqs_exit_common(oldval, user);

  	}

  }

  
  /**
   * 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);

  	rcu_sysidle_exit(0);

  	local_irq_restore(flags);

  }

  EXPORT_SYMBOL_GPL(rcu_idle_exit);

  #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);

  	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);
  	rcu_sysidle_exit(1);

  }
  
  /*
   * 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 (!(atomic_read(&rdtp->dynticks) & 0x1)) {
  		smp_mb__before_atomic();  /* Force delay from prior write. */
  		atomic_inc(&rdtp->dynticks);
  		/* atomic_inc() before later RCU read-side crit sects */
  		smp_mb__after_atomic();  /* See above. */
  		WARN_ON_ONCE(!(atomic_read(&rdtp->dynticks) & 0x1));
  		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(!(atomic_read(&rdtp->dynticks) & 0x1));
  
  	/*
  	 * 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;

  	/* CPUs seeing atomic_inc() must see prior RCU read-side crit sects */

  	smp_mb__before_atomic();  /* See above. */

  	atomic_inc(&rdtp->dynticks);

  	smp_mb__after_atomic();  /* Force delay to next write. */

  	WARN_ON_ONCE(atomic_read(&rdtp->dynticks) & 0x1);

  }
  
  /**

   * __rcu_is_watching - are RCU read-side critical sections safe?
   *
   * Return true if RCU is watching the running CPU, which means that
   * this CPU can safely enter RCU read-side critical sections.  Unlike
   * rcu_is_watching(), the caller of __rcu_is_watching() must have at
   * least disabled preemption.
   */

  bool notrace __rcu_is_watching(void)

  {
  	return atomic_read(this_cpu_ptr(&rcu_dynticks.dynticks)) & 0x1;
  }
  
  /**
   * rcu_is_watching - see if RCU thinks that the current CPU is idle

   *

   * 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_is_watching();

  	preempt_enable_notrace();

  	return ret;

  }

  EXPORT_SYMBOL_GPL(rcu_is_watching);

  #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,
  					 bool *isidle, unsigned long *maxj)

  {

  	rdp->dynticks_snap = atomic_add_return(0, &rdp->dynticks->dynticks);

  	rcu_sysidle_check_cpu(rdp, isidle, maxj);

  	if ((rdp->dynticks_snap & 0x1) == 0) {
  		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,
  				    bool *isidle, unsigned long *maxj)

  {

  	unsigned int curr;

  	int *rcrmp;

  	unsigned int snap;

  	curr = (unsigned int)atomic_add_return(0, &rdp->dynticks->dynticks);
  	snap = (unsigned int)rdp->dynticks_snap;

  
  	/*
  	 * 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 ((curr & 0x1) == 0 || UINT_CMP_GE(curr, snap + 2)) {

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

  		rdp->dynticks_fqs++;
  		return 1;
  	}

  	/*
  	 * Check for the CPU being offline, but only if the grace period
  	 * is old enough.  We don't need to worry about the CPU changing
  	 * state: If we see it offline even once, it has been through a
  	 * quiescent state.
  	 *
  	 * The reason for insisting that the grace period be at least
  	 * one jiffy old is that CPUs that are not quite online and that
  	 * have just gone offline can still execute RCU read-side critical
  	 * sections.
  	 */
  	if (ULONG_CMP_GE(rdp->rsp->gp_start + 2, jiffies))
  		return 0;  /* Grace period is not old enough. */
  	barrier();
  	if (cpu_is_offline(rdp->cpu)) {

  		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_sched_qs_mask 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.

  	 */

  	rcrmp = &per_cpu(rcu_sched_qs_mask, rdp->cpu);
  	if (ULONG_CMP_GE(jiffies,
  			 rdp->rsp->gp_start + jiffies_till_sched_qs) ||

  	    ULONG_CMP_GE(jiffies, rdp->rsp->jiffies_resched)) {

  		if (!(READ_ONCE(*rcrmp) & rdp->rsp->flavor_mask)) {
  			WRITE_ONCE(rdp->cond_resched_completed,
  				   READ_ONCE(rdp->mynode->completed));

  			smp_mb(); /* ->cond_resched_completed before *rcrmp. */

  			WRITE_ONCE(*rcrmp,
  				   READ_ONCE(*rcrmp) + rdp->rsp->flavor_mask);

  		}

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

  	}

  	/* And if it has been a really long time, kick the CPU as well. */
  	if (ULONG_CMP_GE(jiffies,
  			 rdp->rsp->gp_start + 2 * jiffies_till_sched_qs) ||
  	    ULONG_CMP_GE(jiffies, rdp->rsp->gp_start + jiffies_till_sched_qs))
  		resched_cpu(rdp->cpu);  /* Force CPU into scheduler. */

  	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
  ",

  		       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);

  		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.

   */
  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);

  		if (rnp->qsmask != 0) {

  			for_each_leaf_node_possible_cpu(rnp, cpu)
  				if (rnp->qsmask & leaf_node_cpu_bit(rnp, 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) {
  		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 += per_cpu_ptr(rsp->rda, cpu)->qlen;

  	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);

  	} 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);
  		}
  	}

  	/* Complain about tasks blocking the grace period. */

  	rcu_print_detail_task_stall(rsp);

  	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 += per_cpu_ptr(rsp->rda, cpu)->qlen;

  	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. */

  		print_other_cpu_stall(rsp, gpnum);

  	}
  }

  /**
   * rcu_cpu_stall_reset - prevent further stall warnings in current grace period
   *
   * Set the stall-warning timeout way off into the future, thus preventing
   * any RCU CPU stall-warning messages from appearing in the current set of
   * RCU grace periods.
   *
   * The caller must disable hard irqs.
   */
  void rcu_cpu_stall_reset(void)
  {

  	struct rcu_state *rsp;
  
  	for_each_rcu_flavor(rsp)

  		WRITE_ONCE(rsp->jiffies_stall, jiffies + ULONG_MAX / 2);

  }

  /*

   * Initialize the specified rcu_data structure's default callback list
   * to empty.  The default callback list is the one that is not used by
   * no-callbacks CPUs.

   */

  static void init_default_callback_list(struct rcu_data *rdp)

  {
  	int i;
  
  	rdp->nxtlist = NULL;
  	for (i = 0; i < RCU_NEXT_SIZE; i++)
  		rdp->nxttail[i] = &rdp->nxtlist;
  }
  
  /*

   * Initialize the specified rcu_data structure's callback list to empty.
   */
  static void init_callback_list(struct rcu_data *rdp)
  {
  	if (init_nocb_callback_list(rdp))
  		return;
  	init_default_callback_list(rdp);
  }
  
  /*

   * Determine the value that ->completed will have at the end of the
   * next subsequent grace period.  This is used to tag callbacks so that
   * a CPU can invoke callbacks in a timely fashion even if that CPU has
   * been dyntick-idle for an extended period with callbacks under the
   * influence of RCU_FAST_NO_HZ.
   *
   * The caller must hold rnp->lock with interrupts disabled.
   */
  static unsigned long rcu_cbs_completed(struct rcu_state *rsp,
  				       struct rcu_node *rnp)
  {
  	/*
  	 * If RCU is idle, we just wait for the next grace period.
  	 * But we can only be sure that RCU is idle if we are looking
  	 * at the root rcu_node structure -- otherwise, a new grace
  	 * period might have started, but just not yet gotten around
  	 * to initializing the current non-root rcu_node structure.
  	 */
  	if (rcu_get_root(rsp) == rnp && rnp->gpnum == rnp->completed)
  		return rnp->completed + 1;
  
  	/*
  	 * Otherwise, wait for a possible partial grace period and
  	 * then the subsequent full grace period.
  	 */
  	return rnp->completed + 2;
  }
  
  /*

   * Trace-event helper function for rcu_start_future_gp() and
   * rcu_nocb_wait_gp().
   */
  static void trace_rcu_future_gp(struct rcu_node *rnp, struct rcu_data *rdp,

  				unsigned long c, const char *s)

  {
  	trace_rcu_future_grace_period(rdp->rsp->name, rnp->gpnum,
  				      rnp->completed, c, rnp->level,
  				      rnp->grplo, rnp->grphi, s);
  }
  
  /*
   * Start some future grace period, as needed to handle newly arrived
   * callbacks.  The required future grace periods are recorded in each

   * rcu_node structure's ->need_future_gp field.  Returns true if there
   * is reason to awaken the grace-period kthread.

   *
   * The caller must hold the specified rcu_node structure's ->lock.
   */

  static bool __maybe_unused
  rcu_start_future_gp(struct rcu_node *rnp, struct rcu_data *rdp,
  		    unsigned long *c_out)

  {
  	unsigned long c;
  	int i;

  	bool ret = false;

  	struct rcu_node *rnp_root = rcu_get_root(rdp->rsp);
  
  	/*
  	 * Pick up grace-period number for new callbacks.  If this
  	 * grace period is already marked as needed, return to the caller.
  	 */
  	c = rcu_cbs_completed(rdp->rsp, rnp);

  	trace_rcu_future_gp(rnp, rdp, c, TPS("Startleaf"));

  	if (rnp->need_future_gp[c & 0x1]) {

  		trace_rcu_future_gp(rnp, rdp, c, TPS("Prestartleaf"));

  		goto out;

  	}
  
  	/*
  	 * If either this rcu_node structure or the root rcu_node structure
  	 * believe that a grace period is in progress, then we must wait
  	 * for the one following, which is in "c".  Because our request
  	 * will be noticed at the end of the current grace period, we don't

  	 * need to explicitly start one.  We only do the lockless check
  	 * of rnp_root's fields if the current rcu_node structure thinks
  	 * there is no grace period in flight, and because we hold rnp->lock,
  	 * the only possible change is when rnp_root's two fields are
  	 * equal, in which case rnp_root->gpnum might be concurrently
  	 * incremented.  But that is OK, as it will just result in our
  	 * doing some extra useless work.

  	 */
  	if (rnp->gpnum != rnp->completed ||

  	    READ_ONCE(rnp_root->gpnum) != READ_ONCE(rnp_root->completed)) {

  		rnp->need_future_gp[c & 0x1]++;

  		trace_rcu_future_gp(rnp, rdp, c, TPS("Startedleaf"));

  		goto out;

  	}
  
  	/*
  	 * There might be no grace period in progress.  If we don't already
  	 * hold it, acquire the root rcu_node structure's lock in order to
  	 * start one (if needed).
  	 */

  	if (rnp != rnp_root)
  		raw_spin_lock_rcu_node(rnp_root);

  
  	/*
  	 * Get a new grace-period number.  If there really is no grace
  	 * period in progress, it will be smaller than the one we obtained
  	 * earlier.  Adjust callbacks as needed.  Note that even no-CBs
  	 * CPUs have a ->nxtcompleted[] array, so no no-CBs checks needed.
  	 */
  	c = rcu_cbs_completed(rdp->rsp, rnp_root);
  	for (i = RCU_DONE_TAIL; i < RCU_NEXT_TAIL; i++)
  		if (ULONG_CMP_LT(c, rdp->nxtcompleted[i]))
  			rdp->nxtcompleted[i] = c;
  
  	/*
  	 * If the needed for the required grace period is already
  	 * recorded, trace and leave.
  	 */
  	if (rnp_root->need_future_gp[c & 0x1]) {

  		trace_rcu_future_gp(rnp, rdp, c, TPS("Prestartedroot"));

  		goto unlock_out;
  	}
  
  	/* Record the need for the future grace period. */
  	rnp_root->need_future_gp[c & 0x1]++;
  
  	/* If a grace period is not already in progress, start one. */
  	if (rnp_root->gpnum != rnp_root->completed) {

  		trace_rcu_future_gp(rnp, rdp, c, TPS("Startedleafroot"));

  	} else {

  		trace_rcu_future_gp(rnp, rdp, c, TPS("Startedroot"));

  		ret = rcu_start_gp_advanced(rdp->rsp, rnp_root, rdp);

  	}
  unlock_out:
  	if (rnp != rnp_root)

  		raw_spin_unlock_rcu_node(rnp_root);

  out:
  	if (c_out != NULL)
  		*c_out = c;
  	return ret;

  }
  
  /*
   * Clean up any old requests for the just-ended grace period.  Also return
   * whether any additional grace periods have been requested.  Also invoke
   * rcu_nocb_gp_cleanup() in order to wake up any no-callbacks kthreads
   * waiting for this grace period to complete.
   */
  static int rcu_future_gp_cleanup(struct rcu_state *rsp, struct rcu_node *rnp)
  {
  	int c = rnp->completed;
  	int needmore;
  	struct rcu_data *rdp = this_cpu_ptr(rsp->rda);

  	rnp->need_future_gp[c & 0x1] = 0;
  	needmore = rnp->need_future_gp[(c + 1) & 0x1];

  	trace_rcu_future_gp(rnp, rdp, c,
  			    needmore ? TPS("CleanupMore") : TPS("Cleanup"));

  	return needmore;
  }
  
  /*