Re: [PATCH v2 4/7] srcu: Add irqsave variants of the atomic SRCU readers
From: Paul E. McKenney
Date: Wed Nov 11 2026 - 15:04:30 EST
On Wed, Nov 11, 2026 at 11:58:21AM -0800, Paul E. McKenney wrote:
> On Wed, Nov 11, 2026 at 09:59:46AM -0500, Mathieu Desnoyers wrote:
> > synchronize_srcu_atomic() may be invoked with interrupts disabled, for
> > example under a raw spinlock. Its kerneldoc then requires every reader
> > of that srcu_struct to disable interrupts too. srcu_read_lock_atomic()
> > only disables preemption, so such a reader has to disable interrupts
> > itself around it.
> >
> > Add srcu_read_lock_atomic_irqsave() and
> > srcu_read_unlock_atomic_irqrestore(). They disable interrupts instead
> > of preemption, and keep the interrupt state in a flags argument, so
> > they are macros. Both forms share the rest of the reader through
> > __srcu_read_lock_atomic() and __srcu_read_unlock_atomic().
> >
> > Suggested-by: Paul E. McKenney <paulmck@xxxxxxxxxx>
> > Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@xxxxxxxxxxxx>
>
> Reviewed-by: Paul E. McKenney <paulmck@xxxxxxxxxx>
>
> (Smoke tests passed as well.)
Aside from this in the console output:
rcu_torture_nmi_cleanup: nmi_readers set but no reader ever ran in NMI, so NMI readers went untested (no PMU, or NMIs unavailable here).
Looking into it.
Thanx, Paul
> > ---
> > include/linux/srcu.h | 100 ++++++++++++++++++++++++++++++++-----------
> > 1 file changed, 75 insertions(+), 25 deletions(-)
> >
> > diff --git a/include/linux/srcu.h b/include/linux/srcu.h
> > index e3b541ceb8dd..11e9ad914a71 100644
> > --- a/include/linux/srcu.h
> > +++ b/include/linux/srcu.h
> > @@ -357,31 +357,15 @@ static inline int srcu_read_lock(struct srcu_struct *ssp)
> > return retval;
> > }
> >
> > -/**
> > - * srcu_read_lock_atomic - register a new reader promising an atomic section
> > - * @ssp: srcu_struct in which to register the new reader.
> > - *
> > - * As srcu_read_lock(), but the caller promises that the read-side
> > - * critical section never sleeps and never blocks on anything which
> > - * may itself depend on memory allocation to make progress. Preemption
> > - * is disabled for the duration, which both enforces that promise (any
> > - * sleepable call in the section will splat on every configuration)
> > - * and bounds the section so that the update side may spin rather
> > - * than sleep when waiting for readers: see synchronize_srcu_atomic().
> > - *
> > - * The lock and matching srcu_read_unlock_atomic() must be invoked on
> > - * the same CPU, from the same context; passing the return value to
> > - * another task is not permitted for this flavor.
> > - *
> > - * This function is NMI-safe, in a manner similar to
> > - * srcu_read_lock_nmisafe().
> > +/*
> > + * Register an atomic-section reader. The caller has disabled preemption,
> > + * or interrupts.
> > */
> > -static inline int srcu_read_lock_atomic(struct srcu_struct *ssp)
> > +static inline int __srcu_read_lock_atomic(struct srcu_struct *ssp)
> > __acquires_shared(ssp)
> > {
> > int retval;
> >
> > - preempt_disable();
> > /*
> > * Arm might_sleep() to catch even a *potentially* sleeping call
> > * in the section, not just an actual schedule: the atomic-domain
> > @@ -406,6 +390,50 @@ static inline int srcu_read_lock_atomic(struct srcu_struct *ssp)
> > return retval;
> > }
> >
> > +/**
> > + * srcu_read_lock_atomic - register a new reader promising an atomic section
> > + * @ssp: srcu_struct in which to register the new reader.
> > + *
> > + * As srcu_read_lock(), but the caller promises that the read-side
> > + * critical section never sleeps and never blocks on anything which
> > + * may itself depend on memory allocation to make progress. Preemption
> > + * is disabled for the duration, which both enforces that promise (any
> > + * sleepable call in the section will splat on every configuration)
> > + * and bounds the section so that the update side may spin rather
> > + * than sleep when waiting for readers: see synchronize_srcu_atomic().
> > + *
> > + * The lock and matching srcu_read_unlock_atomic() must be invoked on
> > + * the same CPU, from the same context; passing the return value to
> > + * another task is not permitted for this flavor.
> > + *
> > + * This function is NMI-safe, in a manner similar to
> > + * srcu_read_lock_nmisafe().
> > + */
> > +static inline int srcu_read_lock_atomic(struct srcu_struct *ssp)
> > + __acquires_shared(ssp)
> > +{
> > + preempt_disable();
> > + return __srcu_read_lock_atomic(ssp);
> > +}
> > +
> > +/**
> > + * srcu_read_lock_atomic_irqsave - register an atomic reader, interrupts off
> > + * @ssp: srcu_struct in which to register the new reader.
> > + * @flags: interrupt state to restore at srcu_read_unlock_atomic_irqrestore().
> > + *
> > + * As srcu_read_lock_atomic(), but with interrupts disabled for the
> > + * duration instead of preemption. Use it when synchronize_srcu_atomic()
> > + * may be invoked with interrupts disabled for this srcu_struct: its
> > + * readers must then disable interrupts too.
> > + *
> > + * Returns the index to pass to srcu_read_unlock_atomic_irqrestore().
> > + */
> > +#define srcu_read_lock_atomic_irqsave(ssp, flags) \
> > +({ \
> > + local_irq_save(flags); \
> > + __srcu_read_lock_atomic((ssp)); \
> > +})
> > +
> > /**
> > * srcu_read_lock_fast - register a new reader for an SRCU-protected structure.
> > * @ssp: srcu_struct in which to register the new reader.
> > @@ -598,12 +626,11 @@ static inline void srcu_read_unlock(struct srcu_struct *ssp, int idx)
> > __srcu_read_unlock(ssp, idx);
> > }
> >
> > -/**
> > - * srcu_read_unlock_atomic - unregister an atomic-section reader
> > - * @ssp: srcu_struct from which to unregister the old reader.
> > - * @idx: return value from corresponding srcu_read_lock_atomic().
> > +/*
> > + * Unregister an atomic-section reader. The caller then enables preemption,
> > + * or interrupts, again.
> > */
> > -static inline void srcu_read_unlock_atomic(struct srcu_struct *ssp, int idx)
> > +static inline void __srcu_read_unlock_atomic(struct srcu_struct *ssp, int idx)
> > __releases_shared(ssp)
> > {
> > WARN_ON_ONCE(idx & ~0x1);
> > @@ -612,9 +639,32 @@ static inline void srcu_read_unlock_atomic(struct srcu_struct *ssp, int idx)
> > __srcu_read_unlock_nmisafe(ssp, idx);
> > if (in_task())
> > non_block_end();
> > +}
> > +
> > +/**
> > + * srcu_read_unlock_atomic - unregister an atomic-section reader
> > + * @ssp: srcu_struct from which to unregister the old reader.
> > + * @idx: return value from corresponding srcu_read_lock_atomic().
> > + */
> > +static inline void srcu_read_unlock_atomic(struct srcu_struct *ssp, int idx)
> > + __releases_shared(ssp)
> > +{
> > + __srcu_read_unlock_atomic(ssp, idx);
> > preempt_enable();
> > }
> >
> > +/**
> > + * srcu_read_unlock_atomic_irqrestore - unregister an irqsave atomic reader
> > + * @ssp: srcu_struct from which to unregister the old reader.
> > + * @idx: return value from corresponding srcu_read_lock_atomic_irqsave().
> > + * @flags: interrupt state saved by srcu_read_lock_atomic_irqsave().
> > + */
> > +#define srcu_read_unlock_atomic_irqrestore(ssp, idx, flags) \
> > +do { \
> > + __srcu_read_unlock_atomic((ssp), (idx)); \
> > + local_irq_restore(flags); \
> > +} while (0)
> > +
> > /**
> > * srcu_read_unlock_fast - unregister a old reader from an SRCU-protected structure.
> > * @ssp: srcu_struct in which to unregister the old reader.
> > --
> > 2.47.3
> >