mm: madvise: use per_vma lock for MADV_FREE
Subsystems (3)
PATCH v2 1/1 mm: madvise: use per_vma lock for MADV_FREE
From: Barry Song <[email protected]>
MADV_FREE is another option, besides MADV_DONTNEED, for dynamic memory freeing in user-space native or Java heap memory management. For example, jemalloc can be configured to use MADV_FREE, and recent versions of the Android Java heap have also increasingly adopted MADV_FREE. Supporting per-VMA locking for MADV_FREE thus appears increasingly necessary.
We have replaced walk_page_range() with walk_page_range_vma(). Along with the proposed madvise_lock_mode by Lorenzo, the necessary infrastructure is now in place to begin exploring per-VMA locking support for MADV_FREE and potentially other madvise using walk_page_range_vma().
This patch adds support for the PGWALK_VMA_RDLOCK walk_lock mode in walk_page_range_vma(), and leverages madvise_lock_mode from madv_behavior to select the appropriate walk_lock—either mmap_lock or per-VMA lock—based on the context.
Because we now dynamically update the walk_ops->walk_lock field, we must ensure this is thread-safe. The madvise_free_walk_ops is now defined as a stack variable instead of a global constant.
---
-v2:
* Collect David's acked-by and Lorenzo's reviewed-by;
* refine changelog and code cleanup according to David and Lorenzo
include/linux/pagewalk.h | 2 ++ mm/madvise.c | 25 +++++++++++++++++++------ mm/pagewalk.c | 5 ++++- 3 files changed, 25 insertions(+), 7 deletions(-)
include/linux/pagewalk.h +2 -0
@@ -14,6 +14,8 @@ enum page_walk_lock {PGWALK_WRLOCK =1 ,/* vma is expected to be already write-locked during the walk */ PGWALK_WRLOCK_VERIFY =2 , +/* vma is expected to be already read-locked during the walk */ + PGWALK_VMA_RDLOCK_VERIFY = 3, };/**
mm/madvise.c +19 -6
@@ -777,10 +777,19 @@ static int madvise_free_pte_range(pmd_t *pmd, unsigned long addr,return 0 ; } -static const struct mm_walk_ops madvise_free_walk_ops = { - .pmd_entry = madvise_free_pte_range, - .walk_lock =PGWALK_RDLOCK , -}; +static inline enum page_walk_lock get_walk_lock (enum madvise_lock_mode mode) +{ +switch (mode) { +case MADVISE_VMA_READ_LOCK : +return PGWALK_VMA_RDLOCK_VERIFY ; +case MADVISE_MMAP_READ_LOCK : +return PGWALK_RDLOCK ; +default : +/* Other modes don't require fixing up the walk_lock */ +WARN_ON_ONCE (1 ); +return PGWALK_RDLOCK ; + } +} static int madvise_free_single_vma(struct madvise_behavior *madv_behavior, struct vm_area_struct *vma,
@@ -789,6 +798,9 @@ static int madvise_free_single_vma(struct madvise_behavior *madv_behavior,struct mm_struct *mm = vma->vm_mm;struct mmu_notifier_range range;struct mmu_gather *tlb = madv_behavior->tlb; +struct mm_walk_ops walk_ops = { + .pmd_entry = madvise_free_pte_range, + };/* MADV_FREE works for only anon vma at the moment */ if (!vma_is_anonymous (vma))
@@ -808,8 +820,9 @@ static int madvise_free_single_vma(struct madvise_behavior *madv_behavior,mmu_notifier_invalidate_range_start (&range);tlb_start_vma (tlb, vma); + walk_ops.walk_lock =get_walk_lock (madv_behavior->lock_mode);walk_page_range_vma (vma, range.start, range.end, - &madvise_free_walk_ops, tlb); + &walk_ops, tlb);tlb_end_vma (tlb, vma);mmu_notifier_invalidate_range_end (&range);return 0 ;
@@ -1655,7 +1668,6 @@ static enum madvise_lock_mode get_lock_mode(struct madvise_behavior *madv_behavicase MADV_WILLNEED :case MADV_COLD :case MADV_PAGEOUT : -case MADV_FREE :case MADV_POPULATE_READ :case MADV_POPULATE_WRITE :case MADV_COLLAPSE :
@@ -1664,6 +1676,7 @@ static enum madvise_lock_mode get_lock_mode(struct madvise_behavior *madv_behavireturn MADVISE_MMAP_READ_LOCK ;case MADV_DONTNEED :case MADV_DONTNEED_LOCKED : +case MADV_FREE :return MADVISE_VMA_READ_LOCK ;default :return MADVISE_MMAP_WRITE_LOCK ;
mm/pagewalk.c +4 -1
@@ -422,7 +422,7 @@ static inline void process_mm_walk_lock(struct mm_struct *mm, {if (walk_lock ==PGWALK_RDLOCK )mmap_assert_locked (mm); -else +else if (walk_lock !=PGWALK_VMA_RDLOCK_VERIFY )mmap_assert_write_locked (mm); }
@@ -437,6 +437,9 @@ static inline void process_vma_walk_lock(struct vm_area_struct *vma,case PGWALK_WRLOCK_VERIFY :vma_assert_write_locked (vma);break ; +case PGWALK_VMA_RDLOCK_VERIFY : +vma_assert_locked (vma); +break ;case PGWALK_RDLOCK :/* PGWALK_RDLOCK is handled by process_mm_walk_lock */ break ;
Signature · 1 line
2.39.3 (Apple Git-146)
Quoted 22 lines · On Wed, 11 Jun 2025 22:47:45 +1200 Barry Song <[email protected]> wrote:
From: Barry Song <[email protected]>
MADV_FREEis another option, besidesMADV_DONTNEED, for dynamic memory freeing in user-space native or Java heap memory management. For example, jemalloc can be configured to useMADV_FREE, and recent versions of the Android Java heap have also increasingly adoptedMADV_FREE. Supporting per-VMA locking forMADV_FREEthus appears increasingly necessary.We have replaced
walk_page_range()withwalk_page_range_vma(). Along with the proposedmadvise_lock_modeby Lorenzo, the necessary infrastructure is now in place to begin exploring per-VMA locking support forMADV_FREEand potentially other madvise usingwalk_page_range_vma().This patch adds support for the
PGWALK_VMA_RDLOCKwalk_lockmode inwalk_page_range_vma(), and leveragesmadvise_lock_modefrommadv_behaviorto select the appropriate walk_lock—eithermmap_lockor per-VMA lock—based on the context.Because we now dynamically update the
walk_ops->walk_lockfield, we must ensure this is thread-safe. Themadvise_free_walk_opsis now defined as a stack variable instead of a global constant.
Quoted 12 lines
Reviewed-by Lorenzo Stoakes <[email protected]>Cc "Liam R. Howlett" <[email protected]>Cc Vlastimil Babka <[email protected]>Cc Jann Horn <[email protected]>Cc Suren Baghdasaryan <[email protected]>Cc Lokesh Gidra <[email protected]>Cc Mike Rapoport <[email protected]>Cc Michal Hocko <[email protected]>Cc Tangquan Zheng <[email protected]>Cc Qi Zheng <[email protected]>Signed-off-by Barry Song <[email protected]>
Thanks,
SJ
[...]