rcu/nocb: Make local rcu_nocb_lock_irqsave() safe against concurrent deoffloading

rcu_nocb_lock_irqsave() can be preempted between the call to
rcu_segcblist_is_offloaded() and the actual locking. This matters now
that rcu_core() is preemptible on PREEMPT_RT and the (de-)offloading
process can interrupt the softirq or the rcuc kthread.

As a result we may locklessly call into code that requires nocb locking.
In practice this is a problem while we accelerate callbacks on rcu_core().

Simply disabling interrupts before (instead of after) checking the NOCB
offload state fixes the issue.

Reported-and-tested-by: Valentin Schneider <[e-mail]>
Tested-by: Sebastian Andrzej Siewior <[e-mail]>
Signed-off-by: Frederic Weisbecker <[e-mail]>
Cc: Valentin Schneider <[e-mail]>
Cc: Peter Zijlstra <[e-mail]>
Cc: Sebastian Andrzej Siewior <[e-mail]>
Cc: Josh Triplett <[e-mail]>
Cc: Joel Fernandes <[e-mail]>
Cc: Boqun Feng <[e-mail]>
Cc: Neeraj Upadhyay <[e-mail]>
Cc: Uladzislau Rezki <[e-mail]>
Cc: Thomas Gleixner <[e-mail]>
Signed-off-by: Paul E. McKenney <[e-mail]>

kernel/rcu/tree.h

···
 static void rcu_lockdep_assert_cblist_protected(struct rcu_data *rdp);
 #ifdef CONFIG_RCU_NOCB_CPU
 static void __init rcu_organize_nocb_kthreads(void);
-#define rcu_nocb_lock_irqsave(rdp, flags)				\
-do {									\
-	if (!rcu_segcblist_is_offloaded(&(rdp)->cblist))		\
-		local_irq_save(flags);					\
-	else								\
-		raw_spin_lock_irqsave(&(rdp)->nocb_lock, (flags));	\
+
+/*
+ * Disable IRQs before checking offloaded state so that local
+ * locking is safe against concurrent de-offloading.
+ */
+#define rcu_nocb_lock_irqsave(rdp, flags)			\
+do {								\
+	local_irq_save(flags);					\
+	if (rcu_segcblist_is_offloaded(&(rdp)->cblist))	\
+		raw_spin_lock(&(rdp)->nocb_lock);		\
 } while (0)
 #else /* #ifdef CONFIG_RCU_NOCB_CPU */
 #define rcu_nocb_lock_irqsave(rdp, flags) local_irq_save(flags)