On 04/12/2025 12:52, David Hildenbrand (Red Hat) wrote:

Some comments from my side:

quoted

quoted

  static inline void arch_enter_lazy_mmu_mode(void)
  {
-    /*
-     * lazy_mmu_mode is not supposed to permit nesting. But in
practice this
-     * does happen with CONFIG_DEBUG_PAGEALLOC, where a page
allocation
-     * inside a lazy_mmu_mode section (such as zap_pte_range())
will change
-     * permissions on the linear map with apply_to_page_range(), which
-     * re-enters lazy_mmu_mode. So we tolerate nesting in our
-     * implementation. The first call to arch_leave_lazy_mmu_mode()
will
-     * flush and clear the flag such that the remainder of the work
in the
-     * outer nest behaves as if outside of lazy mmu mode. This is
safe and
-     * keeps tracking simple.
-     */
-
      set_thread_flag(TIF_LAZY_MMU);>  }

Should not platform specific changes be deferred to subsequent
patches until
nesting is completely enabled in generic first ? Although no problem
as such
but would be bit cleaner.

This could indeed be done in a separate patch. But I also don't see a
problem with updating the doc in this patch.

I think it is consistent to remove that comment in this patch, since
nesting is fully supported from this patch onwards. Subsequent patches
are cleanups/optimisations that aren't functionally required.

Patch 7 takes the same approach: add handling in the generic layer,
remove anything now superfluous from arm64.

quoted

quoted

  diff --git a/include/linux/mm_types_task.h
b/include/linux/mm_types_task.h
index a82aa80c0ba4..11bf319d78ec 100644

--- a/include/linux/mm_types_task.h
+++ b/include/linux/mm_types_task.h

@@ -88,4 +88,9 @@ struct tlbflush_unmap_batch {

  #endif
  };
  +struct lazy_mmu_state {
+    u8 enable_count;
+    u8 pause_count;
+};
+

Should not this be wrapped with CONFIG_ARCH_HAS_LAZY_MMU_MODE as the
task_struct
element 'lazy_mmu_state' is only available with the feature.

No strong opinion; the compiler will ignore it either way. And less
ifdef is good, right? :)

... and there is nothing magical in there that would result in other
dependencies. 

Agreed, #ifdef'ing types should only be done if necessary.

quoted

Besides, is a depth
of 256 really expected here ? 4 bits for each element would not be
sufficient for
a depth of 16 ?

We could indeed use something like

struct lazy_mmu_state {
    u8 enable_count : 4;
    u8 pause_count : 4;
};

but then, the individual operations on enable_count/pause_count need
more instructions.

Indeed.

Further, as discussed, this 1 additional byte barely matters given the
existing size of the task struct.

In fact it would almost certainly make no difference (depending on
randomized_struct) since almost all members in task_struct have an
alignment of at least 2.

[...]

quoted

quoted

+/**
+ * lazy_mmu_mode_pause() - Resume the lazy MMU mode.
+ *
+ * Resumes the lazy MMU mode; if it was active at the point where
the matching
+ * call to lazy_mmu_mode_pause() was made, re-enables it and calls
+ * arch_enter_lazy_mmu_mode().
+ *
+ * Must match a call to lazy_mmu_mode_pause().
+ *
+ * Has no effect if called:
+ * - While paused (inside another pause()/resume() pair)
+ * - In interrupt context
+ */
  static inline void lazy_mmu_mode_resume(void)
  {
+    struct lazy_mmu_state *state = &current->lazy_mmu_state;
+
      if (in_interrupt())
          return;
  -    arch_enter_lazy_mmu_mode();
+    VM_WARN_ON_ONCE(state->pause_count == 0);
+
+    if (--state->pause_count == 0 && state->enable_count > 0)
+        arch_enter_lazy_mmu_mode();
  }

Should not state->pause/enable_count tests and increment/decrement be
handled
inside include/linux/sched via helpers like in_lazy_mmu_mode() ? This
is will
ensure cleaner abstraction with respect to task_struct.

I don't think this is required given that this code here implements
CONFIG_ARCH_HAS_LAZY_MMU_MODE support.

Agreed, in fact I'd rather not expose helpers that should only be used
in the lazy_mmu implementation itself.

- Kevin