Re: [PATCH v3 07/13] mm: enable lazy_mmu sections to nest

David Hildenbrand
2025-10-23T20:00:31Z

[...]

>
> In summary (count/enabled represent the values *after* the call):
>
> lazy_mmu_mode_enable() -> arch_enter() count=1 enabled=1
> lazy_mmu_mode_enable() -> ø count=2 enabled=1
> lazy_mmu_mode_pause() -> arch_leave() count=2 enabled=0

The arch_leave..() is expected to do a flush itself, correct?

> lazy_mmu_mode_resume() -> arch_enter() count=2 enabled=1
> lazy_mmu_mode_disable() -> arch_flush() count=1 enabled=1
> lazy_mmu_mode_disable() -> arch_leave() count=0 enabled=0
>
> Note: in_lazy_mmu_mode() is added to <linux/sched.h> to allow arch
> headers included by <linux/pgtable.h> to use it.
>
> Signed-off-by: Kevin Brodsky <kevin.brodsky@arm.com>
> ---
> Alexander Gordeev suggested that a future optimisation may need
> lazy_mmu_mode_{pause,resume}() to call distinct arch callbacks [1]. For
> now arch_{leave,enter}() are called directly, but introducing new arch
> callbacks should be straightforward.
>
> [1] https://lore.kernel.org/all/5a0818bb-75d4-47df-925c-0102f7d598f4-agordeev@linux.ibm.com/
> ---

[...]

>
> +struct lazy_mmu_state {
> + u8 count;

I would have called this "enabled_count" or "nesting_level".

> + bool enabled;

"enabled" is a bit confusing when we have lazy_mmu_mode_enable().

I'd have called this "active".

> +};
> +
> #endif /* _LINUX_MM_TYPES_TASK_H */
> diff --git a/include/linux/pgtable.h b/include/linux/pgtable.h
> index 194b2c3e7576..269225a733de 100644
> --- a/include/linux/pgtable.h
> +++ b/include/linux/pgtable.h
> @@ -228,28 +228,89 @@ static inline int pmd_dirty(pmd_t pmd)
> * of the lazy mode. So the implementation must assume preemption may be enabled
> * and cpu migration is possible; it must take steps to be robust against this.
> * (In practice, for user PTE updates, the appropriate page table lock(s) are
> - * held, but for kernel PTE updates, no lock is held). Nesting is not permitted
> - * and the mode cannot be used in interrupt context.
> + * held, but for kernel PTE updates, no lock is held). The mode cannot be used
> + * in interrupt context.
> + *
> + * The lazy MMU mode is enabled for a given block of code using:
> + *
> + * lazy_mmu_mode_enable();
> + *
> + * lazy_mmu_mode_disable();
> + *
> + * Nesting is permitted: may itself use an enable()/disable() pair.
> + * A nested call to enable() has no functional effect; however disable() causes
> + * any batched architectural state to be flushed regardless of nesting. After a
> + * call to disable(), the caller can therefore rely on all previous page table
> + * modifications to have taken effect, but the lazy MMU mode may still be
> + * enabled.
> + *
> + * In certain cases, it may be desirable to temporarily pause the lazy MMU mode.
> + * This can be done using:
> + *
> + * lazy_mmu_mode_pause();
> + *
> + * lazy_mmu_mode_resume();
> + *
> + * This sequence must only be used if the lazy MMU mode is already enabled.
> + * pause() ensures that the mode is exited regardless of the nesting level;
> + * resume() re-enters the mode at the same nesting level. must not modify
> + * the lazy MMU state (i.e. it must not call any of the lazy_mmu_mode_*
> + * helpers).
> + *
> + * in_lazy_mmu_mode() can be used to check whether the lazy MMU mode is
> + * currently enabled.
> */
> #ifdef CONFIG_ARCH_LAZY_MMU
> static inline void lazy_mmu_mode_enable(void)
> {
> - arch_enter_lazy_mmu_mode();
> + struct lazy_mmu_state *state = &current->lazy_mmu_state;
> +
> + VM_BUG_ON(state->count == U8_MAX);

No VM_BUG_ON() please.

> + /* enable() must not be called while paused */
> + VM_WARN_ON(state->count > 0 && !state->enabled);
> +
> + if (state->count == 0) {
> + arch_enter_lazy_mmu_mode();
> + state->enabled = true;
> + }
> + ++state->count;

Can do

if (state->count++ == 0) {

> }
>
> static inline void lazy_mmu_mode_disable(void)
> {
> - arch_leave_lazy_mmu_mode();
> + struct lazy_mmu_state *state = &current->lazy_mmu_state;
> +
> + VM_BUG_ON(state->count == 0);

Dito.

> + VM_WARN_ON(!state->enabled);
> +
> + --state->count;
> + if (state->count == 0) {

Can do

if (--state->count == 0) {

> + state->enabled = false;
> + arch_leave_lazy_mmu_mode();
> + } else {
> + /* Exiting a nested section */
> + arch_flush_lazy_mmu_mode();
> + }
> }
>
> static inline void lazy_mmu_mode_pause(void)
> {
> + struct lazy_mmu_state *state = &current->lazy_mmu_state;
> +
> + VM_WARN_ON(state->count == 0 || !state->enabled);
> +
> + state->enabled = false;
> arch_leave_lazy_mmu_mode();
> }
>
> static inline void lazy_mmu_mode_resume(void)
> {
> + struct lazy_mmu_state *state = &current->lazy_mmu_state;
> +
> + VM_WARN_ON(state->count == 0 || state->enabled);
> +
> arch_enter_lazy_mmu_mode();
> + state->enabled = true;
> }
> #else
> static inline void lazy_mmu_mode_enable(void) {}
> diff --git a/include/linux/sched.h b/include/linux/sched.h
> index cbb7340c5866..2862d8bf2160 100644
> --- a/include/linux/sched.h
> +++ b/include/linux/sched.h
> @@ -1441,6 +1441,10 @@ struct task_struct {
>
> struct page_frag task_frag;
>
> +#ifdef CONFIG_ARCH_LAZY_MMU
> + struct lazy_mmu_state lazy_mmu_state;
> +#endif
> +
> #ifdef CONFIG_TASK_DELAY_ACCT
> struct task_delay_info *delays;
> #endif
> @@ -1724,6 +1728,18 @@ static inline char task_state_to_char(struct task_struct *tsk)
> return task_index_to_char(task_state_index(tsk));
> }
>
> +#ifdef CONFIG_ARCH_LAZY_MMU
> +static inline bool in_lazy_mmu_mode(void)

So these functions will reveal the actual arch state, not whether
_enabled() was called.

As I can see in later patches, in interrupt context they are also
return "not in lazy mmu mode".

--
Cheers

David / dhildenb