tree_exp.h

   1/* SPDX-License-Identifier: GPL-2.0+ */
   2/*
   3 * RCU expedited grace periods
   4 *
   5 * Copyright IBM Corporation, 2016
   6 *
   7 * Authors: Paul E. McKenney <paulmck@linux.ibm.com>
   8 */
   9
  10#include <linux/console.h>
  11#include <linux/lockdep.h>
  12
  13static void rcu_exp_handler(void *unused);
  14static int rcu_print_task_exp_stall(struct rcu_node *rnp);
  15static void rcu_exp_print_detail_task_stall_rnp(struct rcu_node *rnp);
  16
  17/*
  18 * Record the start of an expedited grace period.
  19 */
  20static void rcu_exp_gp_seq_start(void)
  21{
  22	rcu_seq_start(&rcu_state.expedited_sequence);
  23	rcu_poll_gp_seq_start_unlocked(&rcu_state.gp_seq_polled_exp_snap);
  24}
  25
  26/*
  27 * Return the value that the expedited-grace-period counter will have
  28 * at the end of the current grace period.
  29 */
  30static __maybe_unused unsigned long rcu_exp_gp_seq_endval(void)
  31{
  32	return rcu_seq_endval(&rcu_state.expedited_sequence);
  33}
  34
  35/*
  36 * Record the end of an expedited grace period.
  37 */
  38static void rcu_exp_gp_seq_end(void)
  39{
  40	rcu_poll_gp_seq_end_unlocked(&rcu_state.gp_seq_polled_exp_snap);
  41	rcu_seq_end(&rcu_state.expedited_sequence);
  42	smp_mb(); /* Ensure that consecutive grace periods serialize. */
  43}
  44
  45/*
  46 * Take a snapshot of the expedited-grace-period counter, which is the
  47 * earliest value that will indicate that a full grace period has
  48 * elapsed since the current time.
  49 */
  50static unsigned long rcu_exp_gp_seq_snap(void)
  51{
  52	unsigned long s;
  53
  54	smp_mb(); /* Caller's modifications seen first by other CPUs. */
  55	s = rcu_seq_snap(&rcu_state.expedited_sequence);
  56	trace_rcu_exp_grace_period(rcu_state.name, s, TPS("snap"));
  57	return s;
  58}
  59
  60/*
  61 * Given a counter snapshot from rcu_exp_gp_seq_snap(), return true
  62 * if a full expedited grace period has elapsed since that snapshot
  63 * was taken.
  64 */
  65static bool rcu_exp_gp_seq_done(unsigned long s)
  66{
  67	return rcu_seq_done(&rcu_state.expedited_sequence, s);
  68}
  69
  70/*
  71 * Reset the ->expmaskinit values in the rcu_node tree to reflect any
  72 * recent CPU-online activity.  Note that these masks are not cleared
  73 * when CPUs go offline, so they reflect the union of all CPUs that have
  74 * ever been online.  This means that this function normally takes its
  75 * no-work-to-do fastpath.
  76 */
  77static void sync_exp_reset_tree_hotplug(void)
  78{
  79	bool done;
  80	unsigned long flags;
  81	unsigned long mask;
  82	unsigned long oldmask;
  83	int ncpus = smp_load_acquire(&rcu_state.ncpus); /* Order vs. locking. */
  84	struct rcu_node *rnp;
  85	struct rcu_node *rnp_up;
  86
  87	/* If no new CPUs onlined since last time, nothing to do. */
  88	if (likely(ncpus == rcu_state.ncpus_snap))
  89		return;
  90	rcu_state.ncpus_snap = ncpus;
  91
  92	/*
  93	 * Each pass through the following loop propagates newly onlined
  94	 * CPUs for the current rcu_node structure up the rcu_node tree.
  95	 */
  96	rcu_for_each_leaf_node(rnp) {
  97		raw_spin_lock_irqsave_rcu_node(rnp, flags);
  98		if (rnp->expmaskinit == rnp->expmaskinitnext) {
  99			raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
 100			continue;  /* No new CPUs, nothing to do. */
 101		}
 102
 103		/* Update this node's mask, track old value for propagation. */
 104		oldmask = rnp->expmaskinit;
 105		rnp->expmaskinit = rnp->expmaskinitnext;
 106		raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
 107
 108		/* If was already nonzero, nothing to propagate. */
 109		if (oldmask)
 110			continue;
 111
 112		/* Propagate the new CPU up the tree. */
 113		mask = rnp->grpmask;
 114		rnp_up = rnp->parent;
 115		done = false;
 116		while (rnp_up) {
 117			raw_spin_lock_irqsave_rcu_node(rnp_up, flags);
 118			if (rnp_up->expmaskinit)
 119				done = true;
 120			rnp_up->expmaskinit |= mask;
 121			raw_spin_unlock_irqrestore_rcu_node(rnp_up, flags);
 122			if (done)
 123				break;
 124			mask = rnp_up->grpmask;
 125			rnp_up = rnp_up->parent;
 126		}
 127	}
 128}
 129
 130/*
 131 * Reset the ->expmask values in the rcu_node tree in preparation for
 132 * a new expedited grace period.
 133 */
 134static void __maybe_unused sync_exp_reset_tree(void)
 135{
 136	unsigned long flags;
 137	struct rcu_node *rnp;
 138
 139	sync_exp_reset_tree_hotplug();
 140	rcu_for_each_node_breadth_first(rnp) {
 141		raw_spin_lock_irqsave_rcu_node(rnp, flags);
 142		WARN_ON_ONCE(rnp->expmask);
 143		WRITE_ONCE(rnp->expmask, rnp->expmaskinit);
 144		/*
 145		 * Need to wait for any blocked tasks as well.	Note that
 146		 * additional blocking tasks will also block the expedited GP
 147		 * until such time as the ->expmask bits are cleared.
 148		 */
 149		if (rcu_is_leaf_node(rnp) && rcu_preempt_has_tasks(rnp))
 150			WRITE_ONCE(rnp->exp_tasks, rnp->blkd_tasks.next);
 151		raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
 152	}
 153}
 154
 155/*
 156 * Return non-zero if there is no RCU expedited grace period in progress
 157 * for the specified rcu_node structure, in other words, if all CPUs and
 158 * tasks covered by the specified rcu_node structure have done their bit
 159 * for the current expedited grace period.
 160 */
 161static bool sync_rcu_exp_done(struct rcu_node *rnp)
 162{
 163	raw_lockdep_assert_held_rcu_node(rnp);
 164	return READ_ONCE(rnp->exp_tasks) == NULL &&
 165	       READ_ONCE(rnp->expmask) == 0;
 166}
 167
 168/*
 169 * Like sync_rcu_exp_done(), but where the caller does not hold the
 170 * rcu_node's ->lock.
 171 */
 172static bool sync_rcu_exp_done_unlocked(struct rcu_node *rnp)
 173{
 174	unsigned long flags;
 175	bool ret;
 176
 177	raw_spin_lock_irqsave_rcu_node(rnp, flags);
 178	ret = sync_rcu_exp_done(rnp);
 179	raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
 180
 181	return ret;
 182}
 183
 184/*
 185 * Report the exit from RCU read-side critical section for the last task
 186 * that queued itself during or before the current expedited preemptible-RCU
 187 * grace period.  This event is reported either to the rcu_node structure on
 188 * which the task was queued or to one of that rcu_node structure's ancestors,
 189 * recursively up the tree.  (Calm down, calm down, we do the recursion
 190 * iteratively!)
 191 */
 192static void __rcu_report_exp_rnp(struct rcu_node *rnp,
 193				 bool wake, unsigned long flags)
 194	__releases(rnp->lock)
 195{
 196	unsigned long mask;
 197
 198	raw_lockdep_assert_held_rcu_node(rnp);
 199	for (;;) {
 200		if (!sync_rcu_exp_done(rnp)) {
 201			if (!rnp->expmask)
 202				rcu_initiate_boost(rnp, flags);
 203			else
 204				raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
 205			break;
 206		}
 207		if (rnp->parent == NULL) {
 208			raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
 209			if (wake)
 210				swake_up_one(&rcu_state.expedited_wq);
 211
 212			break;
 213		}
 214		mask = rnp->grpmask;
 215		raw_spin_unlock_rcu_node(rnp); /* irqs remain disabled */
 216		rnp = rnp->parent;
 217		raw_spin_lock_rcu_node(rnp); /* irqs already disabled */
 218		WARN_ON_ONCE(!(rnp->expmask & mask));
 219		WRITE_ONCE(rnp->expmask, rnp->expmask & ~mask);
 220	}
 221}
 222
 223/*
 224 * Report expedited quiescent state for specified node.  This is a
 225 * lock-acquisition wrapper function for __rcu_report_exp_rnp().
 226 */
 227static void __maybe_unused rcu_report_exp_rnp(struct rcu_node *rnp, bool wake)
 228{
 229	unsigned long flags;
 230
 231	raw_spin_lock_irqsave_rcu_node(rnp, flags);
 232	__rcu_report_exp_rnp(rnp, wake, flags);
 233}
 234
 235/*
 236 * Report expedited quiescent state for multiple CPUs, all covered by the
 237 * specified leaf rcu_node structure, which is acquired by the caller.
 238 */
 239static void rcu_report_exp_cpu_mult(struct rcu_node *rnp, unsigned long flags,
 240				    unsigned long mask_in, bool wake)
 241				    __releases(rnp->lock)
 242{
 243	int cpu;
 244	unsigned long mask;
 245	struct rcu_data *rdp;
 246
 247	raw_lockdep_assert_held_rcu_node(rnp);
 248	if (!(rnp->expmask & mask_in)) {
 249		raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
 250		return;
 251	}
 252	mask = mask_in & rnp->expmask;
 253	WRITE_ONCE(rnp->expmask, rnp->expmask & ~mask);
 254	for_each_leaf_node_cpu_mask(rnp, cpu, mask) {
 255		rdp = per_cpu_ptr(&rcu_data, cpu);
 256		if (!IS_ENABLED(CONFIG_NO_HZ_FULL) || !rdp->rcu_forced_tick_exp)
 257			continue;
 258		rdp->rcu_forced_tick_exp = false;
 259		tick_dep_clear_cpu(cpu, TICK_DEP_BIT_RCU_EXP);
 260	}
 261	__rcu_report_exp_rnp(rnp, wake, flags); /* Releases rnp->lock. */
 262}
 263
 264/*
 265 * Report expedited quiescent state for specified rcu_data (CPU).
 266 */
 267static void rcu_report_exp_rdp(struct rcu_data *rdp)
 268{
 269	unsigned long flags;
 270	struct rcu_node *rnp = rdp->mynode;
 271
 272	raw_spin_lock_irqsave_rcu_node(rnp, flags);
 273	WRITE_ONCE(rdp->cpu_no_qs.b.exp, false);
 274	ASSERT_EXCLUSIVE_WRITER(rdp->cpu_no_qs.b.exp);
 275	rcu_report_exp_cpu_mult(rnp, flags, rdp->grpmask, true);
 276}
 277
 278/* Common code for work-done checking. */
 279static bool sync_exp_work_done(unsigned long s)
 280{
 281	if (rcu_exp_gp_seq_done(s)) {
 282		trace_rcu_exp_grace_period(rcu_state.name, s, TPS("done"));
 283		/*
 284		 * Order GP completion with preceding accesses. Order also GP
 285		 * completion with post GP update side accesses. Pairs with
 286		 * rcu_seq_end().
 287		 */
 288		smp_mb();
 289		return true;
 290	}
 291	return false;
 292}
 293
 294/*
 295 * Funnel-lock acquisition for expedited grace periods.  Returns true
 296 * if some other task completed an expedited grace period that this task
 297 * can piggy-back on, and with no mutex held.  Otherwise, returns false
 298 * with the mutex held, indicating that the caller must actually do the
 299 * expedited grace period.
 300 */
 301static bool exp_funnel_lock(unsigned long s)
 302{
 303	struct rcu_data *rdp = per_cpu_ptr(&rcu_data, raw_smp_processor_id());
 304	struct rcu_node *rnp = rdp->mynode;
 305	struct rcu_node *rnp_root = rcu_get_root();
 306
 307	/* Low-contention fastpath. */
 308	if (ULONG_CMP_LT(READ_ONCE(rnp->exp_seq_rq), s) &&
 309	    (rnp == rnp_root ||
 310	     ULONG_CMP_LT(READ_ONCE(rnp_root->exp_seq_rq), s)) &&
 311	    mutex_trylock(&rcu_state.exp_mutex))
 312		goto fastpath;
 313
 314	/*
 315	 * Each pass through the following loop works its way up
 316	 * the rcu_node tree, returning if others have done the work or
 317	 * otherwise falls through to acquire ->exp_mutex.  The mapping
 318	 * from CPU to rcu_node structure can be inexact, as it is just
 319	 * promoting locality and is not strictly needed for correctness.
 320	 */
 321	for (; rnp != NULL; rnp = rnp->parent) {
 322		if (sync_exp_work_done(s))
 323			return true;
 324
 325		/* Work not done, either wait here or go up. */
 326		spin_lock(&rnp->exp_lock);
 327		if (ULONG_CMP_GE(rnp->exp_seq_rq, s)) {
 328
 329			/* Someone else doing GP, so wait for them. */
 330			spin_unlock(&rnp->exp_lock);
 331			trace_rcu_exp_funnel_lock(rcu_state.name, rnp->level,
 332						  rnp->grplo, rnp->grphi,
 333						  TPS("wait"));
 334			wait_event(rnp->exp_wq[rcu_seq_ctr(s) & 0x3],
 335				   sync_exp_work_done(s));
 336			return true;
 337		}
 338		WRITE_ONCE(rnp->exp_seq_rq, s); /* Followers can wait on us. */
 339		spin_unlock(&rnp->exp_lock);
 340		trace_rcu_exp_funnel_lock(rcu_state.name, rnp->level,
 341					  rnp->grplo, rnp->grphi, TPS("nxtlvl"));
 342	}
 343	mutex_lock(&rcu_state.exp_mutex);
 344fastpath:
 345	if (sync_exp_work_done(s)) {
 346		mutex_unlock(&rcu_state.exp_mutex);
 347		return true;
 348	}
 349	rcu_exp_gp_seq_start();
 350	trace_rcu_exp_grace_period(rcu_state.name, s, TPS("start"));
 351	return false;
 352}
 353
 354/*
 355 * Select the CPUs within the specified rcu_node that the upcoming
 356 * expedited grace period needs to wait for.
 357 */
 358static void __sync_rcu_exp_select_node_cpus(struct rcu_exp_work *rewp)
 359{
 360	int cpu;
 361	unsigned long flags;
 362	unsigned long mask_ofl_test;
 363	unsigned long mask_ofl_ipi;
 364	int ret;
 365	struct rcu_node *rnp = container_of(rewp, struct rcu_node, rew);
 366
 367	raw_spin_lock_irqsave_rcu_node(rnp, flags);
 368
 369	/* Each pass checks a CPU for identity, offline, and idle. */
 370	mask_ofl_test = 0;
 371	for_each_leaf_node_cpu_mask(rnp, cpu, rnp->expmask) {
 372		struct rcu_data *rdp = per_cpu_ptr(&rcu_data, cpu);
 373		unsigned long mask = rdp->grpmask;
 374		int snap;
 375
 376		if (raw_smp_processor_id() == cpu ||
 377		    !(rnp->qsmaskinitnext & mask)) {
 378			mask_ofl_test |= mask;
 379		} else {
 380			/*
 381			 * Full ordering between remote CPU's post idle accesses
 382			 * and updater's accesses prior to current GP (and also
 383			 * the started GP sequence number) is enforced by
 384			 * rcu_seq_start() implicit barrier, relayed by kworkers
 385			 * locking and even further by smp_mb__after_unlock_lock()
 386			 * barriers chained all the way throughout the rnp locking
 387			 * tree since sync_exp_reset_tree() and up to the current
 388			 * leaf rnp locking.
 389			 *
 390			 * Ordering between remote CPU's pre idle accesses and
 391			 * post grace period updater's accesses is enforced by the
 392			 * below acquire semantic.
 393			 */
 394			snap = ct_rcu_watching_cpu_acquire(cpu);
 395			if (rcu_watching_snap_in_eqs(snap))
 396				mask_ofl_test |= mask;
 397			else
 398				rdp->exp_watching_snap = snap;
 399		}
 400	}
 401	mask_ofl_ipi = rnp->expmask & ~mask_ofl_test;
 402
 403	raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
 404
 405	/* IPI the remaining CPUs for expedited quiescent state. */
 406	for_each_leaf_node_cpu_mask(rnp, cpu, mask_ofl_ipi) {
 407		struct rcu_data *rdp = per_cpu_ptr(&rcu_data, cpu);
 408		unsigned long mask = rdp->grpmask;
 409
 410retry_ipi:
 411		if (rcu_watching_snap_stopped_since(rdp, rdp->exp_watching_snap)) {
 412			mask_ofl_test |= mask;
 413			continue;
 414		}
 415		if (get_cpu() == cpu) {
 416			mask_ofl_test |= mask;
 417			put_cpu();
 418			continue;
 419		}
 420		ret = smp_call_function_single(cpu, rcu_exp_handler, NULL, 0);
 421		put_cpu();
 422		/* The CPU will report the QS in response to the IPI. */
 423		if (!ret)
 424			continue;
 425
 426		/* Failed, raced with CPU hotplug operation. */
 427		raw_spin_lock_irqsave_rcu_node(rnp, flags);
 428		if ((rnp->qsmaskinitnext & mask) &&
 429		    (rnp->expmask & mask)) {
 430			/* Online, so delay for a bit and try again. */
 431			raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
 432			trace_rcu_exp_grace_period(rcu_state.name, rcu_exp_gp_seq_endval(), TPS("selectofl"));
 433			schedule_timeout_idle(1);
 434			goto retry_ipi;
 435		}
 436		/* CPU really is offline, so we must report its QS. */
 437		if (rnp->expmask & mask)
 438			mask_ofl_test |= mask;
 439		raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
 440	}
 441	/* Report quiescent states for those that went offline. */
 442	if (mask_ofl_test) {
 443		raw_spin_lock_irqsave_rcu_node(rnp, flags);
 444		rcu_report_exp_cpu_mult(rnp, flags, mask_ofl_test, false);
 445	}
 446}
 447
 448static void rcu_exp_sel_wait_wake(unsigned long s);
 449
 450static void sync_rcu_exp_select_node_cpus(struct kthread_work *wp)
 451{
 452	struct rcu_exp_work *rewp =
 453		container_of(wp, struct rcu_exp_work, rew_work);
 454
 455	__sync_rcu_exp_select_node_cpus(rewp);
 456}
 457
 458static inline bool rcu_exp_worker_started(void)
 459{
 460	return !!READ_ONCE(rcu_exp_gp_kworker);
 461}
 462
 463static inline bool rcu_exp_par_worker_started(struct rcu_node *rnp)
 464{
 465	return !!READ_ONCE(rnp->exp_kworker);
 466}
 467
 468static inline void sync_rcu_exp_select_cpus_queue_work(struct rcu_node *rnp)
 469{
 470	kthread_init_work(&rnp->rew.rew_work, sync_rcu_exp_select_node_cpus);
 471	/*
 472	 * Use rcu_exp_par_gp_kworker, because flushing a work item from
 473	 * another work item on the same kthread worker can result in
 474	 * deadlock.
 475	 */
 476	kthread_queue_work(READ_ONCE(rnp->exp_kworker), &rnp->rew.rew_work);
 477}
 478
 479static inline void sync_rcu_exp_select_cpus_flush_work(struct rcu_node *rnp)
 480{
 481	kthread_flush_work(&rnp->rew.rew_work);
 482}
 483
 484/*
 485 * Work-queue handler to drive an expedited grace period forward.
 486 */
 487static void wait_rcu_exp_gp(struct kthread_work *wp)
 488{
 489	struct rcu_exp_work *rewp;
 490
 491	rewp = container_of(wp, struct rcu_exp_work, rew_work);
 492	rcu_exp_sel_wait_wake(rewp->rew_s);
 493}
 494
 495static inline void synchronize_rcu_expedited_queue_work(struct rcu_exp_work *rew)
 496{
 497	kthread_init_work(&rew->rew_work, wait_rcu_exp_gp);
 498	kthread_queue_work(rcu_exp_gp_kworker, &rew->rew_work);
 499}
 500
 501/*
 502 * Select the nodes that the upcoming expedited grace period needs
 503 * to wait for.
 504 */
 505static void sync_rcu_exp_select_cpus(void)
 506{
 507	struct rcu_node *rnp;
 508
 509	trace_rcu_exp_grace_period(rcu_state.name, rcu_exp_gp_seq_endval(), TPS("reset"));
 510	sync_exp_reset_tree();
 511	trace_rcu_exp_grace_period(rcu_state.name, rcu_exp_gp_seq_endval(), TPS("select"));
 512
 513	/* Schedule work for each leaf rcu_node structure. */
 514	rcu_for_each_leaf_node(rnp) {
 515		rnp->exp_need_flush = false;
 516		if (!READ_ONCE(rnp->expmask))
 517			continue; /* Avoid early boot non-existent wq. */
 518		if (!rcu_exp_par_worker_started(rnp) ||
 519		    rcu_scheduler_active != RCU_SCHEDULER_RUNNING ||
 520		    rcu_is_last_leaf_node(rnp)) {
 521			/* No worker started yet or last leaf, do direct call. */
 522			sync_rcu_exp_select_node_cpus(&rnp->rew.rew_work);
 523			continue;
 524		}
 525		sync_rcu_exp_select_cpus_queue_work(rnp);
 526		rnp->exp_need_flush = true;
 527	}
 528
 529	/* Wait for jobs (if any) to complete. */
 530	rcu_for_each_leaf_node(rnp)
 531		if (rnp->exp_need_flush)
 532			sync_rcu_exp_select_cpus_flush_work(rnp);
 533}
 534
 535/*
 536 * Wait for the expedited grace period to elapse, within time limit.
 537 * If the time limit is exceeded without the grace period elapsing,
 538 * return false, otherwise return true.
 539 */
 540static bool synchronize_rcu_expedited_wait_once(long tlimit)
 541{
 542	int t;
 543	struct rcu_node *rnp_root = rcu_get_root();
 544
 545	t = swait_event_timeout_exclusive(rcu_state.expedited_wq,
 546					  sync_rcu_exp_done_unlocked(rnp_root),
 547					  tlimit);
 548	// Workqueues should not be signaled.
 549	if (t > 0 || sync_rcu_exp_done_unlocked(rnp_root))
 550		return true;
 551	WARN_ON(t < 0);  /* workqueues should not be signaled. */
 552	return false;
 553}
 554
 555/*
 556 * Print out an expedited RCU CPU stall warning message.
 557 */
 558static void synchronize_rcu_expedited_stall(unsigned long jiffies_start, unsigned long j)
 559{
 560	int cpu;
 561	unsigned long mask;
 562	int ndetected;
 563	struct rcu_node *rnp;
 564	struct rcu_node *rnp_root = rcu_get_root();
 565
 566	if (READ_ONCE(csd_lock_suppress_rcu_stall) && csd_lock_is_stuck()) {
 567		pr_err("INFO: %s detected expedited stalls, but suppressed full report due to a stuck CSD-lock.\n", rcu_state.name);
 568		return;
 569	}
 570	pr_err("INFO: %s detected expedited stalls on CPUs/tasks: {", rcu_state.name);
 571	ndetected = 0;
 572	rcu_for_each_leaf_node(rnp) {
 573		ndetected += rcu_print_task_exp_stall(rnp);
 574		for_each_leaf_node_possible_cpu(rnp, cpu) {
 575			struct rcu_data *rdp;
 576
 577			mask = leaf_node_cpu_bit(rnp, cpu);
 578			if (!(READ_ONCE(rnp->expmask) & mask))
 579				continue;
 580			ndetected++;
 581			rdp = per_cpu_ptr(&rcu_data, cpu);
 582			pr_cont(" %d-%c%c%c%c", cpu,
 583				"O."[!!cpu_online(cpu)],
 584				"o."[!!(rdp->grpmask & rnp->expmaskinit)],
 585				"N."[!!(rdp->grpmask & rnp->expmaskinitnext)],
 586				"D."[!!data_race(rdp->cpu_no_qs.b.exp)]);
 587		}
 588	}
 589	pr_cont(" } %lu jiffies s: %lu root: %#lx/%c\n",
 590		j - jiffies_start, rcu_state.expedited_sequence, data_race(rnp_root->expmask),
 591		".T"[!!data_race(rnp_root->exp_tasks)]);
 592	if (ndetected) {
 593		pr_err("blocking rcu_node structures (internal RCU debug):");
 594		rcu_for_each_node_breadth_first(rnp) {
 595			if (rnp == rnp_root)
 596				continue; /* printed unconditionally */
 597			if (sync_rcu_exp_done_unlocked(rnp))
 598				continue;
 599			pr_cont(" l=%u:%d-%d:%#lx/%c",
 600				rnp->level, rnp->grplo, rnp->grphi, data_race(rnp->expmask),
 601				".T"[!!data_race(rnp->exp_tasks)]);
 602		}
 603		pr_cont("\n");
 604	}
 605	rcu_for_each_leaf_node(rnp) {
 606		for_each_leaf_node_possible_cpu(rnp, cpu) {
 607			mask = leaf_node_cpu_bit(rnp, cpu);
 608			if (!(READ_ONCE(rnp->expmask) & mask))
 609				continue;
 610			dump_cpu_task(cpu);
 611		}
 612		rcu_exp_print_detail_task_stall_rnp(rnp);
 613	}
 614}
 615
 616/*
 617 * Wait for the expedited grace period to elapse, issuing any needed
 618 * RCU CPU stall warnings along the way.
 619 */
 620static void synchronize_rcu_expedited_wait(void)
 621{
 622	int cpu;
 623	unsigned long j;
 624	unsigned long jiffies_stall;
 625	unsigned long jiffies_start;
 626	unsigned long mask;
 627	struct rcu_data *rdp;
 628	struct rcu_node *rnp;
 629	unsigned long flags;
 630
 631	trace_rcu_exp_grace_period(rcu_state.name, rcu_exp_gp_seq_endval(), TPS("startwait"));
 632	jiffies_stall = rcu_exp_jiffies_till_stall_check();
 633	jiffies_start = jiffies;
 634	if (tick_nohz_full_enabled() && rcu_inkernel_boot_has_ended()) {
 635		if (synchronize_rcu_expedited_wait_once(1))
 636			return;
 637		rcu_for_each_leaf_node(rnp) {
 638			raw_spin_lock_irqsave_rcu_node(rnp, flags);
 639			mask = READ_ONCE(rnp->expmask);
 640			for_each_leaf_node_cpu_mask(rnp, cpu, mask) {
 641				rdp = per_cpu_ptr(&rcu_data, cpu);
 642				if (rdp->rcu_forced_tick_exp)
 643					continue;
 644				rdp->rcu_forced_tick_exp = true;
 645				if (cpu_online(cpu))
 646					tick_dep_set_cpu(cpu, TICK_DEP_BIT_RCU_EXP);
 647			}
 648			raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
 649		}
 650		j = READ_ONCE(jiffies_till_first_fqs);
 651		if (synchronize_rcu_expedited_wait_once(j + HZ))
 652			return;
 653	}
 654
 655	for (;;) {
 656		unsigned long j;
 657
 658		if (synchronize_rcu_expedited_wait_once(jiffies_stall))
 659			return;
 660		if (rcu_stall_is_suppressed())
 661			continue;
 662
 663		nbcon_cpu_emergency_enter();
 664
 665		j = jiffies;
 666		rcu_stall_notifier_call_chain(RCU_STALL_NOTIFY_EXP, (void *)(j - jiffies_start));
 667		trace_rcu_stall_warning(rcu_state.name, TPS("ExpeditedStall"));
 668		synchronize_rcu_expedited_stall(jiffies_start, j);
 669		jiffies_stall = 3 * rcu_exp_jiffies_till_stall_check() + 3;
 670
 671		nbcon_cpu_emergency_exit();
 672
 673		panic_on_rcu_stall();
 674	}
 675}
 676
 677/*
 678 * Wait for the current expedited grace period to complete, and then
 679 * wake up everyone who piggybacked on the just-completed expedited
 680 * grace period.  Also update all the ->exp_seq_rq counters as needed
 681 * in order to avoid counter-wrap problems.
 682 */
 683static void rcu_exp_wait_wake(unsigned long s)
 684{
 685	struct rcu_node *rnp;
 686
 687	synchronize_rcu_expedited_wait();
 688
 689	// Switch over to wakeup mode, allowing the next GP to proceed.
 690	// End the previous grace period only after acquiring the mutex
 691	// to ensure that only one GP runs concurrently with wakeups.
 692	mutex_lock(&rcu_state.exp_wake_mutex);
 693	rcu_exp_gp_seq_end();
 694	trace_rcu_exp_grace_period(rcu_state.name, s, TPS("end"));
 695
 696	rcu_for_each_node_breadth_first(rnp) {
 697		if (ULONG_CMP_LT(READ_ONCE(rnp->exp_seq_rq), s)) {
 698			spin_lock(&rnp->exp_lock);
 699			/* Recheck, avoid hang in case someone just arrived. */
 700			if (ULONG_CMP_LT(rnp->exp_seq_rq, s))
 701				WRITE_ONCE(rnp->exp_seq_rq, s);
 702			spin_unlock(&rnp->exp_lock);
 703		}
 704		smp_mb(); /* All above changes before wakeup. */
 705		wake_up_all(&rnp->exp_wq[rcu_seq_ctr(s) & 0x3]);
 706	}
 707	trace_rcu_exp_grace_period(rcu_state.name, s, TPS("endwake"));
 708	mutex_unlock(&rcu_state.exp_wake_mutex);
 709}
 710
 711/*
 712 * Common code to drive an expedited grace period forward, used by
 713 * workqueues and mid-boot-time tasks.
 714 */
 715static void rcu_exp_sel_wait_wake(unsigned long s)
 716{
 717	/* Initialize the rcu_node tree in preparation for the wait. */
 718	sync_rcu_exp_select_cpus();
 719
 720	/* Wait and clean up, including waking everyone. */
 721	rcu_exp_wait_wake(s);
 722}
 723
 724/* Request an expedited quiescent state. */
 725static void rcu_exp_need_qs(void)
 726{
 727	lockdep_assert_irqs_disabled();
 728	ASSERT_EXCLUSIVE_WRITER_SCOPED(*this_cpu_ptr(&rcu_data.cpu_no_qs.b.exp));
 729	__this_cpu_write(rcu_data.cpu_no_qs.b.exp, true);
 730	/* Store .exp before .rcu_urgent_qs. */
 731	smp_store_release(this_cpu_ptr(&rcu_data.rcu_urgent_qs), true);
 732	set_need_resched_current();
 733}
 734
 735#ifdef CONFIG_PREEMPT_RCU
 736
 737/*
 738 * Remote handler for smp_call_function_single().  If there is an
 739 * RCU read-side critical section in effect, request that the
 740 * next rcu_read_unlock() record the quiescent state up the
 741 * ->expmask fields in the rcu_node tree.  Otherwise, immediately
 742 * report the quiescent state.
 743 */
 744static void rcu_exp_handler(void *unused)
 745{
 746	int depth = rcu_preempt_depth();
 747	unsigned long flags;
 748	struct rcu_data *rdp = this_cpu_ptr(&rcu_data);
 749	struct rcu_node *rnp = rdp->mynode;
 750	struct task_struct *t = current;
 751
 752	/*
 753	 * WARN if the CPU is unexpectedly already looking for a
 754	 * QS or has already reported one.
 755	 */
 756	ASSERT_EXCLUSIVE_WRITER_SCOPED(rdp->cpu_no_qs.b.exp);
 757	if (WARN_ON_ONCE(!(READ_ONCE(rnp->expmask) & rdp->grpmask) ||
 758			 READ_ONCE(rdp->cpu_no_qs.b.exp)))
 759		return;
 760
 761	/*
 762	 * Second, the common case of not being in an RCU read-side
 763	 * critical section.  If also enabled or idle, immediately
 764	 * report the quiescent state, otherwise defer.
 765	 */
 766	if (!depth) {
 767		if (!(preempt_count() & (PREEMPT_MASK | SOFTIRQ_MASK)) ||
 768		    rcu_is_cpu_rrupt_from_idle())
 769			rcu_report_exp_rdp(rdp);
 770		else
 771			rcu_exp_need_qs();
 772		return;
 773	}
 774
 775	/*
 776	 * Third, the less-common case of being in an RCU read-side
 777	 * critical section.  In this case we can count on a future
 778	 * rcu_read_unlock().  However, this rcu_read_unlock() might
 779	 * execute on some other CPU, but in that case there will be
 780	 * a future context switch.  Either way, if the expedited
 781	 * grace period is still waiting on this CPU, set ->deferred_qs
 782	 * so that the eventual quiescent state will be reported.
 783	 * Note that there is a large group of race conditions that
 784	 * can have caused this quiescent state to already have been
 785	 * reported, so we really do need to check ->expmask.
 786	 */
 787	if (depth > 0) {
 788		raw_spin_lock_irqsave_rcu_node(rnp, flags);
 789		if (rnp->expmask & rdp->grpmask) {
 790			WRITE_ONCE(rdp->cpu_no_qs.b.exp, true);
 791			t->rcu_read_unlock_special.b.exp_hint = true;
 792		}
 793		raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
 794		return;
 795	}
 796
 797	// Fourth and finally, negative nesting depth should not happen.
 798	WARN_ON_ONCE(1);
 799}
 800
 801/*
 802 * Scan the current list of tasks blocked within RCU read-side critical
 803 * sections, printing out the tid of each that is blocking the current
 804 * expedited grace period.
 805 */
 806static int rcu_print_task_exp_stall(struct rcu_node *rnp)
 807{
 808	unsigned long flags;
 809	int ndetected = 0;
 810	struct task_struct *t;
 811
 812	raw_spin_lock_irqsave_rcu_node(rnp, flags);
 813	if (!rnp->exp_tasks) {
 814		raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
 815		return 0;
 816	}
 817	t = list_entry(rnp->exp_tasks->prev,
 818		       struct task_struct, rcu_node_entry);
 819	list_for_each_entry_continue(t, &rnp->blkd_tasks, rcu_node_entry) {
 820		pr_cont(" P%d", t->pid);
 821		ndetected++;
 822	}
 823	raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
 824	return ndetected;
 825}
 826
 827/*
 828 * Scan the current list of tasks blocked within RCU read-side critical
 829 * sections, dumping the stack of each that is blocking the current
 830 * expedited grace period.
 831 */
 832static void rcu_exp_print_detail_task_stall_rnp(struct rcu_node *rnp)
 833{
 834	unsigned long flags;
 835	struct task_struct *t;
 836
 837	if (!rcu_exp_stall_task_details)
 838		return;
 839	raw_spin_lock_irqsave_rcu_node(rnp, flags);
 840	if (!READ_ONCE(rnp->exp_tasks)) {
 841		raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
 842		return;
 843	}
 844	t = list_entry(rnp->exp_tasks->prev,
 845		       struct task_struct, rcu_node_entry);
 846	list_for_each_entry_continue(t, &rnp->blkd_tasks, rcu_node_entry) {
 847		/*
 848		 * We could be printing a lot while holding a spinlock.
 849		 * Avoid triggering hard lockup.
 850		 */
 851		touch_nmi_watchdog();
 852		sched_show_task(t);
 853	}
 854	raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
 855}
 856
 857#else /* #ifdef CONFIG_PREEMPT_RCU */
 858
 859/* Invoked on each online non-idle CPU for expedited quiescent state. */
 860static void rcu_exp_handler(void *unused)
 861{
 862	struct rcu_data *rdp = this_cpu_ptr(&rcu_data);
 863	struct rcu_node *rnp = rdp->mynode;
 864	bool preempt_bh_enabled = !(preempt_count() & (PREEMPT_MASK | SOFTIRQ_MASK));
 865
 866	ASSERT_EXCLUSIVE_WRITER_SCOPED(rdp->cpu_no_qs.b.exp);
 867	if (!(READ_ONCE(rnp->expmask) & rdp->grpmask) ||
 868	    __this_cpu_read(rcu_data.cpu_no_qs.b.exp))
 869		return;
 870	if (rcu_is_cpu_rrupt_from_idle() ||
 871	    (IS_ENABLED(CONFIG_PREEMPT_COUNT) && preempt_bh_enabled)) {
 872		rcu_report_exp_rdp(this_cpu_ptr(&rcu_data));
 873		return;
 874	}
 875	rcu_exp_need_qs();
 876}
 877
 878/*
 879 * Because preemptible RCU does not exist, we never have to check for
 880 * tasks blocked within RCU read-side critical sections that are
 881 * blocking the current expedited grace period.
 882 */
 883static int rcu_print_task_exp_stall(struct rcu_node *rnp)
 884{
 885	return 0;
 886}
 887
 888/*
 889 * Because preemptible RCU does not exist, we never have to print out
 890 * tasks blocked within RCU read-side critical sections that are blocking
 891 * the current expedited grace period.
 892 */
 893static void rcu_exp_print_detail_task_stall_rnp(struct rcu_node *rnp)
 894{
 895}
 896
 897#endif /* #else #ifdef CONFIG_PREEMPT_RCU */
 898
 899/**
 900 * synchronize_rcu_expedited - Brute-force RCU grace period
 901 *
 902 * Wait for an RCU grace period, but expedite it.  The basic idea is to
 903 * IPI all non-idle non-nohz online CPUs.  The IPI handler checks whether
 904 * the CPU is in an RCU critical section, and if so, it sets a flag that
 905 * causes the outermost rcu_read_unlock() to report the quiescent state
 906 * for RCU-preempt or asks the scheduler for help for RCU-sched.  On the
 907 * other hand, if the CPU is not in an RCU read-side critical section,
 908 * the IPI handler reports the quiescent state immediately.
 909 *
 910 * Although this is a great improvement over previous expedited
 911 * implementations, it is still unfriendly to real-time workloads, so is
 912 * thus not recommended for any sort of common-case code.  In fact, if
 913 * you are using synchronize_rcu_expedited() in a loop, please restructure
 914 * your code to batch your updates, and then use a single synchronize_rcu()
 915 * instead.
 916 *
 917 * This has the same semantics as (but is more brutal than) synchronize_rcu().
 918 */
 919void synchronize_rcu_expedited(void)
 920{
 921	unsigned long flags;
 922	struct rcu_exp_work rew;
 923	struct rcu_node *rnp;
 924	unsigned long s;
 925
 926	RCU_LOCKDEP_WARN(lock_is_held(&rcu_bh_lock_map) ||
 927			 lock_is_held(&rcu_lock_map) ||
 928			 lock_is_held(&rcu_sched_lock_map),
 929			 "Illegal synchronize_rcu_expedited() in RCU read-side critical section");
 930
 931	/* Is the state is such that the call is a grace period? */
 932	if (rcu_blocking_is_gp()) {
 933		// Note well that this code runs with !PREEMPT && !SMP.
 934		// In addition, all code that advances grace periods runs
 935		// at process level.  Therefore, this expedited GP overlaps
 936		// with other expedited GPs only by being fully nested within
 937		// them, which allows reuse of ->gp_seq_polled_exp_snap.
 938		rcu_poll_gp_seq_start_unlocked(&rcu_state.gp_seq_polled_exp_snap);
 939		rcu_poll_gp_seq_end_unlocked(&rcu_state.gp_seq_polled_exp_snap);
 940
 941		local_irq_save(flags);
 942		WARN_ON_ONCE(num_online_cpus() > 1);
 943		rcu_state.expedited_sequence += (1 << RCU_SEQ_CTR_SHIFT);
 944		local_irq_restore(flags);
 945		return;  // Context allows vacuous grace periods.
 946	}
 947
 948	/* If expedited grace periods are prohibited, fall back to normal. */
 949	if (rcu_gp_is_normal()) {
 950		synchronize_rcu_normal();
 951		return;
 952	}
 953
 954	/* Take a snapshot of the sequence number.  */
 955	s = rcu_exp_gp_seq_snap();
 956	if (exp_funnel_lock(s))
 957		return;  /* Someone else did our work for us. */
 958
 959	/* Ensure that load happens before action based on it. */
 960	if (unlikely((rcu_scheduler_active == RCU_SCHEDULER_INIT) || !rcu_exp_worker_started())) {
 961		/* Direct call during scheduler init and early_initcalls(). */
 962		rcu_exp_sel_wait_wake(s);
 963	} else {
 964		/* Marshall arguments & schedule the expedited grace period. */
 965		rew.rew_s = s;
 966		synchronize_rcu_expedited_queue_work(&rew);
 967	}
 968
 969	/* Wait for expedited grace period to complete. */
 970	rnp = rcu_get_root();
 971	wait_event(rnp->exp_wq[rcu_seq_ctr(s) & 0x3],
 972		   sync_exp_work_done(s));
 973
 974	/* Let the next expedited grace period start. */
 975	mutex_unlock(&rcu_state.exp_mutex);
 976}
 977EXPORT_SYMBOL_GPL(synchronize_rcu_expedited);
 978
 979/*
 980 * Ensure that start_poll_synchronize_rcu_expedited() has the expedited
 981 * RCU grace periods that it needs.
 982 */
 983static void sync_rcu_do_polled_gp(struct work_struct *wp)
 984{
 985	unsigned long flags;
 986	int i = 0;
 987	struct rcu_node *rnp = container_of(wp, struct rcu_node, exp_poll_wq);
 988	unsigned long s;
 989
 990	raw_spin_lock_irqsave(&rnp->exp_poll_lock, flags);
 991	s = rnp->exp_seq_poll_rq;
 992	rnp->exp_seq_poll_rq = RCU_GET_STATE_COMPLETED;
 993	raw_spin_unlock_irqrestore(&rnp->exp_poll_lock, flags);
 994	if (s == RCU_GET_STATE_COMPLETED)
 995		return;
 996	while (!poll_state_synchronize_rcu(s)) {
 997		synchronize_rcu_expedited();
 998		if (i == 10 || i == 20)
 999			pr_info("%s: i = %d s = %lx gp_seq_polled = %lx\n", __func__, i, s, READ_ONCE(rcu_state.gp_seq_polled));
1000		i++;
1001	}
1002	raw_spin_lock_irqsave(&rnp->exp_poll_lock, flags);
1003	s = rnp->exp_seq_poll_rq;
1004	if (poll_state_synchronize_rcu(s))
1005		rnp->exp_seq_poll_rq = RCU_GET_STATE_COMPLETED;
1006	raw_spin_unlock_irqrestore(&rnp->exp_poll_lock, flags);
1007}
1008
1009/**
1010 * start_poll_synchronize_rcu_expedited - Snapshot current RCU state and start expedited grace period
1011 *
1012 * Returns a cookie to pass to a call to cond_synchronize_rcu(),
1013 * cond_synchronize_rcu_expedited(), or poll_state_synchronize_rcu(),
1014 * allowing them to determine whether or not any sort of grace period has
1015 * elapsed in the meantime.  If the needed expedited grace period is not
1016 * already slated to start, initiates that grace period.
1017 */
1018unsigned long start_poll_synchronize_rcu_expedited(void)
1019{
1020	unsigned long flags;
1021	struct rcu_data *rdp;
1022	struct rcu_node *rnp;
1023	unsigned long s;
1024
1025	s = get_state_synchronize_rcu();
1026	rdp = per_cpu_ptr(&rcu_data, raw_smp_processor_id());
1027	rnp = rdp->mynode;
1028	if (rcu_init_invoked())
1029		raw_spin_lock_irqsave(&rnp->exp_poll_lock, flags);
1030	if (!poll_state_synchronize_rcu(s)) {
1031		if (rcu_init_invoked()) {
1032			rnp->exp_seq_poll_rq = s;
1033			queue_work(rcu_gp_wq, &rnp->exp_poll_wq);
1034		}
1035	}
1036	if (rcu_init_invoked())
1037		raw_spin_unlock_irqrestore(&rnp->exp_poll_lock, flags);
1038
1039	return s;
1040}
1041EXPORT_SYMBOL_GPL(start_poll_synchronize_rcu_expedited);
1042
1043/**
1044 * start_poll_synchronize_rcu_expedited_full - Take a full snapshot and start expedited grace period
1045 * @rgosp: Place to put snapshot of grace-period state
1046 *
1047 * Places the normal and expedited grace-period states in rgosp.  This
1048 * state value can be passed to a later call to cond_synchronize_rcu_full()
1049 * or poll_state_synchronize_rcu_full() to determine whether or not a
1050 * grace period (whether normal or expedited) has elapsed in the meantime.
1051 * If the needed expedited grace period is not already slated to start,
1052 * initiates that grace period.
1053 */
1054void start_poll_synchronize_rcu_expedited_full(struct rcu_gp_oldstate *rgosp)
1055{
1056	get_state_synchronize_rcu_full(rgosp);
1057	(void)start_poll_synchronize_rcu_expedited();
1058}
1059EXPORT_SYMBOL_GPL(start_poll_synchronize_rcu_expedited_full);
1060
1061/**
1062 * cond_synchronize_rcu_expedited - Conditionally wait for an expedited RCU grace period
1063 *
1064 * @oldstate: value from get_state_synchronize_rcu(), start_poll_synchronize_rcu(), or start_poll_synchronize_rcu_expedited()
1065 *
1066 * If any type of full RCU grace period has elapsed since the earlier
1067 * call to get_state_synchronize_rcu(), start_poll_synchronize_rcu(),
1068 * or start_poll_synchronize_rcu_expedited(), just return.  Otherwise,
1069 * invoke synchronize_rcu_expedited() to wait for a full grace period.
1070 *
1071 * Yes, this function does not take counter wrap into account.
1072 * But counter wrap is harmless.  If the counter wraps, we have waited for
1073 * more than 2 billion grace periods (and way more on a 64-bit system!),
1074 * so waiting for a couple of additional grace periods should be just fine.
1075 *
1076 * This function provides the same memory-ordering guarantees that
1077 * would be provided by a synchronize_rcu() that was invoked at the call
1078 * to the function that provided @oldstate and that returned at the end
1079 * of this function.
1080 */
1081void cond_synchronize_rcu_expedited(unsigned long oldstate)
1082{
1083	if (!poll_state_synchronize_rcu(oldstate))
1084		synchronize_rcu_expedited();
1085}
1086EXPORT_SYMBOL_GPL(cond_synchronize_rcu_expedited);
1087
1088/**
1089 * cond_synchronize_rcu_expedited_full - Conditionally wait for an expedited RCU grace period
1090 * @rgosp: value from get_state_synchronize_rcu_full(), start_poll_synchronize_rcu_full(), or start_poll_synchronize_rcu_expedited_full()
1091 *
1092 * If a full RCU grace period has elapsed since the call to
1093 * get_state_synchronize_rcu_full(), start_poll_synchronize_rcu_full(),
1094 * or start_poll_synchronize_rcu_expedited_full() from which @rgosp was
1095 * obtained, just return.  Otherwise, invoke synchronize_rcu_expedited()
1096 * to wait for a full grace period.
1097 *
1098 * Yes, this function does not take counter wrap into account.
1099 * But counter wrap is harmless.  If the counter wraps, we have waited for
1100 * more than 2 billion grace periods (and way more on a 64-bit system!),
1101 * so waiting for a couple of additional grace periods should be just fine.
1102 *
1103 * This function provides the same memory-ordering guarantees that
1104 * would be provided by a synchronize_rcu() that was invoked at the call
1105 * to the function that provided @rgosp and that returned at the end of
1106 * this function.
1107 */
1108void cond_synchronize_rcu_expedited_full(struct rcu_gp_oldstate *rgosp)
1109{
1110	if (!poll_state_synchronize_rcu_full(rgosp))
1111		synchronize_rcu_expedited();
1112}
1113EXPORT_SYMBOL_GPL(cond_synchronize_rcu_expedited_full);