perf: Disable IRQs across RCU RS CS that acquires scheduler lock

The perf_lock_task_context() function disables preemption across its
RCU read-side critical section because that critical section acquires
a scheduler lock.  If there was a preemption during that RCU read-side
critical section, the rcu_read_unlock() could attempt to acquire scheduler
locks, resulting in deadlock.

However, recent optimizations to expedited grace periods mean that IPI
handlers that execute during preemptible RCU read-side critical sections
can now cause the subsequent rcu_read_unlock() to acquire scheduler locks.
Disabling preemption does nothiing to prevent these IPI handlers from
executing, so these optimizations introduced a deadlock.  In theory,
this deadlock could be avoided by pulling all wakeups and printk()s out
from rnp->lock critical sections, but in practice this would re-introduce
some RCU CPU stall warning bugs.

Given that acquiring scheduler locks entails disabling interrupts, these
deadlocks can be avoided by disabling interrupts (instead of disabling
preemption) across any RCU read-side critical that acquires scheduler
locks and holds them across the rcu_read_unlock().  This commit therefore
makes this change for perf_lock_task_context().

Reported-by: Dave Jones <davej@codemonkey.org.uk>
Reported-by: Peter Zijlstra <peterz@infradead.org>
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Stephane Eranian <eranian@gmail.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/20151104134838.GR29027@linux.vnet.ibm.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>

1 files changed, 9 insertions, 8 deletions

diff --git a/kernel/events/core.c b/kernel/events/core.c
index ea02109aee77..f8e5c443d74e 100644
--- a/kernel/events/core.c
+++ b/kernel/events/core.c
@@ -1050,13 +1050,13 @@ retry:
         /*
          * One of the few rules of preemptible RCU is that one cannot do
          * rcu_read_unlock() while holding a scheduler (or nested) lock when
-         * part of the read side critical section was preemptible -- see
+         * part of the read side critical section was irqs-enabled -- see
          * rcu_read_unlock_special().
          *
          * Since ctx->lock nests under rq->lock we must ensure the entire read
-         * side critical section is non-preemptible.
+         * side critical section has interrupts disabled.
          */
-        preempt_disable();
+        local_irq_save(*flags);
         rcu_read_lock();
         ctx = rcu_dereference(task->perf_event_ctxp[ctxn]);
         if (ctx) {
@@ -1070,21 +1070,22 @@ retry:
                  * if so.  If we locked the right context, then it
                  * can't get swapped on us any more.
                  */
-                raw_spin_lock_irqsave(&ctx->lock, *flags);
+                raw_spin_lock(&ctx->lock);
                 if (ctx != rcu_dereference(task->perf_event_ctxp[ctxn])) {
-                        raw_spin_unlock_irqrestore(&ctx->lock, *flags);
+                        raw_spin_unlock(&ctx->lock);
                         rcu_read_unlock();
-                        preempt_enable();
+                        local_irq_restore(*flags);
                         goto retry;
                 }
 
                 if (!atomic_inc_not_zero(&ctx->refcount)) {
-                        raw_spin_unlock_irqrestore(&ctx->lock, *flags);
+                        raw_spin_unlock(&ctx->lock);
                         ctx = NULL;
                 }
         }
         rcu_read_unlock();
-        preempt_enable();
+        if (!ctx)
+                local_irq_restore(*flags);
         return ctx;
 }