Hi Peter,

This is a follow-up for Lyude's work [1]. After learning the current
preempt_count() usage and how ARM64 handle this, I came up with this
series that could resolve your feedback [2]. The basic idea is based on:

1) preempt_count() previously already masks our NEED_RESCHED bit, so the
   effective bits is 31bits
2) with a 64bit preempt count implementation (as in your PREEMPT_LONG
   proposal), the effective bits that record "whether we CAN preempt or
   not" still fit in 32bit (i.e. an int)

as a result, I don't think we need to change the existing
preempt_count() API, but rather keep "32bit vs 64bit" as an
implementation detail. This saves us the need to change the printk code
for preempt_count().

v1: https://lore.kernel.org/rust-for-linux/20260508042111.24358-1-boqun@kernel.org/

Changes since v1:

* Rename PREEMPT_COUNT_64BIT to HAS_SEPARATE_PREEMPT_RESCHED_BITS per
  Mark Rutland.
* Add s390's support for HAS_SEPARATE_PREEMPT_RESCHED_BITS for Heiko
  Carstens, thank you!
* Reorder patch #1 and #2 per Steven Rostedt.
* Keep the NMI count warning per Steven Rostedt and Joel Fernandes.
* Fix an race between interrupt disabling and softirq reported by
  sashiko (see the changes in __irq_exit_rcu()).
* Add Context Analysis annotations for the newly introduced API.
* Sync the preempt bits changes to BPF tests.

I would like to target this changes for 7.2 if possible.

[1]: https://lore.kernel.org/all/20260121223933.1568682-1-lyude@redhat.com/
[2]: https://lore.kernel.org/all/20260204111234.GA3031506@noisy.programming.kicks-ass.net/

Regards,
Boqun

Boqun Feng (8):
  preempt: Introduce HARDIRQ_DISABLE_BITS
  preempt: Introduce __preempt_count_{sub, add}_return()
  irq & spin_lock: Add counted interrupt disabling/enabling
  locking: Switch to _irq_{disable,enable}() variants in cleanup guards
  sched: Remove the unused preempt_offset parameter of __cant_sleep()
  sched: Avoid signed comparison of preempt_count() in __cant_migrate()
  preempt: Introduce HAS_SEPARATE_PREEMPT_RESCHED_BITS
  arm64: sched/preempt: Enable HAS_SEPARATE_PREEMPT_RESCHED_BITS

Heiko Carstens (1):
  s390/preempt: Enable HAS_SEPARATE_PREEMPT_RESCHED_BITS

Joel Fernandes (1):
  preempt: Track NMI nesting to separate per-CPU counter

Lyude Paul (2):
  openrisc: Include <linux/cpumask.h> in smp.h
  irq: Add KUnit test for refcounted interrupt enable/disable

 arch/arm64/Kconfig                            |   1 +
 arch/arm64/include/asm/preempt.h              |  18 +++
 arch/openrisc/include/asm/smp.h               |   2 +
 arch/s390/Kconfig                             |   1 +
 arch/s390/include/asm/lowcore.h               |  13 ++-
 arch/s390/include/asm/preempt.h               |  49 ++++----
 arch/x86/Kconfig                              |   1 +
 arch/x86/include/asm/preempt.h                |  61 +++++++---
 arch/x86/kernel/cpu/common.c                  |   2 +-
 include/asm-generic/preempt.h                 |  14 +++
 include/linux/hardirq.h                       |  43 ++++++-
 include/linux/interrupt_rc.h                  |  65 +++++++++++
 include/linux/kernel.h                        |   4 +-
 include/linux/preempt.h                       |  35 ++++--
 include/linux/spinlock.h                      |  48 +++++---
 include/linux/spinlock_api_smp.h              |  41 +++++++
 include/linux/spinlock_api_up.h               |  16 +++
 include/linux/spinlock_rt.h                   |  18 +++
 kernel/Kconfig.preempt                        |   4 +
 kernel/irq/Makefile                           |   1 +
 kernel/irq/refcount_interrupt_test.c          | 109 ++++++++++++++++++
 kernel/locking/spinlock.c                     |  29 +++++
 kernel/sched/core.c                           |  18 ++-
 kernel/softirq.c                              |  22 +++-
 lib/locking-selftest.c                        |   2 +-
 .../testing/selftests/bpf/bpf_experimental.h  |   7 +-
 26 files changed, 544 insertions(+), 80 deletions(-)
 create mode 100644 include/linux/interrupt_rc.h
 create mode 100644 kernel/irq/refcount_interrupt_test.c

-- 
2.50.1 (Apple Git-155)

On Tue, May 26, 2026 at 08:21:36AM -0700, Boqun Feng wrote:
> Hi Peter,
> 
> This is a follow-up for Lyude's work [1]. After learning the current
> preempt_count() usage and how ARM64 handle this, I came up with this
> series that could resolve your feedback [2]. The basic idea is based on:
> 
> 1) preempt_count() previously already masks our NEED_RESCHED bit, so the
>    effective bits is 31bits
> 2) with a 64bit preempt count implementation (as in your PREEMPT_LONG
>    proposal), the effective bits that record "whether we CAN preempt or
>    not" still fit in 32bit (i.e. an int)
> 
> as a result, I don't think we need to change the existing
> preempt_count() API, but rather keep "32bit vs 64bit" as an
> implementation detail. This saves us the need to change the printk code
> for preempt_count().

