[PATCH v6 30/39] mm/vma: introduce vma[_flags]_is_mm_backed()
Lorenzo Stoakes (ARM)
ljs at kernel.org
Tue Oct 13 08:05:10 PDT 2026
Introduce vma[_flags]_is_mm_backed() for the purposes of identifying
mappings which are mm-managed and whose contents were placed there by core
mm's own fault path - rather than a custom ->fault handler.
Mappings not managed by core mm do not fall into this category, as they are
populated by their owner, and nor of course does memory-mapped I/O.
We exclude fixed mappings as these have a layout core mm cannot assume
ordinary fault semantics over.
hugetlb mappings are fixed mappings, but core mm owns them entirely, so
they are explicitly carved out as mm-backed, as the MADV_DODUMP check
already does.
Use this functionality to update the madvise MADV_DODUMP check to test for
this rather than open-coding it.
Also update vma_flags_can_merge() so it is written in terms of
vma_flags_is_mm_backed() - all mm-backed mappings can be merged except
hugetlb mappings, whose flags and fields do not completely describe them.
Also update __thp_vma_allowable_orders() to use vma_is_mm_backed() rather
than testing for mergeability, which is irrelevant to this function.
This replaces the VM_SPECIAL check which means it no longer checks for
VMA_IO_BIT, however this is safe as we have established the invariant that
mm-managed mappings may not set VMA_IO_BIT, so we implicitly include
these.
No functional change intended.
Acked-by: Zi Yan <ziy at nvidia.com>
Signed-off-by: Lorenzo Stoakes (ARM) <ljs at kernel.org>
---
include/linux/mm.h | 66 +++++++++++++++++++++++++++++++++++------
mm/huge_memory.c | 7 ++---
mm/madvise.c | 7 +++--
tools/testing/vma/include/dup.h | 44 +++++++++++++++++++++------
4 files changed, 100 insertions(+), 24 deletions(-)
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 70fcb7e18b50..e8d2b0e847b3 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -1701,6 +1701,54 @@ static inline bool vma_is_fixed_mapping(const struct vm_area_struct *vma)
return vma_flags_is_fixed_mapping(&vma->flags);
}
+/**
+ * vma_flags_is_mm_backed() - Do the specified VMA flags imply the mapping is
+ * backed by core mm?
+ * @flags: The VMA flags to test.
+ *
+ * An mm-backed mapping is one managed by core mm (see
+ * vma_flags_is_mm_managed()) whose contents are established by core mm's own
+ * fault path rather than a custom ->fault handler.
+ *
+ * Mappings not managed by core mm are populated by their owner, and fixed
+ * mappings may be mm-managed but have their contents established by a custom
+ * ->fault handler, so neither are mm-backed. hugetlb mappings are fixed, but
+ * core mm owns them entirely, so they are.
+ *
+ * These are the only mappings which can sensibly be merged, locked, dumped or
+ * be subject to uffd faulting, as all of these assume core mm and core mm
+ * alone manages their contents.
+ *
+ * Returns: true if the flags imply an mm-backed mapping, otherwise false.
+ */
+static inline bool vma_flags_is_mm_backed(const vma_flags_t *flags)
+{
+ /* hugetlb is a fixed mapping, but core mm owns it entirely. */
+ if (vma_flags_is_hugetlb(flags))
+ return true;
+ /*
+ * Mappings not managed by core mm are populated by their owner.
+ *
+ * Fixed mappings may be mm-managed, but their contents are established
+ * by a custom ->fault handler, so core mm cannot assume ordinary fault
+ * semantics over them.
+ */
+ return vma_flags_is_mm_managed(flags) && !vma_flags_is_fixed_mapping(flags);
+}
+
+/**
+ * vma_is_mm_backed() - Is @vma backed by core mm?
+ * @vma: The VMA to test.
+ *
+ * See vma_flags_is_mm_backed() for details.
+ *
+ * Returns: true if the VMA is mm-backed, otherwise false.
+ */
+static inline bool vma_is_mm_backed(const struct vm_area_struct *vma)
+{
+ return vma_flags_is_mm_backed(&vma->flags);
+}
+
/**
* vma_flags_can_merge() - Do the specified VMA flags permit the VMA to be
* merged with another?
@@ -1711,21 +1759,21 @@ static inline bool vma_flags_can_merge(const vma_flags_t *flags)
{
/*
* VMA merging assumes that a VMA's flags and fields completely describe
- * its state.
+ * its state, which is only the case for mm-backed mappings.
*
- * However, mappings which are not mm-managed may have established state
- * upon mapping not embodied in any attribute of the VMA.
+ * Mappings which are not mm-managed may have established state upon
+ * mapping not embodied in any attribute of the VMA.
*
* Additionally, private (CoW) PFN maps encode the source PFN of the
* range in vma->vm_pgoff, which may otherwise cause spurious merges.
*/
- if (!vma_flags_is_mm_managed(flags))
- return false;
- /* VMA explicitly marked as being unmergeable. */
- if (vma_flags_is_fixed_mapping(flags))
+ if (!vma_flags_is_mm_backed(flags))
return false;
-
- return true;
+ /*
+ * hugetlb mappings contain per-VMA state, so their flags and fields do
+ * not completely describe them.
+ */
+ return !vma_flags_is_hugetlb(flags);
}
/**
diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index 83dd63b04568..5b295a7979cd 100644
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -215,11 +215,10 @@ unsigned long __thp_vma_allowable_orders(struct vm_area_struct *vma,
* khugepaged moves data from VMAs once collapsed, after they have been
* faulted in, relying on refaulting for file-backed memory.
*
- * Mappings not managed by core mm cannot be reliably reconstructed from
- * page faults, and fixed mappings (including hugetlb) may well be
- * mm-managed - precisely the mappings which cannot be merged.
+ * Only mm-backed mappings can be reliably reconstructed from page
+ * faults, and hugetlb mappings cannot be collapsed.
*/
- if (!in_pf && !smaps && !vma_can_merge(vma))
+ if (!in_pf && !smaps && (!vma_is_mm_backed(vma) || vma_is_hugetlb(vma)))
return 0;
/*
diff --git a/mm/madvise.c b/mm/madvise.c
index 467601a8525b..3d25202db5cc 100644
--- a/mm/madvise.c
+++ b/mm/madvise.c
@@ -1578,8 +1578,11 @@ static int madvise_vma_behavior(struct madvise_behavior *madv_behavior)
new_flags |= VM_DONTDUMP;
break;
case MADV_DODUMP:
- if ((!vma_is_hugetlb(vma) && (new_flags & VM_SPECIAL)) ||
- (new_flags & VM_DROPPABLE))
+ /* Only mm-backed memory can be meaningfully dumped. */
+ if (!vma_is_mm_backed(vma))
+ return -EINVAL;
+ /* Core mm may discard droppable memory at any time. */
+ if (new_flags & VM_DROPPABLE)
return -EINVAL;
new_flags &= ~VM_DONTDUMP;
break;
diff --git a/tools/testing/vma/include/dup.h b/tools/testing/vma/include/dup.h
index 94bf818ad0e1..19ce10faa9f3 100644
--- a/tools/testing/vma/include/dup.h
+++ b/tools/testing/vma/include/dup.h
@@ -1689,23 +1689,49 @@ static inline bool vma_is_fixed_mapping(const struct vm_area_struct *vma)
return vma_flags_is_fixed_mapping(&vma->flags);
}
+static inline bool vma_flags_is_hugetlb(const vma_flags_t *flags)
+{
+ return IS_ENABLED(CONFIG_HUGETLB_PAGE) &&
+ vma_flags_test(flags, VMA_HUGETLB_BIT);
+}
+
+static inline bool vma_flags_is_mm_backed(const vma_flags_t *flags)
+{
+ /* hugetlb is a fixed mapping, but core mm owns it entirely. */
+ if (vma_flags_is_hugetlb(flags))
+ return true;
+ /*
+ * Mappings not managed by core mm are populated by their owner.
+ *
+ * Fixed mappings may be mm-managed, but their contents are established
+ * by a custom ->fault handler, so core mm cannot assume ordinary fault
+ * semantics over them.
+ */
+ return vma_flags_is_mm_managed(flags) && !vma_flags_is_fixed_mapping(flags);
+}
+
+static inline bool vma_is_mm_backed(const struct vm_area_struct *vma)
+{
+ return vma_flags_is_mm_backed(&vma->flags);
+}
+
static inline bool vma_flags_can_merge(const vma_flags_t *flags)
{
/*
* VMA merging assumes that a VMA's flags and fields completely describe
- * its state.
+ * its state, which is only the case for mm-backed mappings.
*
- * However, mappings which are not mm-managed may have established state
- * upon mapping not embodied in any attribute of the VMA.
+ * Mappings which are not mm-managed may have established state upon
+ * mapping not embodied in any attribute of the VMA.
*
* Additionally, private (CoW) PFN maps encode the source PFN of the
* range in vma->vm_pgoff, which may otherwise cause spurious merges.
*/
- if (!vma_flags_is_mm_managed(flags))
- return false;
- /* VMA explicitly marked as being unmergeable. */
- if (vma_flags_is_fixed_mapping(flags))
+ if (!vma_flags_is_mm_backed(flags))
return false;
-
- return true;
+ /*
+ * hugetlb mappings contain per-VMA state, so their flags and fields do
+ * not completely describe them.
+ */
+ return !vma_flags_is_hugetlb(flags);
}
--
2.55.0
More information about the kvm-riscv
mailing list