Patch "rcu: Make rcu_cpu_starting() rely on interrupts being disabled" has been added to the 6.3-stable tree

[Sasha Levin <sashal@xxxxxxxxxx>]

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

    rcu: Make rcu_cpu_starting() rely on interrupts being disabled

to the 6.3-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:
     rcu-make-rcu_cpu_starting-rely-on-interrupts-being-d.patch
and it can be found in the queue-6.3 subdirectory.

If you, or anyone else, feels it should not be added to the stable tree,
please let <stable@xxxxxxxxxxxxxxx> know about it.



commit 75385cb2d82c3857268d1b959982e1d7fa9d6dfe
Author: Paul E. McKenney <paulmck@xxxxxxxxxx>
Date:   Thu Apr 27 10:50:47 2023 -0700

    rcu: Make rcu_cpu_starting() rely on interrupts being disabled
    
    [ Upstream commit 15d44dfa40305da1648de4bf001e91cc63148725 ]
    
    Currently, rcu_cpu_starting() is written so that it might be invoked
    with interrupts enabled.  However, it is always called when interrupts
    are disabled, either by rcu_init(), notify_cpu_starting(), or from a
    call point prior to the call to notify_cpu_starting().
    
    But why bother requiring that interrupts be disabled?  The purpose is
    to allow the rcu_data structure's ->beenonline flag to be set after all
    early processing has completed for the incoming CPU, thus allowing this
    flag to be used to determine when workqueues have been set up for the
    incoming CPU, while still allowing this flag to be used as a diagnostic
    within rcu_core().
    
    This commit therefore makes rcu_cpu_starting() rely on interrupts being
    disabled.
    
    Signed-off-by: Paul E. McKenney <paulmck@xxxxxxxxxx>
    Stable-dep-of: 401b0de3ae4f ("rcu-tasks: Stop rcu_tasks_invoke_cbs() from using never-onlined CPUs")
    Signed-off-by: Sasha Levin <sashal@xxxxxxxxxx>

diff --git a/kernel/rcu/tree.c b/kernel/rcu/tree.c
index a565dc5c54440..954a91fec912c 100644
--- a/kernel/rcu/tree.c
+++ b/kernel/rcu/tree.c
@@ -4364,15 +4364,16 @@ int rcutree_offline_cpu(unsigned int cpu)
  * Note that this function is special in that it is invoked directly
  * from the incoming CPU rather than from the cpuhp_step mechanism.
  * This is because this function must be invoked at a precise location.
+ * This incoming CPU must not have enabled interrupts yet.
  */
 void rcu_cpu_starting(unsigned int cpu)
 {
-	unsigned long flags;
 	unsigned long mask;
 	struct rcu_data *rdp;
 	struct rcu_node *rnp;
 	bool newcpu;
 
+	lockdep_assert_irqs_disabled();
 	rdp = per_cpu_ptr(&rcu_data, cpu);
 	if (rdp->cpu_started)
 		return;
@@ -4380,7 +4381,6 @@ void rcu_cpu_starting(unsigned int cpu)
 
 	rnp = rdp->mynode;
 	mask = rdp->grpmask;
-	local_irq_save(flags);
 	arch_spin_lock(&rcu_state.ofl_lock);
 	rcu_dynticks_eqs_online();
 	raw_spin_lock(&rcu_state.barrier_lock);
@@ -4399,17 +4399,16 @@ void rcu_cpu_starting(unsigned int cpu)
 	/* An incoming CPU should never be blocking a grace period. */
 	if (WARN_ON_ONCE(rnp->qsmask & mask)) { /* RCU waiting on incoming CPU? */
 		/* rcu_report_qs_rnp() *really* wants some flags to restore */
-		unsigned long flags2;
+		unsigned long flags;
 
-		local_irq_save(flags2);
+		local_irq_save(flags);
 		rcu_disable_urgency_upon_qs(rdp);
 		/* Report QS -after- changing ->qsmaskinitnext! */
-		rcu_report_qs_rnp(mask, rnp, rnp->gp_seq, flags2);
+		rcu_report_qs_rnp(mask, rnp, rnp->gp_seq, flags);
 	} else {
 		raw_spin_unlock_rcu_node(rnp);
 	}
 	arch_spin_unlock(&rcu_state.ofl_lock);
-	local_irq_restore(flags);
 	smp_mb(); /* Ensure RCU read-side usage follows above initialization. */
 }