github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-11-07 06:17:02 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

mm/huge_memory: split huge PUDs when adjusting VMA boundaries

Browse Source 
PFN mappings such as VFIO PCI BAR mappings can use PUD leaves while
allowing VMA splits at page granularity. However, vma_adjust_trans_huge()
only handles PMDs.

After faulting a writable PUD-sized VFIO BAR mapping, changing its first
page to read-only with mprotect() makes the PMD walk treat the PUD leaf
as a PMD table. Applying MADV_DONTFORK to the first PMD-sized chunk leaves
the PUD spanning two VMAs: the PMD-aligned boundary skips splitting.

Walk the page tables once at each adjusted boundary and split a huge
PUD or PMD leaf as needed. Handle PUD leaves even when the boundary is
PMD-aligned.

Fixes: f9e54c3a2f ("vfio/pci: implement huge_fault support")
Cc: stable@vger.kernel.org
Tested-by: Muhammad Usama Anjum <usama.anjum@arm.com>
Reviewed-by: Kiryl Shutsemau (Meta) <kas@kernel.org>
Link: https://patch.msgid.link/20261031-fixes_core-v3-43-d6437171ecc3@kernel.org
Signed-off-by: David Hildenbrand (Arm) <david@kernel.org>
This commit is contained in:
David Hildenbrand (Arm) 2026-10-31 10:40:12 +01:00
parent 0193e83368
commit 23e5709274
1 changed files with 60 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
mm/huge_memory.c
View File

@ -3504,16 +3504,66 @@ void split_huge_pmd_address(struct vm_area_struct *vma, unsigned long address,
__split_huge_pmd(vma, pmd, address, freeze);
}
static inline void split_huge_pmd_if_needed(struct vm_area_struct *vma, unsigned long address)
static bool pud_split_required(const struct vm_area_struct *vma,
unsigned long address)
{
if (!IS_ENABLED(CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD))
return false;
if (IS_ALIGNED(address, HPAGE_PUD_SIZE))
return false;
/*
* If the new address isn't hpage aligned and it could previously
* contain an hugepage: check if we need to split an huge pmd.
* Only selected VMAs support mapping PUDs for now. Lift the
* restriction once this changes.
*/
if (!IS_ALIGNED(address, HPAGE_PMD_SIZE) &&
range_in_vma(vma, ALIGN_DOWN(address, HPAGE_PMD_SIZE),
ALIGN(address, HPAGE_PMD_SIZE)))
split_huge_pmd_address(vma, address, false);
if (!vma_is_dax(vma) && !vma_test_any(vma, VMA_PFNMAP_BIT, VMA_MIXEDMAP_BIT))
return false;
return range_in_vma(vma, ALIGN_DOWN(address, HPAGE_PUD_SIZE),
ALIGN(address, HPAGE_PUD_SIZE));
}
static bool pmd_split_required(const struct vm_area_struct *vma,
unsigned long address)
{
if (IS_ALIGNED(address, HPAGE_PMD_SIZE))
return false;
return range_in_vma(vma, ALIGN_DOWN(address, HPAGE_PMD_SIZE),
ALIGN(address, HPAGE_PMD_SIZE));
}
static void split_huge_leaf(struct vm_area_struct *vma,
unsigned long address)
{
const bool split_pud = pud_split_required(vma, address);
const bool split_pmd = pmd_split_required(vma, address);
pgd_t *pgd;
p4d_t *p4d;
pud_t *pud;
pmd_t *pmd;
/*
* mmap, VMA and rmap write locks protect the walk; the split helpers
* take the page table locks.
*/
if (!split_pud && !split_pmd)
return;
pgd = pgd_offset(vma->vm_mm, address);
if (!pgd_present(*pgd))
return;
p4d = p4d_offset(pgd, address);
if (!p4d_present(*p4d))
return;
pud = pud_offset(p4d, address);
if (pud_leaf(*pud))
__split_huge_pud(vma, pud, address);
if (!split_pmd || !pud_present(*pud))
return;
pmd = pmd_offset(pud, address);
__split_huge_pmd(vma, pmd, address, false);
}
void vma_adjust_trans_huge(struct vm_area_struct *vma,
@ -3522,14 +3572,14 @@ void vma_adjust_trans_huge(struct vm_area_struct *vma,
struct vm_area_struct *next)
{
/* Check if we need to split start first. */
split_huge_pmd_if_needed(vma, start);
split_huge_leaf(vma, start);
/* Check if we need to split end next. */
split_huge_pmd_if_needed(vma, end);
split_huge_leaf(vma, end);
/* If we're incrementing next->vm_start, we might need to split it. */
if (next)
split_huge_pmd_if_needed(next, end);
split_huge_leaf(next, end);
}
/*