Commit 5d6742b3 authored by Paul E. McKenney's avatar Paul E. McKenney
Browse files

rcu/nocb: Use rcu_segcblist for no-CBs CPUs 



Currently the RCU callbacks for no-CBs CPUs are queued on a series of
ad-hoc linked lists, which means that these callbacks cannot benefit
from "drive-by" grace periods, thus suffering needless delays prior
to invocation.  In addition, the no-CBs grace-period kthreads first
wait for callbacks to appear and later wait for a new grace period,
which means that callbacks appearing during a grace-period wait can
be delayed.  These delays increase memory footprint, and could even
result in an out-of-memory condition.

This commit therefore enqueues RCU callbacks from no-CBs CPUs on the
rcu_segcblist structure that is already used by non-no-CBs CPUs.  It also
restructures the no-CBs grace-period kthread to be checking for incoming
callbacks while waiting for grace periods.  Also, instead of waiting
for a new grace period, it waits for the closest grace period that will
cause some of the callbacks to be safe to invoke.  All of these changes
reduce callback latency and thus the number of outstanding callbacks,
in turn reducing the probability of an out-of-memory condition.

Signed-off-by: default avatarPaul E. McKenney <paulmck@linux.ibm.com>
parent e83e73f5

include/trace/events/rcu.h

+0 −1
Original line number Diff line number Diff line
@@ -100,7 +100,6 @@ TRACE_EVENT_RCU(rcu_grace_period, 
 * "Startedroot": Requested a nocb grace period based on root-node data.

 * "NoGPkthread": The RCU grace-period kthread has not yet started.

 * "StartWait": Start waiting for the requested grace period.

 * "ResumeWait": Resume waiting after signal.

 * "EndWait": Complete wait.

 * "Cleanup": Clean up rcu_node structure after previous GP.

 * "CleanupMore": Clean up, and another GP is needed.

kernel/rcu/rcu_segcblist.c

+12 −0
Original line number Diff line number Diff line
@@ -127,6 +127,18 @@ struct rcu_head *rcu_segcblist_first_pend_cb(struct rcu_segcblist *rsclp) 
	return NULL;

}



/*

 * Return false if there are no CBs awaiting grace periods, otherwise,

 * return true and store the nearest waited-upon grace period into *lp.

 */

bool rcu_segcblist_nextgp(struct rcu_segcblist *rsclp, unsigned long *lp)

{

	if (!rcu_segcblist_pend_cbs(rsclp))

		return false;

	*lp = rsclp->gp_seq[RCU_WAIT_TAIL];

	return true;

}



/*

 * Enqueue the specified callback onto the specified rcu_segcblist

 * structure, updating accounting as needed.  Note that the ->len

kernel/rcu/rcu_segcblist.h

+1 −0
Original line number Diff line number Diff line
@@ -89,6 +89,7 @@ bool rcu_segcblist_ready_cbs(struct rcu_segcblist *rsclp); 
bool rcu_segcblist_pend_cbs(struct rcu_segcblist *rsclp);

struct rcu_head *rcu_segcblist_first_cb(struct rcu_segcblist *rsclp);

struct rcu_head *rcu_segcblist_first_pend_cb(struct rcu_segcblist *rsclp);

bool rcu_segcblist_nextgp(struct rcu_segcblist *rsclp, unsigned long *lp);

void rcu_segcblist_enqueue(struct rcu_segcblist *rsclp,

			   struct rcu_head *rhp, bool lazy);

bool rcu_segcblist_entrain(struct rcu_segcblist *rsclp,

kernel/rcu/tree.c

+63 −53
Original line number Diff line number Diff line
@@ -1343,8 +1343,10 @@ static bool rcu_advance_cbs(struct rcu_node *rnp, struct rcu_data *rdp) 
 */

static bool __note_gp_changes(struct rcu_node *rnp, struct rcu_data *rdp)

