Re: [PATCH] locking: Revert switching guards to _irq_{disable,enable}()

[Boqun Feng <boqun@kernel.org>]

On Mon, Aug 24, 2026 at 12:55:23PM +0200, Peter Zijlstra wrote:
> 
> While the guards are properly nested, not all wrapped code is nice, as already
> highlighted by that fair.c hunk.
> 
> Syzbot found another instance of this pattern in posix_timer_delete(), which
> does spin_unlock_irq()+spin_lock_irq() inside scoped_guard(spinlock_irq).
> Combined with this patch, that goes sideways most spectacular.
> 
> Undo this change, until we've developed stronger tools / debug for such issues.
> 

Mainly hand-waving, but if we make _irq(), irqsave(), _disable()
__acquires() different contexts, we may be able to catch these issues at
compile time. I will explore a bit on this.

> Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>

Acked-by: Boqun Feng <boqun@kernel.org>

Regards,
Boqun

> ---
>  include/linux/spinlock.h |   26 ++++++++++++++------------
>  kernel/sched/fair.c      |   12 ++++++------
>  2 files changed, 20 insertions(+), 18 deletions(-)
> 
> --- a/include/linux/spinlock.h
> +++ b/include/linux/spinlock.h
> @@ -572,12 +572,12 @@ DECLARE_LOCK_GUARD_1_ATTRS(raw_spinlock_
>  #define class_raw_spinlock_nested_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(raw_spinlock_nested, _T)
>  
>  DEFINE_LOCK_GUARD_1(raw_spinlock_irq, raw_spinlock_t,
> -		    raw_spin_lock_irq_disable(_T->lock),
> -		    raw_spin_unlock_irq_enable(_T->lock))
> +		    raw_spin_lock_irq(_T->lock),
> +		    raw_spin_unlock_irq(_T->lock))
>  DECLARE_LOCK_GUARD_1_ATTRS(raw_spinlock_irq, __acquires(_T), __releases(*(raw_spinlock_t **)_T))
>  #define class_raw_spinlock_irq_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(raw_spinlock_irq, _T)
>  
> -DEFINE_LOCK_GUARD_1_COND(raw_spinlock_irq, _try, raw_spin_trylock_irq_disable(_T->lock))
> +DEFINE_LOCK_GUARD_1_COND(raw_spinlock_irq, _try, raw_spin_trylock_irq(_T->lock))
>  DECLARE_LOCK_GUARD_1_ATTRS(raw_spinlock_irq_try, __acquires(_T), __releases(*(raw_spinlock_t **)_T))
>  #define class_raw_spinlock_irq_try_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(raw_spinlock_irq_try, _T)
>  
> @@ -592,13 +592,14 @@ DECLARE_LOCK_GUARD_1_ATTRS(raw_spinlock_
>  #define class_raw_spinlock_bh_try_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(raw_spinlock_bh_try, _T)
>  
>  DEFINE_LOCK_GUARD_1(raw_spinlock_irqsave, raw_spinlock_t,
> -		    raw_spin_lock_irq_disable(_T->lock),
> -		    raw_spin_unlock_irq_enable(_T->lock))
> +		    raw_spin_lock_irqsave(_T->lock, _T->flags),
> +		    raw_spin_unlock_irqrestore(_T->lock, _T->flags),
> +		    unsigned long flags)
>  DECLARE_LOCK_GUARD_1_ATTRS(raw_spinlock_irqsave, __acquires(_T), __releases(*(raw_spinlock_t **)_T))
>  #define class_raw_spinlock_irqsave_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(raw_spinlock_irqsave, _T)
>  
>  DEFINE_LOCK_GUARD_1_COND(raw_spinlock_irqsave, _try,
> -			 raw_spin_trylock_irq_disable(_T->lock))
> +			 raw_spin_trylock_irqsave(_T->lock, _T->flags))
>  DECLARE_LOCK_GUARD_1_ATTRS(raw_spinlock_irqsave_try, __acquires(_T), __releases(*(raw_spinlock_t **)_T))
>  #define class_raw_spinlock_irqsave_try_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(raw_spinlock_irqsave_try, _T)
>  
> @@ -617,13 +618,13 @@ DECLARE_LOCK_GUARD_1_ATTRS(spinlock_try,
>  #define class_spinlock_try_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(spinlock_try, _T)
>  
>  DEFINE_LOCK_GUARD_1(spinlock_irq, spinlock_t,
> -		    spin_lock_irq_disable(_T->lock),
> -		    spin_unlock_irq_enable(_T->lock))
> +		    spin_lock_irq(_T->lock),
> +		    spin_unlock_irq(_T->lock))
>  DECLARE_LOCK_GUARD_1_ATTRS(spinlock_irq, __acquires(_T), __releases(*(spinlock_t **)_T))
>  #define class_spinlock_irq_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(spinlock_irq, _T)
>  
>  DEFINE_LOCK_GUARD_1_COND(spinlock_irq, _try,
> -			 spin_trylock_irq_disable(_T->lock))
> +			 spin_trylock_irq(_T->lock))
>  DECLARE_LOCK_GUARD_1_ATTRS(spinlock_irq_try, __acquires(_T), __releases(*(spinlock_t **)_T))
>  #define class_spinlock_irq_try_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(spinlock_irq_try, _T)
>  
> @@ -639,13 +640,14 @@ DECLARE_LOCK_GUARD_1_ATTRS(spinlock_bh_t
>  #define class_spinlock_bh_try_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(spinlock_bh_try, _T)
>  
>  DEFINE_LOCK_GUARD_1(spinlock_irqsave, spinlock_t,
> -		    spin_lock_irq_disable(_T->lock),
> -		    spin_unlock_irq_enable(_T->lock))
> +		    spin_lock_irqsave(_T->lock, _T->flags),
> +		    spin_unlock_irqrestore(_T->lock, _T->flags),
> +		    unsigned long flags)
>  DECLARE_LOCK_GUARD_1_ATTRS(spinlock_irqsave, __acquires(_T), __releases(*(spinlock_t **)_T))
>  #define class_spinlock_irqsave_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(spinlock_irqsave, _T)
>  
>  DEFINE_LOCK_GUARD_1_COND(spinlock_irqsave, _try,
> -			 spin_trylock_irq_disable(_T->lock))
> +			 spin_trylock_irqsave(_T->lock, _T->flags))
>  DECLARE_LOCK_GUARD_1_ATTRS(spinlock_irqsave_try, __acquires(_T), __releases(*(spinlock_t **)_T))
>  #define class_spinlock_irqsave_try_constructor(_T) WITH_LOCK_GUARD_1_ATTRS(spinlock_irqsave_try, _T)
>  
> --- a/kernel/sched/fair.c
> +++ b/kernel/sched/fair.c
> @@ -7253,7 +7253,7 @@ static bool distribute_cfs_runtime(struc
>   * period the timer is deactivated until scheduling resumes; cfs_b->idle is
>   * used to track this state.
>   */
> -static int do_sched_cfs_period_timer(struct cfs_bandwidth *cfs_b, int overrun)
> +static int do_sched_cfs_period_timer(struct cfs_bandwidth *cfs_b, int overrun, unsigned long flags)
>  	__must_hold(&cfs_b->lock)
>  {
>  	int throttled;
> @@ -7288,10 +7288,10 @@ static int do_sched_cfs_period_timer(str
>  	 * This check is repeated as we release cfs_b->lock while we unthrottle.
>  	 */
>  	while (throttled && cfs_b->runtime > 0) {
> -		raw_spin_unlock_irq_enable(&cfs_b->lock);
> +		raw_spin_unlock_irqrestore(&cfs_b->lock, flags);
>  		/* we can't nest cfs_b->lock while distributing bandwidth */
>  		throttled = distribute_cfs_runtime(cfs_b);
> -		raw_spin_lock_irq_disable(&cfs_b->lock);
> +		raw_spin_lock_irqsave(&cfs_b->lock, flags);
>  	}
>  
>  	/*
> @@ -7399,7 +7399,7 @@ static __always_inline void return_cfs_r
>  static void do_sched_cfs_slack_timer(struct cfs_bandwidth *cfs_b)
>  {
>  	/* confirm we're still not at a refresh boundary */
> -	scoped_guard(raw_spinlock_irq, &cfs_b->lock) {
> +	scoped_guard(raw_spinlock_irqsave, &cfs_b->lock) {
>  		u64 runtime = 0, slice = sched_cfs_bandwidth_slice();
>  
>  		cfs_b->slack_started = false;
> @@ -7484,14 +7484,14 @@ static enum hrtimer_restart sched_cfs_pe
>  	int idle = 0;
>  	int count = 0;
>  
> -	guard(raw_spinlock_irq)(&cfs_b->lock);
> +	CLASS(raw_spinlock_irqsave, cfsb_guard)(&cfs_b->lock);
>  
>  	for (;;) {
>  		overrun = hrtimer_forward_now(timer, cfs_b->period);
>  		if (!overrun)
>  			break;
>  
> -		idle = do_sched_cfs_period_timer(cfs_b, overrun);
> +		idle = do_sched_cfs_period_timer(cfs_b, overrun, cfsb_guard.flags);
>  
>  		if (++count > 3) {
>  			u64 new, old = ktime_to_ns(cfs_b->period);