4.4-stable patches

added patches:
	rcu-do-rcu-gp-kthread-self-wakeup-from-softirq-and-interrupt.patch

diff --git a/queue-4.4/rcu-do-rcu-gp-kthread-self-wakeup-from-softirq-and-interrupt.patch b/queue-4.4/rcu-do-rcu-gp-kthread-self-wakeup-from-softirq-and-interrupt.patch
new file mode 100644 (file)
index 0000000..d48b09f
--- /dev/null
+++ b/queue-4.4/rcu-do-rcu-gp-kthread-self-wakeup-from-softirq-and-interrupt.patch
@@ -0,0 +1,86 @@
+From 1d1f898df6586c5ea9aeaf349f13089c6fa37903 Mon Sep 17 00:00:00 2001
+From: "Zhang, Jun" <jun.zhang@intel.com>
+Date: Tue, 18 Dec 2018 06:55:01 -0800
+Subject: rcu: Do RCU GP kthread self-wakeup from softirq and interrupt
+
+From: Zhang, Jun <jun.zhang@intel.com>
+
+commit 1d1f898df6586c5ea9aeaf349f13089c6fa37903 upstream.
+
+The rcu_gp_kthread_wake() function is invoked when it might be necessary
+to wake the RCU grace-period kthread.  Because self-wakeups are normally
+a useless waste of CPU cycles, if rcu_gp_kthread_wake() is invoked from
+this kthread, it naturally refuses to do the wakeup.
+
+Unfortunately, natural though it might be, this heuristic fails when
+rcu_gp_kthread_wake() is invoked from an interrupt or softirq handler
+that interrupted the grace-period kthread just after the final check of
+the wait-event condition but just before the schedule() call.  In this
+case, a wakeup is required, even though the call to rcu_gp_kthread_wake()
+is within the RCU grace-period kthread's context.  Failing to provide
+this wakeup can result in grace periods failing to start, which in turn
+results in out-of-memory conditions.
+
+This race window is quite narrow, but it actually did happen during real
+testing.  It would of course need to be fixed even if it was strictly
+theoretical in nature.
+
+This patch does not Cc stable because it does not apply cleanly to
+earlier kernel versions.
+
+Fixes: 48a7639ce80c ("rcu: Make callers awaken grace-period kthread")
+Reported-by: "He, Bo" <bo.he@intel.com>
+Co-developed-by: "Zhang, Jun" <jun.zhang@intel.com>
+Co-developed-by: "He, Bo" <bo.he@intel.com>
+Co-developed-by: "xiao, jin" <jin.xiao@intel.com>
+Co-developed-by: Bai, Jie A <jie.a.bai@intel.com>
+Signed-off: "Zhang, Jun" <jun.zhang@intel.com>
+Signed-off: "He, Bo" <bo.he@intel.com>
+Signed-off: "xiao, jin" <jin.xiao@intel.com>
+Signed-off: Bai, Jie A <jie.a.bai@intel.com>
+Signed-off-by: "Zhang, Jun" <jun.zhang@intel.com>
+[ paulmck: Switch from !in_softirq() to "!in_interrupt() &&
+  !in_serving_softirq() to avoid redundant wakeups and to also handle the
+  interrupt-handler scenario as well as the softirq-handler scenario that
+  actually occurred in testing. ]
+Signed-off-by: Paul E. McKenney <paulmck@linux.ibm.com>
+Link: https://lkml.kernel.org/r/CD6925E8781EFD4D8E11882D20FC406D52A11F61@SHSMSX104.ccr.corp.intel.com
+Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+
+
+---
+ kernel/rcu/tree.c |   20 ++++++++++++++------
+ 1 file changed, 14 insertions(+), 6 deletions(-)
+
+--- a/kernel/rcu/tree.c
++++ b/kernel/rcu/tree.c
+@@ -1611,15 +1611,23 @@ static int rcu_future_gp_cleanup(struct
+ }
+ 
+ /*
+- * Awaken the grace-period kthread for the specified flavor of RCU.
+- * Don't do a self-awaken, and don't bother awakening when there is
+- * nothing for the grace-period kthread to do (as in several CPUs
+- * raced to awaken, and we lost), and finally don't try to awaken
+- * a kthread that has not yet been created.
++ * Awaken the grace-period kthread.  Don't do a self-awaken (unless in
++ * an interrupt or softirq handler), and don't bother awakening when there
++ * is nothing for the grace-period kthread to do (as in several CPUs raced
++ * to awaken, and we lost), and finally don't try to awaken a kthread that
++ * has not yet been created.  If all those checks are passed, track some
++ * debug information and awaken.
++ *
++ * So why do the self-wakeup when in an interrupt or softirq handler
++ * in the grace-period kthread's context?  Because the kthread might have
++ * been interrupted just as it was going to sleep, and just after the final
++ * pre-sleep check of the awaken condition.  In this case, a wakeup really
++ * is required, and is therefore supplied.
+  */
+ static void rcu_gp_kthread_wake(struct rcu_state *rsp)
+ {
+-      if (current == rsp->gp_kthread ||
++      if ((current == rsp->gp_kthread &&
++           !in_interrupt() && !in_serving_softirq()) ||
+           !READ_ONCE(rsp->gp_flags) ||
+           !rsp->gp_kthread)
+               return;

diff --git a/queue-4.4/series b/queue-4.4/series
index c047d5234803988d73054f975a51c198dd348a5f..fc56bb2c91e3f0094426d2a841c2d29b89f66f7d 100644 (file)
--- a/queue-4.4/series
+++ b/queue-4.4/series
@@ -222,3 +222,4 @@ nfs-don-t-recoalesce-on-error-in-nfs_pageio_complete_mirror.patch
 nfsd-fix-memory-corruption-caused-by-readdir.patch
 nfsd-fix-wrong-check-in-write_v4_end_grace.patch
 pm-wakeup-rework-wakeup-source-timer-cancellation.patch
+rcu-do-rcu-gp-kthread-self-wakeup-from-softirq-and-interrupt.patch