Patch "srcu: Provide ordering for CPU not involved in grace period" has been added to the 4.13-stable tree

This is a note to let you know that I've just added the patch titled

srcu: Provide ordering for CPU not involved in grace period

to the 4.13-stable tree which can be found at:
http://www.kernel.org/git/?p=linux/kernel/git/stable/stable-queue.git;a=summary

The filename of the patch is:
srcu-provide-ordering-for-cpu-not-involved-in-grace-period.patch
and it can be found in the queue-4.13 subdirectory.

If you, or anyone else, feels it should not be added to the stable tree, please let <[email protected]> know about it.

From: "Paul E. McKenney" <[email protected]>
Date: Wed, 5 Jul 2017 13:30:21 -0700
Subject: srcu: Provide ordering for CPU not involved in grace period

From: Paul E. McKenney <[email protected]>

commit 35732cf9dd38b1efb0f2f22c91c61b51337d1ac3 upstream.

Tree RCU guarantees that every online CPU has a memory barrier between any given grace period and any of that CPU's RCU read-side sections that must be ordered against that grace period. Since RCU doesn't always know where read-side critical sections are, the actual implementation guarantees order against prior and subsequent non-idle non-offline code, whether in an RCU read-side critical section or not. As a result, there does not need to be a memory barrier at the end of synchronize_rcu() and friends because the ordering internal to the grace period has ordered every CPU's post-grace-period execution against each CPU's pre-grace-period execution, again for all non-idle online CPUs.

In contrast, SRCU can have non-idle online CPUs that are completely uninvolved in a given SRCU grace period, for example, a CPU that never runs any SRCU read-side critical sections and took no part in the grace-period processing. It is in theory possible for a given synchronize_srcu()'s wakeup to be delivered to a CPU that was completely uninvolved in the prior SRCU grace period, which could mean that the code following that synchronize_srcu() would end up being unordered with respect to both the grace period and any pre-existing SRCU read-side critical sections.

This commit therefore adds an smp_mb() to the end of __synchronize_srcu(), which prevents this scenario from occurring.

---
 kernel/rcu/srcutree.c |    9 +++++++++
 1 file changed, 9 insertions(+)

@@ -896,6 +896,15 @@ static void __synchronize_srcu(struct sr
 	__call_srcu(sp, &rcu.head, wakeme_after_rcu, do_norm);
 	wait_for_completion(&rcu.completion);
 	destroy_rcu_head_on_stack(&rcu.head);
+
+	/*
+	 * Make sure that later code is ordered after the SRCU grace
+	 * period.  This pairs with the raw_spin_lock_irq_rcu_node()
+	 * in srcu_invoke_callbacks().  Unlike Tree RCU, this is needed
+	 * because the current CPU might have been totally uninvolved with
+	 * (and thus unordered against) that grace period.
+	 */
+	smp_mb();
 }
 
 /**

Patches currently in stable-queue which might be from [email protected] are

queue-4.13/srcu-provide-ordering-for-cpu-not-involved-in-grace-period.patch queue-4.13/smp-hotplug-handle-removal-correctly-in-cpuhp_store_callbacks.patch