> 
> v1: https://lore.kernel.org/rust-for-linux/20260508042111.24358-1-boqun@kernel.org/
> 
> Changes since v1:
> 
> * Rename PREEMPT_COUNT_64BIT to HAS_SEPARATE_PREEMPT_RESCHED_BITS per
>   Mark Rutland.

Blergh, so I really don't like that new name. It isn't that
PREEMPT_RESCHED is separate, it really is a 64bit preempt count.

Shashiko has a few fits, but its mostly being stupid. Although I think
it might be useful to perhaps put a WARN_ON_ONCE(in_nmi()) in
local_interrupt_disable().

Anyway, I'll re-read things again tomorrow, but I suppose this will do.

On Wed, May 27, 2026 at 06:18:44PM +0200, Peter Zijlstra wrote:
> On Tue, May 26, 2026 at 08:21:36AM -0700, Boqun Feng wrote:
> > Hi Peter,
> > 
> > This is a follow-up for Lyude's work [1]. After learning the current
> > preempt_count() usage and how ARM64 handle this, I came up with this
> > series that could resolve your feedback [2]. The basic idea is based on:
> > 
> > 1) preempt_count() previously already masks our NEED_RESCHED bit, so the
> >    effective bits is 31bits
> > 2) with a 64bit preempt count implementation (as in your PREEMPT_LONG
> >    proposal), the effective bits that record "whether we CAN preempt or
> >    not" still fit in 32bit (i.e. an int)
> > 
> > as a result, I don't think we need to change the existing
> > preempt_count() API, but rather keep "32bit vs 64bit" as an
> > implementation detail. This saves us the need to change the printk code
> > for preempt_count().
> 
> > 
> > v1: https://lore.kernel.org/rust-for-linux/20260508042111.24358-1-boqun@kernel.org/
> > 
> > Changes since v1:
> > 
> > * Rename PREEMPT_COUNT_64BIT to HAS_SEPARATE_PREEMPT_RESCHED_BITS per
> >   Mark Rutland.
> 
> Blergh, so I really don't like that new name. It isn't that
> PREEMPT_RESCHED is separate, it really is a 64bit preempt count.
> 
> Shashiko has a few fits, but its mostly being stupid. Although I think
> it might be useful to perhaps put a WARN_ON_ONCE(in_nmi()) in
> local_interrupt_disable().

Yes, that's also what I'm thinking of, and also we need to check
local_softirq_pending() in local_interrupt_enable() I think, because now
HARDIRQ_DISABLE bits being non-zero means deferring softirq. (Shashiko
also reported this as well).

> 
> Anyway, I'll re-read things again tomorrow, but I suppose this will do.
> 

Thank you!

Regards,
Boqun

On Wed, May 27, 2026 at 09:33:53AM -0700, Boqun Feng wrote:
> On Wed, May 27, 2026 at 06:18:44PM +0200, Peter Zijlstra wrote:
> > On Tue, May 26, 2026 at 08:21:36AM -0700, Boqun Feng wrote:
> > > Hi Peter,
> > > 
> > > This is a follow-up for Lyude's work [1]. After learning the current
> > > preempt_count() usage and how ARM64 handle this, I came up with this
> > > series that could resolve your feedback [2]. The basic idea is based on:
> > > 
> > > 1) preempt_count() previously already masks our NEED_RESCHED bit, so the
> > >    effective bits is 31bits
> > > 2) with a 64bit preempt count implementation (as in your PREEMPT_LONG
> > >    proposal), the effective bits that record "whether we CAN preempt or
> > >    not" still fit in 32bit (i.e. an int)
> > > 
> > > as a result, I don't think we need to change the existing
> > > preempt_count() API, but rather keep "32bit vs 64bit" as an
> > > implementation detail. This saves us the need to change the printk code
> > > for preempt_count().
> > 
> > > 
> > > v1: https://lore.kernel.org/rust-for-linux/20260508042111.24358-1-boqun@kernel.org/
> > > 
> > > Changes since v1:
> > > 
> > > * Rename PREEMPT_COUNT_64BIT to HAS_SEPARATE_PREEMPT_RESCHED_BITS per
> > >   Mark Rutland.
> > 
> > Blergh, so I really don't like that new name. It isn't that
> > PREEMPT_RESCHED is separate, it really is a 64bit preempt count.
> > 
> > Shashiko has a few fits, but its mostly being stupid. Although I think
> > it might be useful to perhaps put a WARN_ON_ONCE(in_nmi()) in
> > local_interrupt_disable().
> 
> Yes, that's also what I'm thinking of, and also we need to check
> local_softirq_pending() in local_interrupt_enable() I think, because now
> HARDIRQ_DISABLE bits being non-zero means deferring softirq. (Shashiko
> also reported this as well).
> 

After some thoughts on this, I will postpone the idea of checking of
local_softirq_pending() in local_interrupt_enable(), because that
essientially makes every interrupt enabling a point to trigger softirq,
and that's different from the current local_irq_{enable,restore}().

Regards,
Boqun

> > 
> > Anyway, I'll re-read things again tomorrow, but I suppose this will do.
> > 
> 
> Thank you!
> 
> Regards,
> Boqun