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 <[email protected]> Signed-off-by: Lorenzo Stoakes (ARM) <[email protected]> --- 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