{

	bool ret;

	bool ret = false;

	bool need_gp;

	const bool offloaded = IS_ENABLED(CONFIG_RCU_NOCB_CPU) &&

			       rcu_segcblist_is_offloaded(&rdp->cblist);



	raw_lockdep_assert_held_rcu_node(rnp);
@@ -1354,10 +1356,12 @@ static bool __note_gp_changes(struct rcu_node *rnp, struct rcu_data *rdp) 
	/* Handle the ends of any preceding grace periods first. */

	if (rcu_seq_completed_gp(rdp->gp_seq, rnp->gp_seq) ||

	    unlikely(READ_ONCE(rdp->gpwrap))) {

		ret = rcu_advance_cbs(rnp, rdp); /* Advance callbacks. */

		if (!offloaded)

			ret = rcu_advance_cbs(rnp, rdp); /* Advance CBs. */

		trace_rcu_grace_period(rcu_state.name, rdp->gp_seq, TPS("cpuend"));

	} else {

		ret = rcu_accelerate_cbs(rnp, rdp); /* Recent callbacks. */

		if (!offloaded)

			ret = rcu_accelerate_cbs(rnp, rdp); /* Recent CBs. */

	}



	/* Now handle the beginnings of any new-to-this-CPU grace periods. */
@@ -1658,6 +1662,7 @@ static void rcu_gp_cleanup(void) 
	unsigned long gp_duration;

	bool needgp = false;

	unsigned long new_gp_seq;

	bool offloaded;

	struct rcu_data *rdp;

	struct rcu_node *rnp = rcu_get_root();

	struct swait_queue_head *sq;
@@ -1723,7 +1728,9 @@ static void rcu_gp_cleanup(void) 
		needgp = true;

	}

	/* Advance CBs to reduce false positives below. */

	if (!rcu_accelerate_cbs(rnp, rdp) && needgp) {

	offloaded = IS_ENABLED(CONFIG_RCU_NOCB_CPU) &&

		    rcu_segcblist_is_offloaded(&rdp->cblist);

	if ((offloaded || !rcu_accelerate_cbs(rnp, rdp)) && needgp) {

		WRITE_ONCE(rcu_state.gp_flags, RCU_GP_FLAG_INIT);

		rcu_state.gp_req_activity = jiffies;

		trace_rcu_grace_period(rcu_state.name,
@@ -1917,7 +1924,9 @@ rcu_report_qs_rdp(int cpu, struct rcu_data *rdp) 
{

	unsigned long flags;

	unsigned long mask;

	bool needwake;

	bool needwake = false;

	const bool offloaded = IS_ENABLED(CONFIG_RCU_NOCB_CPU) &&

			       rcu_segcblist_is_offloaded(&rdp->cblist);

	struct rcu_node *rnp;



	rnp = rdp->mynode;
@@ -1944,6 +1953,7 @@ rcu_report_qs_rdp(int cpu, struct rcu_data *rdp) 
		 * This GP can't end until cpu checks in, so all of our

		 * callbacks can be processed during the next GP.

		 */

		if (!offloaded)

			needwake = rcu_accelerate_cbs(rnp, rdp);



		rcu_report_qs_rnp(mask, rnp, rnp->gp_seq, flags);
@@ -2082,7 +2092,6 @@ static void rcu_do_batch(struct rcu_data *rdp) 
	struct rcu_cblist rcl = RCU_CBLIST_INITIALIZER(rcl);

	long bl, count;



	WARN_ON_ONCE(rdp->cblist.offloaded);

	/* If no callbacks are ready, just return. */

	if (!rcu_segcblist_ready_cbs(&rdp->cblist)) {

		trace_rcu_batch_start(rcu_state.name,
@@ -2101,13 +2110,14 @@ static void rcu_do_batch(struct rcu_data *rdp) 
	 * callback counts, as rcu_barrier() needs to be conservative.

	 */

	local_irq_save(flags);

	rcu_nocb_lock(rdp);

	WARN_ON_ONCE(cpu_is_offline(smp_processor_id()));

	bl = rdp->blimit;

	trace_rcu_batch_start(rcu_state.name,

			      rcu_segcblist_n_lazy_cbs(&rdp->cblist),

			      rcu_segcblist_n_cbs(&rdp->cblist), bl);

	rcu_segcblist_extract_done_cbs(&rdp->cblist, &rcl);

	local_irq_restore(flags);

	rcu_nocb_unlock_irqrestore(rdp, flags);



	/* Invoke callbacks. */

	rhp = rcu_cblist_dequeue(&rcl);
@@ -2120,12 +2130,22 @@ static void rcu_do_batch(struct rcu_data *rdp) 
		 * Note: The rcl structure counts down from zero.

		 */

		if (-rcl.len >= bl &&

		    !rcu_segcblist_is_offloaded(&rdp->cblist) &&

		    (need_resched() ||

		     (!is_idle_task(current) && !rcu_is_callbacks_kthread())))

			break;

		if (rcu_segcblist_is_offloaded(&rdp->cblist)) {

			WARN_ON_ONCE(in_serving_softirq());

			local_bh_enable();

			lockdep_assert_irqs_enabled();

			cond_resched_tasks_rcu_qs();

			lockdep_assert_irqs_enabled();

			local_bh_disable();

		}

	}



	local_irq_save(flags);

	rcu_nocb_lock(rdp);

	count = -rcl.len;

	trace_rcu_batch_end(rcu_state.name, count, !!rcl.head, need_resched(),

			    is_idle_task(current), rcu_is_callbacks_kthread());
@@ -2153,10 +2173,11 @@ static void rcu_do_batch(struct rcu_data *rdp) 
	 */

	WARN_ON_ONCE(rcu_segcblist_empty(&rdp->cblist) != (count == 0));



	local_irq_restore(flags);

	rcu_nocb_unlock_irqrestore(rdp, flags);



	/* Re-invoke RCU core processing if there are callbacks remaining. */

	if (rcu_segcblist_ready_cbs(&rdp->cblist))

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

	    rcu_segcblist_ready_cbs(&rdp->cblist))

		invoke_rcu_core();

}
@@ -2312,7 +2333,8 @@ static __latent_entropy void rcu_core(void) 
	rcu_check_gp_start_stall(rnp, rdp, rcu_jiffies_till_stall_check());



	/* If there are callbacks ready, invoke them. */

	if (rcu_segcblist_ready_cbs(&rdp->cblist) &&

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

	    rcu_segcblist_ready_cbs(&rdp->cblist) &&

	    likely(READ_ONCE(rcu_scheduler_fully_active)))

		rcu_do_batch(rdp);
@@ -2492,10 +2514,11 @@ static void rcu_leak_callback(struct rcu_head *rhp) 
 * is expected to specify a CPU.

 */

static void

__call_rcu(struct rcu_head *head, rcu_callback_t func, int cpu, bool lazy)

__call_rcu(struct rcu_head *head, rcu_callback_t func, bool lazy)

{

	unsigned long flags;

	struct rcu_data *rdp;

	bool was_alldone;



	/* Misaligned rcu_head! */

	WARN_ON_ONCE((unsigned long)head & (sizeof(void *) - 1));
@@ -2517,29 +2540,17 @@ __call_rcu(struct rcu_head *head, rcu_callback_t func, int cpu, bool lazy) 
	rdp = this_cpu_ptr(&rcu_data);



	/* Add the callback to our list. */

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

	    rcu_segcblist_is_offloaded(&rdp->cblist) || cpu != -1) {

		int offline;



		if (cpu != -1)

			rdp = per_cpu_ptr(&rcu_data, cpu);

		if (likely(rdp->mynode)) {

			/* Post-boot, so this should be for a no-CBs CPU. */

			offline = !__call_rcu_nocb(rdp, head, lazy, flags);

			WARN_ON_ONCE(offline);

			/* Offline CPU, _call_rcu() illegal, leak callback.  */

			local_irq_restore(flags);

			return;

		}

		/*

		 * Very early boot, before rcu_init().  Initialize if needed

		 * and then drop through to queue the callback.

		 */

		WARN_ON_ONCE(cpu != -1);

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

		// This can trigger due to call_rcu() from offline CPU:

		WARN_ON_ONCE(rcu_scheduler_active != RCU_SCHEDULER_INACTIVE);

		WARN_ON_ONCE(!rcu_is_watching());

		// Very early boot, before rcu_init().  Initialize if needed

		// and then drop through to queue the callback.

		if (rcu_segcblist_empty(&rdp->cblist))

			rcu_segcblist_init(&rdp->cblist);

	}

	rcu_nocb_lock(rdp);

	was_alldone = !rcu_segcblist_pend_cbs(&rdp->cblist);

	rcu_segcblist_enqueue(&rdp->cblist, head, lazy);

	if (__is_kfree_rcu_offset((unsigned long)func))

		trace_rcu_kfree_callback(rcu_state.name, head,
@@ -2552,9 +2563,14 @@ __call_rcu(struct rcu_head *head, rcu_callback_t func, int cpu, bool lazy) 
				   rcu_segcblist_n_cbs(&rdp->cblist));



	/* Go handle any RCU core processing required. */

	if (IS_ENABLED(CONFIG_RCU_NOCB_CPU) &&

	    unlikely(rcu_segcblist_is_offloaded(&rdp->cblist))) {

		__call_rcu_nocb_wake(rdp, was_alldone, flags); /* unlocks */

	} else {

		__call_rcu_core(rdp, head, flags);

		local_irq_restore(flags);

	}

}



/**

 * call_rcu() - Queue an RCU callback for invocation after a grace period.
@@ -2593,7 +2609,7 @@ __call_rcu(struct rcu_head *head, rcu_callback_t func, int cpu, bool lazy) 
 */

void call_rcu(struct rcu_head *head, rcu_callback_t func)

{

	__call_rcu(head, func, -1, 0);

	__call_rcu(head, func, 0);

}

EXPORT_SYMBOL_GPL(call_rcu);
@@ -2606,7 +2622,7 @@ EXPORT_SYMBOL_GPL(call_rcu); 
 */

void kfree_call_rcu(struct rcu_head *head, rcu_callback_t func)

{

	__call_rcu(head, func, -1, 1);

	__call_rcu(head, func, 1);

}

EXPORT_SYMBOL_GPL(kfree_call_rcu);
@@ -2806,6 +2822,7 @@ static void rcu_barrier_func(void *unused) 
	rcu_barrier_trace(TPS("IRQ"), -1, rcu_state.barrier_sequence);

	rdp->barrier_head.func = rcu_barrier_callback;

	debug_rcu_head_queue(&rdp->barrier_head);

	rcu_nocb_lock(rdp);

	if (rcu_segcblist_entrain(&rdp->cblist, &rdp->barrier_head, 0)) {

		atomic_inc(&rcu_state.barrier_cpu_count);

	} else {
@@ -2813,6 +2830,7 @@ static void rcu_barrier_func(void *unused) 
		rcu_barrier_trace(TPS("IRQNQ"), -1,

				   rcu_state.barrier_sequence);

	}

	rcu_nocb_unlock(rdp);

}



/**
@@ -2867,19 +2885,7 @@ void rcu_barrier(void) 
		if (!cpu_online(cpu) &&

		    !rcu_segcblist_is_offloaded(&rdp->cblist))

			continue;

		if (rcu_segcblist_is_offloaded(&rdp->cblist)) {

			if (!rcu_nocb_cpu_needs_barrier(cpu)) {

				rcu_barrier_trace(TPS("OfflineNoCB"), cpu,

						   rcu_state.barrier_sequence);

			} else {

				rcu_barrier_trace(TPS("OnlineNoCB"), cpu,

						   rcu_state.barrier_sequence);

				smp_mb__before_atomic();

				atomic_inc(&rcu_state.barrier_cpu_count);

				__call_rcu(&rdp->barrier_head,

					   rcu_barrier_callback, cpu, 0);

			}

		} else if (rcu_segcblist_n_cbs(&rdp->cblist)) {

		if (rcu_segcblist_n_cbs(&rdp->cblist)) {

			rcu_barrier_trace(TPS("OnlineQ"), cpu,

					   rcu_state.barrier_sequence);

			smp_call_function_single(cpu, rcu_barrier_func, NULL, 1);
@@ -3169,10 +3175,7 @@ void rcutree_migrate_callbacks(int cpu) 
	local_irq_save(flags);

	my_rdp = this_cpu_ptr(&rcu_data);

	my_rnp = my_rdp->mynode;

	if (rcu_nocb_adopt_orphan_cbs(my_rdp, rdp, flags)) {

		local_irq_restore(flags);

		return;

	}

	rcu_nocb_lock(my_rdp); /* irqs already disabled. */

	raw_spin_lock_rcu_node(my_rnp); /* irqs already disabled. */

	/* Leverage recent GPs and set GP for new callbacks. */

	needwake = rcu_advance_cbs(my_rnp, rdp) ||
@@ -3180,9 +3183,16 @@ void rcutree_migrate_callbacks(int cpu) 
	rcu_segcblist_merge(&my_rdp->cblist, &rdp->cblist);

	WARN_ON_ONCE(rcu_segcblist_empty(&my_rdp->cblist) !=

		     !rcu_segcblist_n_cbs(&my_rdp->cblist));

	if (rcu_segcblist_is_offloaded(&my_rdp->cblist)) {

		raw_spin_unlock_rcu_node(my_rnp); /* irqs remain disabled. */

		__call_rcu_nocb_wake(my_rdp, true, flags);

	} else {

		rcu_nocb_unlock(my_rdp); /* irqs remain disabled. */

		raw_spin_unlock_irqrestore_rcu_node(my_rnp, flags);

	}

	if (needwake)

		rcu_gp_kthread_wake();

	lockdep_assert_irqs_enabled();

	WARN_ONCE(rcu_segcblist_n_cbs(&rdp->cblist) != 0 ||

		  !rcu_segcblist_empty(&rdp->cblist),

		  "rcu_cleanup_dead_cpu: Callbacks on offline CPU %d: qlen=%lu, 1stCB=%p\n",

kernel/rcu/tree.h

+8 −6
Original line number Diff line number Diff line
@@ -211,7 +211,9 @@ struct rcu_data { 
					/* CBs waiting for GP. */

	struct rcu_head **nocb_gp_tail;

	bool nocb_gp_sleep;		/* Is the nocb GP thread asleep? */

	bool nocb_gp_forced;		/* Forced nocb GP thread wakeup? */

	struct swait_queue_head nocb_gp_wq; /* For nocb kthreads to sleep on. */

	bool nocb_cb_sleep;		/* Is the nocb CB thread asleep? */

	struct task_struct *nocb_cb_kthread;

	struct rcu_data *nocb_next_cb_rdp;

					/* Next rcu_data in wakeup chain. */
@@ -421,20 +423,20 @@ static bool rcu_preempt_has_tasks(struct rcu_node *rnp); 
static bool rcu_preempt_need_deferred_qs(struct task_struct *t);

static void rcu_preempt_deferred_qs(struct task_struct *t);

static void zero_cpu_stall_ticks(struct rcu_data *rdp);

static bool rcu_nocb_cpu_needs_barrier(int cpu);

static struct swait_queue_head *rcu_nocb_gp_get(struct rcu_node *rnp);

static void rcu_nocb_gp_cleanup(struct swait_queue_head *sq);

static void rcu_init_one_nocb(struct rcu_node *rnp);

static bool __call_rcu_nocb(struct rcu_data *rdp, struct rcu_head *rhp,

			    bool lazy, unsigned long flags);

static bool rcu_nocb_adopt_orphan_cbs(struct rcu_data *my_rdp,

				      struct rcu_data *rdp,

static void __call_rcu_nocb_wake(struct rcu_data *rdp, bool was_empty,

				 unsigned long flags);

static int rcu_nocb_need_deferred_wakeup(struct rcu_data *rdp);

static void do_nocb_deferred_wakeup(struct rcu_data *rdp);

static void rcu_boot_init_nocb_percpu_data(struct rcu_data *rdp);

static void rcu_spawn_cpu_nocb_kthread(int cpu);

static void __init rcu_spawn_nocb_kthreads(void);

static void rcu_nocb_lock(struct rcu_data *rdp);

static void rcu_nocb_unlock(struct rcu_data *rdp);

static void rcu_nocb_unlock_irqrestore(struct rcu_data *rdp,

				       unsigned long flags);

#ifdef CONFIG_RCU_NOCB_CPU

static void __init rcu_organize_nocb_kthreads(void);

#endif /* #ifdef CONFIG_RCU_NOCB_CPU */

CRA Git | Maintained and supported by SUSTech CRA and CCSE