mm: Clear uffd-wp PTE/PMD state on mremap()
Subsystems (8)
Ryan Roberts
reviewercover mm: Clear uffd-wp PTE/PMD state on mremap()
Hi All,
This series contains a fix for a warning emitted when a uffd-registered region, which doesn't have UFFD_FEATURE_EVENT_REMAP, is mremap()ed. patch 1 describes the problem and fixes it, and patch 2 adds a selftest to verify the fix.
Thanks to Mikołaj Lenczewski who originally created the patch, which I have subsequently extended.
Applies on top of mm-unstable (f349e79bfbf3)
Thanks,
Ryan
Ryan Roberts (2):
mm: Clear uffd-wp PTE/PMD state on mremap() selftests/mm: Introduce uffd-wp-mremap regression test
include/linux/userfaultfd_k.h | 12 + mm/huge_memory.c | 12 + mm/hugetlb.c | 14 +- mm/mremap.c | 32 +- tools/testing/selftests/mm/.gitignore | 1 + tools/testing/selftests/mm/Makefile | 2 + tools/testing/selftests/mm/run_vmtests.sh | 1 + tools/testing/selftests/mm/uffd-wp-mremap.c | 380 ++++++++++++++++++++ 8 files changed, 452 insertions(+), 2 deletions(-) create mode 100644 tools/testing/selftests/mm/uffd-wp-mremap.c
--
2.43.0
Ryan Roberts
reviewerPATCH 1/2 mm: Clear uffd-wp PTE/PMD state on mremap()
When mremap()ing a memory region previously registered with userfaultfd as write-protected but without UFFD_FEATURE_EVENT_REMAP, an inconsistency in flag clearing leads to a mismatch between the vma flags (which have uffd-wp cleared) and the pte/pmd flags (which do not have uffd-wp cleared). This mismatch causes a subsequent mprotect(PROT_WRITE) to trigger a warning in page_table_check_pte_flags() due to setting the pte to writable while uffd-wp is still set.
Fix this by always explicitly clearing the uffd-wp pte/pmd flags on any such mremap() so that the values are consistent with the existing clearing of VM_UFFD_WP. Be careful to clear the logical flag regardless of its physical form; a PTE bit, a swap PTE bit, or a PTE marker. Cover PTE, huge PMD and hugetlb paths.
--- include/linux/userfaultfd_k.h | 12 ++++++++++++ mm/huge_memory.c | 12 ++++++++++++ mm/hugetlb.c | 14 +++++++++++++- mm/mremap.c | 32 +++++++++++++++++++++++++++++++- 4 files changed, 68 insertions(+), 2 deletions(-)
include/linux/userfaultfd_k.h +12 -0
@@ -247,6 +247,13 @@ static inline bool vma_can_userfault(struct vm_area_struct *vma,vma_is_shmem (vma); } +static inline bool vma_has_uffd_without_event_remap (struct vm_area_struct *vma) +{ +struct userfaultfd_ctx *uffd_ctx = vma->vm_userfaultfd_ctx.ctx; + +return uffd_ctx && (uffd_ctx->features &UFFD_FEATURE_EVENT_REMAP ) ==0 ; +} +extern int dup_userfaultfd (struct vm_area_struct *,struct list_head *);extern void dup_userfaultfd_complete (struct list_head *);void dup_userfaultfd_fail (struct list_head *);
@@ -402,6 +409,11 @@ static inline bool userfaultfd_wp_async(struct vm_area_struct *vma) return false; } +static inline bool vma_has_uffd_without_event_remap (struct vm_area_struct *vma) +{ +return false; +} +#endif /* CONFIG_USERFAULTFD */ static inline bool userfaultfd_wp_use_markers (struct vm_area_struct *vma)
mm/huge_memory.c +12 -0
@@ -2212,6 +2212,16 @@ static pmd_t move_soft_dirty_pmd(pmd_t pmd)return pmd; } +static pmd_t clear_uffd_wp_pmd (pmd_t pmd) +{ +if (pmd_present (pmd)) + pmd =pmd_clear_uffd_wp (pmd); +else if (is_swap_pmd (pmd)) + pmd =pmd_swp_clear_uffd_wp (pmd); + +return pmd; +} +bool move_huge_pmd (struct vm_area_struct *vma,unsigned long old_addr,unsigned long new_addr,pmd_t *old_pmd,pmd_t *new_pmd) {
@@ -2250,6 +2260,8 @@ bool move_huge_pmd(struct vm_area_struct *vma, unsigned long old_addr,pgtable_trans_huge_deposit (mm, new_pmd, pgtable); } pmd =move_soft_dirty_pmd (pmd); +if (vma_has_uffd_without_event_remap (vma)) + pmd =clear_uffd_wp_pmd (pmd);set_pmd_at (mm, new_addr, new_pmd, pmd);if (force_flush)flush_pmd_tlb_range (vma, old_addr, old_addr +PMD_SIZE );
mm/hugetlb.c +13 -1
@@ -5454,6 +5454,7 @@ static void move_huge_pte(struct vm_area_struct *vma, unsigned long old_addr, unsigned long new_addr, pte_t *src_pte, pte_t *dst_pte, unsigned long sz) { + bool need_clear_uffd_wp = vma_has_uffd_without_event_remap(vma);struct hstate *h =hstate_vma (vma);struct mm_struct *mm = vma->vm_mm;spinlock_t *src_ptl, *dst_ptl;
@@ -5470,7 +5471,18 @@ static void move_huge_pte(struct vm_area_struct *vma, unsigned long old_addr,spin_lock_nested (src_ptl,SINGLE_DEPTH_NESTING ); pte =huge_ptep_get_and_clear (mm, old_addr, src_pte); -set_huge_pte_at (mm, new_addr, dst_pte, pte, sz); + +if (need_clear_uffd_wp &&pte_marker_uffd_wp (pte)) +huge_pte_clear (mm, new_addr, dst_pte, sz); +else { +if (need_clear_uffd_wp) { +if (pte_present (pte)) + pte =huge_pte_clear_uffd_wp (pte); +else if (is_swap_pte (pte)) + pte =pte_swp_clear_uffd_wp (pte); + } +set_huge_pte_at (mm, new_addr, dst_pte, pte, sz); + }if (src_ptl != dst_ptl)spin_unlock (src_ptl);
mm/mremap.c +31 -1
@@ -138,6 +138,7 @@ static int move_ptes(struct vm_area_struct *vma, pmd_t *old_pmd, struct vm_area_struct *new_vma, pmd_t *new_pmd, unsigned long new_addr, bool need_rmap_locks) { + bool need_clear_uffd_wp = vma_has_uffd_without_event_remap(vma);struct mm_struct *mm = vma->vm_mm;pte_t *old_pte, *new_pte, pte;pmd_t dummy_pmdval;
@@ -216,7 +217,18 @@ static int move_ptes(struct vm_area_struct *vma, pmd_t *old_pmd, force_flush = true; pte =move_pte (pte, old_addr, new_addr); pte =move_soft_dirty_pte (pte); -set_pte_at (mm, new_addr, new_pte, pte); + +if (need_clear_uffd_wp &&pte_marker_uffd_wp (pte)) +pte_clear (mm, new_addr, new_pte); +else { +if (need_clear_uffd_wp) { +if (pte_present (pte)) + pte =pte_clear_uffd_wp (pte); +else if (is_swap_pte (pte)) + pte =pte_swp_clear_uffd_wp (pte); + } +set_pte_at (mm, new_addr, new_pte, pte); + } }arch_leave_lazy_mmu_mode ();
@@ -278,6 +290,15 @@ static bool move_normal_pmd(struct vm_area_struct *vma, unsigned long old_addr,if (WARN_ON_ONCE (!pmd_none (*new_pmd)))return false; +/* If this pmd belongs to a uffd vma with remap events disabled, we need +* to ensure that the uffd-wp state is cleared from all pgtables. This +* means recursing into lower page tables in move_page_tables(), and we +* can reuse the existing code if we simply treat the entry as "not +* moved". +*/ +if (vma_has_uffd_without_event_remap (vma)) +return false; +/* * We don't have to worry about the ordering of src and dst * ptlocks because exclusive mmap_lock prevents deadlock.
@@ -333,6 +354,15 @@ static bool move_normal_pud(struct vm_area_struct *vma, unsigned long old_addr,if (WARN_ON_ONCE (!pud_none (*new_pud)))return false; +/* If this pud belongs to a uffd vma with remap events disabled, we need +* to ensure that the uffd-wp state is cleared from all pgtables. This +* means recursing into lower page tables in move_page_tables(), and we +* can reuse the existing code if we simply treat the entry as "not +* moved". +*/ +if (vma_has_uffd_without_event_remap (vma)) +return false; +/* * We don't have to worry about the ordering of src and dst * ptlocks because exclusive mmap_lock prevents deadlock.
Signature · 1 line
2.43.0
Ryan Roberts
reviewerHi Peter, David,
Quoted 8 lines · Ryan Roberts
When mremap()ing a memory region previously registered with userfaultfd as write-protected but without
UFFD_FEATURE_EVENT_REMAP, an inconsistency in flag clearing leads to a mismatch between the vma flags (which have uffd-wp cleared) and the pte/pmd flags (which do not have uffd-wp cleared). This mismatch causes a subsequentmprotect(PROT_WRITE)to trigger a warning inpage_table_check_pte_flags()due to setting the pte to writable while uffd-wp is still set.
Quoted 5 lines
Fix this by always explicitly clearing the uffd-wp pte/pmd flags on any such
mremap()so that the values are consistent with the existing clearing ofVM_UFFD_WP. Be careful to clear the logical flag regardless of its physical form; a PTE bit, a swap PTE bit, or a PTE marker. Cover PTE, huge PMD and hugetlb paths.
I just noticed that Andrew sent this to Linus and it's now in his tree; I'm suddenly very nervous that it doesn't have any acks. I don't suppose you would be able to do a quick review to calm the nerves??
Thanks,
Ryan
Quoted 170 lines
Co-developed-by Mikołaj Lenczewski <[email protected]>Signed-off-by Mikołaj Lenczewski <[email protected]>Signed-off-by Ryan Roberts <[email protected]>Fixes 63b2d4174c4a ("userfaultfd: wp: add the writeprotect API to userfaultfd ioctl")--- include/linux/userfaultfd_k.h | 12 ++++++++++++ mm/huge_memory.c | 12 ++++++++++++ mm/hugetlb.c | 14 +++++++++++++- mm/mremap.c | 32 +++++++++++++++++++++++++++++++- 4 files changed, 68 insertions(+), 2 deletions(-)include/linux/userfaultfd_k.h +12
-0@@ -247,6 +247,13 @@ static inline bool vma_can_userfault(struct vm_area_struct *vma,vma_is_shmem (vma); } +static inline bool vma_has_uffd_without_event_remap (struct vm_area_struct *vma) +{ +struct userfaultfd_ctx *uffd_ctx = vma->vm_userfaultfd_ctx.ctx; + +return uffd_ctx && (uffd_ctx->features &UFFD_FEATURE_EVENT_REMAP ) ==0 ; +} +extern int dup_userfaultfd (struct vm_area_struct *,struct list_head *);extern void dup_userfaultfd_complete (struct list_head *);void dup_userfaultfd_fail (struct list_head *);@@ -402,6 +409,11 @@ static inline bool userfaultfd_wp_async(struct vm_area_struct *vma) return false; } +static inline bool vma_has_uffd_without_event_remap (struct vm_area_struct *vma) +{ +return false; +} +#endif /* CONFIG_USERFAULTFD */ static inline bool userfaultfd_wp_use_markers (struct vm_area_struct *vma)mm/huge_memory.c +12
-0@@ -2212,6 +2212,16 @@ static pmd_t move_soft_dirty_pmd(pmd_t pmd)return pmd; } +static pmd_t clear_uffd_wp_pmd (pmd_t pmd) +{ +if (pmd_present (pmd)) + pmd =pmd_clear_uffd_wp (pmd); +else if (is_swap_pmd (pmd)) + pmd =pmd_swp_clear_uffd_wp (pmd); + +return pmd; +} +bool move_huge_pmd (struct vm_area_struct *vma,unsigned long old_addr,unsigned long new_addr,pmd_t *old_pmd,pmd_t *new_pmd) {@@ -2250,6 +2260,8 @@ bool move_huge_pmd(struct vm_area_struct *vma, unsigned long old_addr,pgtable_trans_huge_deposit (mm, new_pmd, pgtable); } pmd =move_soft_dirty_pmd (pmd); +if (vma_has_uffd_without_event_remap (vma)) + pmd =clear_uffd_wp_pmd (pmd);set_pmd_at (mm, new_addr, new_pmd, pmd);if (force_flush)flush_pmd_tlb_range (vma, old_addr, old_addr +PMD_SIZE );mm/hugetlb.c +13
-1@@ -5454,6 +5454,7 @@ static void move_huge_pte(struct vm_area_struct *vma, unsigned long old_addr, unsigned long new_addr, pte_t *src_pte, pte_t *dst_pte, unsigned long sz) { + bool need_clear_uffd_wp = vma_has_uffd_without_event_remap(vma);struct hstate *h =hstate_vma (vma);struct mm_struct *mm = vma->vm_mm;spinlock_t *src_ptl, *dst_ptl;@@ -5470,7 +5471,18 @@ static void move_huge_pte(struct vm_area_struct *vma, unsigned long old_addr,spin_lock_nested (src_ptl,SINGLE_DEPTH_NESTING ); pte =huge_ptep_get_and_clear (mm, old_addr, src_pte); -set_huge_pte_at (mm, new_addr, dst_pte, pte, sz); + +if (need_clear_uffd_wp &&pte_marker_uffd_wp (pte)) +huge_pte_clear (mm, new_addr, dst_pte, sz); +else { +if (need_clear_uffd_wp) { +if (pte_present (pte)) + pte =huge_pte_clear_uffd_wp (pte); +else if (is_swap_pte (pte)) + pte =pte_swp_clear_uffd_wp (pte); + } +set_huge_pte_at (mm, new_addr, dst_pte, pte, sz); + }if (src_ptl != dst_ptl)spin_unlock (src_ptl);mm/mremap.c +31
-1@@ -138,6 +138,7 @@ static int move_ptes(struct vm_area_struct *vma, pmd_t *old_pmd, struct vm_area_struct *new_vma, pmd_t *new_pmd, unsigned long new_addr, bool need_rmap_locks) { + bool need_clear_uffd_wp = vma_has_uffd_without_event_remap(vma);struct mm_struct *mm = vma->vm_mm;pte_t *old_pte, *new_pte, pte;pmd_t dummy_pmdval;@@ -216,7 +217,18 @@ static int move_ptes(struct vm_area_struct *vma, pmd_t *old_pmd, force_flush = true; pte =move_pte (pte, old_addr, new_addr); pte =move_soft_dirty_pte (pte); -set_pte_at (mm, new_addr, new_pte, pte); + +if (need_clear_uffd_wp &&pte_marker_uffd_wp (pte)) +pte_clear (mm, new_addr, new_pte); +else { +if (need_clear_uffd_wp) { +if (pte_present (pte)) + pte =pte_clear_uffd_wp (pte); +else if (is_swap_pte (pte)) + pte =pte_swp_clear_uffd_wp (pte); + } +set_pte_at (mm, new_addr, new_pte, pte); + } }arch_leave_lazy_mmu_mode ();@@ -278,6 +290,15 @@ static bool move_normal_pmd(struct vm_area_struct *vma, unsigned long old_addr,if (WARN_ON_ONCE (!pmd_none (*new_pmd)))return false; +/* If this pmd belongs to a uffd vma with remap events disabled, we need +* to ensure that the uffd-wp state is cleared from all pgtables. This +* means recursing into lower page tables in move_page_tables(), and we +* can reuse the existing code if we simply treat the entry as "not +* moved". +*/ +if (vma_has_uffd_without_event_remap (vma)) +return false; +/* * We don't have to worry about the ordering of src and dst * ptlocks because exclusive mmap_lock prevents deadlock. @@ -333,6 +354,15 @@ static bool move_normal_pud(struct vm_area_struct *vma, unsigned long old_addr,if (WARN_ON_ONCE (!pud_none (*new_pud)))return false; +/* If this pud belongs to a uffd vma with remap events disabled, we need +* to ensure that the uffd-wp state is cleared from all pgtables. This +* means recursing into lower page tables in move_page_tables(), and we +* can reuse the existing code if we simply treat the entry as "not +* moved". +*/ +if (vma_has_uffd_without_event_remap (vma)) +return false; +/* * We don't have to worry about the ordering of src and dst * ptlocks because exclusive mmap_lock prevents deadlock.
Peter Xu
reviewerQuoted 1 line · Ryan Roberts
Hi Peter, David,
Hey, Ryan,
Quoted 16 lines · Ryan Roberts
Quoted 8 lines
When mremap()ing a memory region previously registered with userfaultfd as write-protected but without
UFFD_FEATURE_EVENT_REMAP, an inconsistency in flag clearing leads to a mismatch between the vma flags (which have uffd-wp cleared) and the pte/pmd flags (which do not have uffd-wp cleared). This mismatch causes a subsequentmprotect(PROT_WRITE)to trigger a warning inpage_table_check_pte_flags()due to setting the pte to writable while uffd-wp is still set.Quoted 5 lines
Fix this by always explicitly clearing the uffd-wp pte/pmd flags on any such
mremap()so that the values are consistent with the existing clearing ofVM_UFFD_WP. Be careful to clear the logical flag regardless of its physical form; a PTE bit, a swap PTE bit, or a PTE marker. Cover PTE, huge PMD and hugetlb paths.
Quoted 3 lines
I just noticed that Andrew sent this to Linus and it's now in his tree; I'm suddenly very nervous that it doesn't have any acks. I don't suppose you would be able to do a quick review to calm the nerves??
Heh, I fully trusted you, and I appreciated your help too. I'll need to run for 1-2 hours, but I'll read it this afternoon.
Side note: no review is as good as tests on reliability POV if that was the concern, but I'll try my best.
Thanks,
Signature · 1 line
Peter Xu
Quoted 25 lines · Peter Xu
Quoted 1 line · Ryan Roberts
Hi Peter, David,
Hey, Ryan,
Quoted 16 lines · Ryan Roberts
Quoted 8 lines
When mremap()ing a memory region previously registered with userfaultfd as write-protected but without
UFFD_FEATURE_EVENT_REMAP, an inconsistency in flag clearing leads to a mismatch between the vma flags (which have uffd-wp cleared) and the pte/pmd flags (which do not have uffd-wp cleared). This mismatch causes a subsequentmprotect(PROT_WRITE)to trigger a warning inpage_table_check_pte_flags()due to setting the pte to writable while uffd-wp is still set.Quoted 5 lines
Fix this by always explicitly clearing the uffd-wp pte/pmd flags on any such
mremap()so that the values are consistent with the existing clearing ofVM_UFFD_WP. Be careful to clear the logical flag regardless of its physical form; a PTE bit, a swap PTE bit, or a PTE marker. Cover PTE, huge PMD and hugetlb paths.Quoted 3 lines
I just noticed that Andrew sent this to Linus and it's now in his tree; I'm suddenly very nervous that it doesn't have any acks. I don't suppose you would be able to do a quick review to calm the nerves??
Quoted 5 lines
Heh, I fully trusted you, and I appreciated your help too. I'll need to run for 1-2 hours, but I'll read it this afternoon.
Side note: no review is as good as tests on reliability POV if that was the concern, but I'll try my best.
Things go all inception though when part of the review _are_ the tests ;) Though of course there are also all existing uffd tests and the bots that add a bit of weight.
This isn't really my area so will defer to Peter on the review side.
I sort of favour putting hotfixes in quick, but this one has gone in quicker than some reviewed hotfixes which we left in unstable... however towards the end of a cycle I think Andrew is stuck between a rock and a hard place in deciding how to handle these.
So I'm guessing the heuristic is 'allow to simmer in unstable if time permits in cycle', if known 'good egg' + no objection + towards end of cycle + hotfix - send.
I do wonder whether we should require review on hotfixes generally. But then of course that creates rock + hard place decision for Andrew as to whether it gets deferred to the next cycle + stable backports...
Maybe one to discuss at LSF?
Quoted 6 lines
Thanks,
--
Peter Xu
Ryan Roberts
reviewerQuoted 22 lines · Lorenzo Stoakes
Quoted 21 lines · Peter Xu
Quoted 1 line · Ryan Roberts
Hi Peter, David,
Hey, Ryan,
Quoted 16 lines · Ryan Roberts
Quoted 13 lines
When mremap()ing a memory region previously registered with userfaultfd as write-protected but without
UFFD_FEATURE_EVENT_REMAP, an inconsistency in flag clearing leads to a mismatch between the vma flags (which have uffd-wp cleared) and the pte/pmd flags (which do not have uffd-wp cleared). This mismatch causes a subsequentmprotect(PROT_WRITE)to trigger a warning inpage_table_check_pte_flags()due to setting the pte to writable while uffd-wp is still set.Fix this by always explicitly clearing the uffd-wp pte/pmd flags on any such
mremap()so that the values are consistent with the existing clearing ofVM_UFFD_WP. Be careful to clear the logical flag regardless of its physical form; a PTE bit, a swap PTE bit, or a PTE marker. Cover PTE, huge PMD and hugetlb paths.
Quoted 6 lines
Quoted 6 lines
Quoted 3 lines
I just noticed that Andrew sent this to Linus and it's now in his tree; I'm suddenly very nervous that it doesn't have any acks. I don't suppose you would be able to do a quick review to calm the nerves??
Heh, I fully trusted you, and I appreciated your help too. I'll need to run for 1-2 hours, but I'll read it this afternoon.
Thanks - appreciate it! I was just conscious that in the original thread there was some disagreement between you and David about whether we should clear the PTE state or set the VMA state. I think we converged on the former (and that's what's implemented) but would be good to get an explicit ack.
Quoted 15 lines
Quoted 3 lines
Side note: no review is as good as tests on reliability POV if that was the concern, but I'll try my best.
Things go all inception though when part of the review _are_ the tests ;) Though of course there are also all existing uffd tests and the bots that add a bit of weight.
This isn't really my area so will defer to Peter on the review side.
I sort of favour putting hotfixes in quick, but this one has gone in quicker than some reviewed hotfixes which we left in unstable... however towards the end of a cycle I think Andrew is stuck between a rock and a hard place in deciding how to handle these.
Quoted 7 lines
So I'm guessing the heuristic is 'allow to simmer in unstable if time permits in cycle', if known 'good egg' + no objection + towards end of cycle + hotfix - send.
I do wonder whether we should require review on hotfixes generally. But then of course that creates rock + hard place decision for Andrew as to whether it gets deferred to the next cycle + stable backports...
I have no issue with the process in general. I agree it's better to go quickly - that's the best way to find the bugs. I'm really just highlighting that in this case, I don't feel sufficiently expert with the subject matter and would appreciate another set of eyes.
Thanks,
Ryan
Quoted 9 lines
Maybe one to discuss at LSF?
Quoted 6 lines
Thanks,
--
Peter Xu
Andrew Morton
maintainerQuoted 8 lines · On Wed, 15 Jan 2025 17:30:20 +0000 Lorenzo Stoakes…
I sort of favour putting hotfixes in quick, but this one has gone in quicker than some reviewed hotfixes which we left in unstable... however towards the end of a cycle I think Andrew is stuck between a rock and a hard place in deciding how to handle these.
So I'm guessing the heuristic is 'allow to simmer in unstable if time permits in cycle', if known 'good egg' + no objection + towards end of cycle + hotfix - send.
Yup. Plus this patch had such a convincing changelog ;)
Quoted 14 lines · Ryan Roberts
When mremap()ing a memory region previously registered with userfaultfd as write-protected but without
UFFD_FEATURE_EVENT_REMAP, an inconsistency in flag clearing leads to a mismatch between the vma flags (which have uffd-wp cleared) and the pte/pmd flags (which do not have uffd-wp cleared). This mismatch causes a subsequentmprotect(PROT_WRITE)to trigger a warning inpage_table_check_pte_flags()due to setting the pte to writable while uffd-wp is still set.Fix this by always explicitly clearing the uffd-wp pte/pmd flags on any such
mremap()so that the values are consistent with the existing clearing ofVM_UFFD_WP. Be careful to clear the logical flag regardless of its physical form; a PTE bit, a swap PTE bit, or a PTE marker. Cover PTE, huge PMD and hugetlb paths.
Quoted 6 lines
Co-developed-by Mikołaj Lenczewski <[email protected]>Signed-off-by Mikołaj Lenczewski <[email protected]>Signed-off-by Ryan Roberts <[email protected]>Fixes 63b2d4174c4a ("userfaultfd: wp: add the writeprotect API to userfaultfd ioctl")
Nothing I see wrong:
One trivial thing: some multiple-line comments is following the net/ coding style rather than mm/, but well.. I don't think it's a huge deal.
https://www.kernel.org/doc/html/v4.10/process/coding-style.html#commenting
Thanks again.
Signature · 1 line
Peter Xu
Ryan Roberts
reviewerQuoted 22 lines · Peter Xu
Quoted 14 lines · Ryan Roberts
When mremap()ing a memory region previously registered with userfaultfd as write-protected but without
UFFD_FEATURE_EVENT_REMAP, an inconsistency in flag clearing leads to a mismatch between the vma flags (which have uffd-wp cleared) and the pte/pmd flags (which do not have uffd-wp cleared). This mismatch causes a subsequentmprotect(PROT_WRITE)to trigger a warning inpage_table_check_pte_flags()due to setting the pte to writable while uffd-wp is still set.Fix this by always explicitly clearing the uffd-wp pte/pmd flags on any such
mremap()so that the values are consistent with the existing clearing ofVM_UFFD_WP. Be careful to clear the logical flag regardless of its physical form; a PTE bit, a swap PTE bit, or a PTE marker. Cover PTE, huge PMD and hugetlb paths.Quoted 6 lines
Co-developed-by Mikołaj Lenczewski <[email protected]>Signed-off-by Mikołaj Lenczewski <[email protected]>Signed-off-by Ryan Roberts <[email protected]>Fixes 63b2d4174c4a ("userfaultfd: wp: add the writeprotect API to userfaultfd ioctl")
Quoted 3 lines
Nothing I see wrong:
Reviewed-by Peter Xu <[email protected]>
Great thanks!
Quoted 5 lines
One trivial thing: some multiple-line comments is following the
net/coding style rather thanmm/, but well.. I don't think it's a huge deal.https://www.kernel.org/doc/html/v4.10/process/coding-style.html#commenting
Noted, I'll aim to get it right in future.
Quoted 3 lines
Thanks again.
Quoted 23 lines · Ryan Roberts
Quoted 22 lines · Peter Xu
Quoted 20 lines · Ryan Roberts
When mremap()ing a memory region previously registered with userfaultfd as write-protected but without
UFFD_FEATURE_EVENT_REMAP, an inconsistency in flag clearing leads to a mismatch between the vma flags (which have uffd-wp cleared) and the pte/pmd flags (which do not have uffd-wp cleared). This mismatch causes a subsequentmprotect(PROT_WRITE)to trigger a warning inpage_table_check_pte_flags()due to setting the pte to writable while uffd-wp is still set.Fix this by always explicitly clearing the uffd-wp pte/pmd flags on any such
mremap()so that the values are consistent with the existing clearing ofVM_UFFD_WP. Be careful to clear the logical flag regardless of its physical form; a PTE bit, a swap PTE bit, or a PTE marker. Cover PTE, huge PMD and hugetlb paths.Co-developed-by Mikołaj Lenczewski <[email protected]>Signed-off-by Mikołaj Lenczewski <[email protected]>Signed-off-by Ryan Roberts <[email protected]>Fixes 63b2d4174c4a ("userfaultfd: wp: add the writeprotect API to userfaultfd ioctl")
Quoted 5 lines
Quoted 3 lines
Nothing I see wrong:
Reviewed-by Peter Xu <[email protected]>Great thanks!
Thanks Peter, for your feedback while I was out.
I remember that I skimmed over it without anything obvious jumping at me, but decided to set it aside for later to take a closer look .... which never happened.
Took another look, and it looks good to me! (we really must clear the uffd-wp flags when losing the VMA flag)
Signature · 3 lines
Cheers, David / dhildenb
Ryan Roberts
reviewerI think there might be a bug in this after all...
Quoted 100 lines · Ryan Roberts
When mremap()ing a memory region previously registered with userfaultfd as write-protected but without
UFFD_FEATURE_EVENT_REMAP, an inconsistency in flag clearing leads to a mismatch between the vma flags (which have uffd-wp cleared) and the pte/pmd flags (which do not have uffd-wp cleared). This mismatch causes a subsequentmprotect(PROT_WRITE)to trigger a warning inpage_table_check_pte_flags()due to setting the pte to writable while uffd-wp is still set.Fix this by always explicitly clearing the uffd-wp pte/pmd flags on any such
mremap()so that the values are consistent with the existing clearing ofVM_UFFD_WP. Be careful to clear the logical flag regardless of its physical form; a PTE bit, a swap PTE bit, or a PTE marker. Cover PTE, huge PMD and hugetlb paths.Co-developed-by Mikołaj Lenczewski <[email protected]>Signed-off-by Mikołaj Lenczewski <[email protected]>Signed-off-by Ryan Roberts <[email protected]>Fixes 63b2d4174c4a ("userfaultfd: wp: add the writeprotect API to userfaultfd ioctl")--- include/linux/userfaultfd_k.h | 12 ++++++++++++ mm/huge_memory.c | 12 ++++++++++++ mm/hugetlb.c | 14 +++++++++++++- mm/mremap.c | 32 +++++++++++++++++++++++++++++++- 4 files changed, 68 insertions(+), 2 deletions(-)include/linux/userfaultfd_k.h +12
-0@@ -247,6 +247,13 @@ static inline bool vma_can_userfault(struct vm_area_struct *vma,vma_is_shmem (vma); } +static inline bool vma_has_uffd_without_event_remap (struct vm_area_struct *vma) +{ +struct userfaultfd_ctx *uffd_ctx = vma->vm_userfaultfd_ctx.ctx; + +return uffd_ctx && (uffd_ctx->features &UFFD_FEATURE_EVENT_REMAP ) ==0 ; +} +extern int dup_userfaultfd (struct vm_area_struct *,struct list_head *);extern void dup_userfaultfd_complete (struct list_head *);void dup_userfaultfd_fail (struct list_head *);@@ -402,6 +409,11 @@ static inline bool userfaultfd_wp_async(struct vm_area_struct *vma) return false; } +static inline bool vma_has_uffd_without_event_remap (struct vm_area_struct *vma) +{ +return false; +} +#endif /* CONFIG_USERFAULTFD */ static inline bool userfaultfd_wp_use_markers (struct vm_area_struct *vma)mm/huge_memory.c +12
-0@@ -2212,6 +2212,16 @@ static pmd_t move_soft_dirty_pmd(pmd_t pmd)return pmd; } +static pmd_t clear_uffd_wp_pmd (pmd_t pmd) +{ +if (pmd_present (pmd)) + pmd =pmd_clear_uffd_wp (pmd); +else if (is_swap_pmd (pmd)) + pmd =pmd_swp_clear_uffd_wp (pmd); + +return pmd; +} +bool move_huge_pmd (struct vm_area_struct *vma,unsigned long old_addr,unsigned long new_addr,pmd_t *old_pmd,pmd_t *new_pmd) {@@ -2250,6 +2260,8 @@ bool move_huge_pmd(struct vm_area_struct *vma, unsigned long old_addr,pgtable_trans_huge_deposit (mm, new_pmd, pgtable); } pmd =move_soft_dirty_pmd (pmd); +if (vma_has_uffd_without_event_remap (vma)) + pmd =clear_uffd_wp_pmd (pmd);set_pmd_at (mm, new_addr, new_pmd, pmd);if (force_flush)flush_pmd_tlb_range (vma, old_addr, old_addr +PMD_SIZE );mm/hugetlb.c +1
-0@@ -5454,6 +5454,7 @@ static void move_huge_pte(struct vm_area_struct *vma, unsigned long old_addr, unsigned long new_addr, pte_t *src_pte, pte_t *dst_pte, unsigned long sz) { + bool need_clear_uffd_wp = vma_has_uffd_without_event_remap(vma);struct hstate *h =hstate_vma (vma);struct mm_struct *mm = vma->vm_mm;spinlock_t *src_ptl, *dst_ptl;
mm/hugetlb.c static void move_huge_pte(struct vm_area_struct *vma, unsigned long old_addr, · line 5476
Quoted 7 lines
mm/hugetlb.c +3
-1@@ -5470,7 +5471,18 @@ static void move_huge_pte(struct vm_area_struct *vma, unsigned long old_addr,spin_lock_nested (src_ptl,SINGLE_DEPTH_NESTING ); pte =huge_ptep_get_and_clear (mm, old_addr, src_pte); -set_huge_pte_at (mm, new_addr, dst_pte, pte, sz); + +if (need_clear_uffd_wp &&pte_marker_uffd_wp (pte)) +huge_pte_clear (mm, new_addr, dst_pte, sz);
This is checking if the source huge_pte is a uffd-wp marker and clearing the destination if so. The destination could have previously held arbitrary valid mappings, I guess?
But huge_pte_clear() does not call page_table_check_pte_clear(). So any previous valid mapping will not have it's page_table_check ref count decremented?
I think it should be replaced with:
huge_ptep_get_and_clear(mm, new_addr, dst_pte);
Since there is no huge_ptep_clear().
The tests I wrote are always mremapping into PROT_NONE space so they don't hit this condition. If people agree this is a bug, I'll send out a fix.
Thanks,
Ryan
Quoted 76 lines
mm/hugetlb.c +9
-0+else { +if (need_clear_uffd_wp) { +if (pte_present (pte)) + pte =huge_pte_clear_uffd_wp (pte); +else if (is_swap_pte (pte)) + pte =pte_swp_clear_uffd_wp (pte); + } +set_huge_pte_at (mm, new_addr, dst_pte, pte, sz); + }if (src_ptl != dst_ptl)spin_unlock (src_ptl);mm/mremap.c +31
-1@@ -138,6 +138,7 @@ static int move_ptes(struct vm_area_struct *vma, pmd_t *old_pmd, struct vm_area_struct *new_vma, pmd_t *new_pmd, unsigned long new_addr, bool need_rmap_locks) { + bool need_clear_uffd_wp = vma_has_uffd_without_event_remap(vma);struct mm_struct *mm = vma->vm_mm;pte_t *old_pte, *new_pte, pte;pmd_t dummy_pmdval;@@ -216,7 +217,18 @@ static int move_ptes(struct vm_area_struct *vma, pmd_t *old_pmd, force_flush = true; pte =move_pte (pte, old_addr, new_addr); pte =move_soft_dirty_pte (pte); -set_pte_at (mm, new_addr, new_pte, pte); + +if (need_clear_uffd_wp &&pte_marker_uffd_wp (pte)) +pte_clear (mm, new_addr, new_pte); +else { +if (need_clear_uffd_wp) { +if (pte_present (pte)) + pte =pte_clear_uffd_wp (pte); +else if (is_swap_pte (pte)) + pte =pte_swp_clear_uffd_wp (pte); + } +set_pte_at (mm, new_addr, new_pte, pte); + } }arch_leave_lazy_mmu_mode ();@@ -278,6 +290,15 @@ static bool move_normal_pmd(struct vm_area_struct *vma, unsigned long old_addr,if (WARN_ON_ONCE (!pmd_none (*new_pmd)))return false; +/* If this pmd belongs to a uffd vma with remap events disabled, we need +* to ensure that the uffd-wp state is cleared from all pgtables. This +* means recursing into lower page tables in move_page_tables(), and we +* can reuse the existing code if we simply treat the entry as "not +* moved". +*/ +if (vma_has_uffd_without_event_remap (vma)) +return false; +/* * We don't have to worry about the ordering of src and dst * ptlocks because exclusive mmap_lock prevents deadlock. @@ -333,6 +354,15 @@ static bool move_normal_pud(struct vm_area_struct *vma, unsigned long old_addr,if (WARN_ON_ONCE (!pud_none (*new_pud)))return false; +/* If this pud belongs to a uffd vma with remap events disabled, we need +* to ensure that the uffd-wp state is cleared from all pgtables. This +* means recursing into lower page tables in move_page_tables(), and we +* can reuse the existing code if we simply treat the entry as "not +* moved". +*/ +if (vma_has_uffd_without_event_remap (vma)) +return false; +/* * We don't have to worry about the ordering of src and dst * ptlocks because exclusive mmap_lock prevents deadlock.
Ryan Roberts
reviewerQuoted 119 lines · Ryan Roberts
I think there might be a bug in this after all...
Quoted 100 lines · Ryan Roberts
When mremap()ing a memory region previously registered with userfaultfd as write-protected but without
UFFD_FEATURE_EVENT_REMAP, an inconsistency in flag clearing leads to a mismatch between the vma flags (which have uffd-wp cleared) and the pte/pmd flags (which do not have uffd-wp cleared). This mismatch causes a subsequentmprotect(PROT_WRITE)to trigger a warning inpage_table_check_pte_flags()due to setting the pte to writable while uffd-wp is still set.Fix this by always explicitly clearing the uffd-wp pte/pmd flags on any such
mremap()so that the values are consistent with the existing clearing ofVM_UFFD_WP. Be careful to clear the logical flag regardless of its physical form; a PTE bit, a swap PTE bit, or a PTE marker. Cover PTE, huge PMD and hugetlb paths.Co-developed-by Mikołaj Lenczewski <[email protected]>Signed-off-by Mikołaj Lenczewski <[email protected]>Signed-off-by Ryan Roberts <[email protected]>Fixes 63b2d4174c4a ("userfaultfd: wp: add the writeprotect API to userfaultfd ioctl")--- include/linux/userfaultfd_k.h | 12 ++++++++++++ mm/huge_memory.c | 12 ++++++++++++ mm/hugetlb.c | 14 +++++++++++++- mm/mremap.c | 32 +++++++++++++++++++++++++++++++- 4 files changed, 68 insertions(+), 2 deletions(-)include/linux/userfaultfd_k.h +12
-0@@ -247,6 +247,13 @@ static inline bool vma_can_userfault(struct vm_area_struct *vma,vma_is_shmem (vma); } +static inline bool vma_has_uffd_without_event_remap (struct vm_area_struct *vma) +{ +struct userfaultfd_ctx *uffd_ctx = vma->vm_userfaultfd_ctx.ctx; + +return uffd_ctx && (uffd_ctx->features &UFFD_FEATURE_EVENT_REMAP ) ==0 ; +} +extern int dup_userfaultfd (struct vm_area_struct *,struct list_head *);extern void dup_userfaultfd_complete (struct list_head *);void dup_userfaultfd_fail (struct list_head *);@@ -402,6 +409,11 @@ static inline bool userfaultfd_wp_async(struct vm_area_struct *vma) return false; } +static inline bool vma_has_uffd_without_event_remap (struct vm_area_struct *vma) +{ +return false; +} +#endif /* CONFIG_USERFAULTFD */ static inline bool userfaultfd_wp_use_markers (struct vm_area_struct *vma)mm/huge_memory.c +12
-0@@ -2212,6 +2212,16 @@ static pmd_t move_soft_dirty_pmd(pmd_t pmd)return pmd; } +static pmd_t clear_uffd_wp_pmd (pmd_t pmd) +{ +if (pmd_present (pmd)) + pmd =pmd_clear_uffd_wp (pmd); +else if (is_swap_pmd (pmd)) + pmd =pmd_swp_clear_uffd_wp (pmd); + +return pmd; +} +bool move_huge_pmd (struct vm_area_struct *vma,unsigned long old_addr,unsigned long new_addr,pmd_t *old_pmd,pmd_t *new_pmd) {@@ -2250,6 +2260,8 @@ bool move_huge_pmd(struct vm_area_struct *vma, unsigned long old_addr,pgtable_trans_huge_deposit (mm, new_pmd, pgtable); } pmd =move_soft_dirty_pmd (pmd); +if (vma_has_uffd_without_event_remap (vma)) + pmd =clear_uffd_wp_pmd (pmd);set_pmd_at (mm, new_addr, new_pmd, pmd);if (force_flush)flush_pmd_tlb_range (vma, old_addr, old_addr +PMD_SIZE );mm/hugetlb.c +1
-0@@ -5454,6 +5454,7 @@ static void move_huge_pte(struct vm_area_struct *vma, unsigned long old_addr, unsigned long new_addr, pte_t *src_pte, pte_t *dst_pte, unsigned long sz) { + bool need_clear_uffd_wp = vma_has_uffd_without_event_remap(vma);struct hstate *h =hstate_vma (vma);struct mm_struct *mm = vma->vm_mm;spinlock_t *src_ptl, *dst_ptl;mm/hugetlb.c static void move_huge_pte(struct vm_area_struct *vma, unsigned long old_addr, · line 5476
Quoted 7 lines
mm/hugetlb.c +3
-1@@ -5470,7 +5471,18 @@ static void move_huge_pte(struct vm_area_struct *vma, unsigned long old_addr,spin_lock_nested (src_ptl,SINGLE_DEPTH_NESTING ); pte =huge_ptep_get_and_clear (mm, old_addr, src_pte); -set_huge_pte_at (mm, new_addr, dst_pte, pte, sz); + +if (need_clear_uffd_wp &&pte_marker_uffd_wp (pte)) +huge_pte_clear (mm, new_addr, dst_pte, sz);This is checking if the source
huge_pteis a uffd-wp marker and clearing the destination if so. The destination could have previously held arbitrary valid mappings, I guess?But
huge_pte_clear()does not callpage_table_check_pte_clear(). So any previous valid mapping will not have it'spage_table_checkref count decremented?
Quoted 7 lines
I think it should be replaced with:
huge_ptep_get_and_clear(mm, new_addr, dst_pte);Since there is no
huge_ptep_clear().The tests I wrote are always mremapping into
PROT_NONEspace so they don't hit this condition. If people agree this is a bug, I'll send out a fix.
OK I'm deep in the rabbit hole now; Could anyone clarify the specs for huge_pte_clear() and huge_ptep_get_and_clear()? Specifically, I believe:
- huge_pte_clear() can only be called for not-present huge_ptes, because the
only way to set a huge_pte is via set_huge_pte_at() and that will always execute the page_table_check_*_set() functions for present huge_ptes. So clearing a present huge_pte using huge_pte_clear(), which does not call page_table_check_*_clear(), would cause counter imbalance. It looks like existing generic-code callers of huge_pte_clear() only do it for non-present huge_ptes.
- huge_ptep_get_and_clear() can be used to get-and-clear both present and
non-present huge_ptes? There is a single call site in generic-code where this could be called for a non-present huge_pte: move_huge_pte() (and it was there prior to my change). BUT, it looks like the arm64 implementation of huge_ptep_get_and_clear() is not safe to call if the pte being cleared is non-present:
pte_t huge_ptep_get_and_clear(struct mm_struct *mm,
unsigned long addr, pte_t *ptep)
{
int ncontig;
size_t pgsize;
pte_t orig_pte = __ptep_get(ptep);
if (!pte_cont(orig_pte))
return __ptep_get_and_clear(mm, addr, ptep);
ncontig = find_num_contig(mm, addr, ptep, &pgsize);
return get_clear_contig(mm, addr, ptep, pgsize, ncontig);
}pte_cont() assumes the pte is present, otherwise it's sampling a random bit that doesn't have the meaning it thinks it has. It is currently relying on that to determine the size of the huge_pte.
So either arm64 has a bug or move_huge_pte() has a bug. If huge_ptep_get_and_clear() needs to work for non-present huge_ptes, we will need to pass the huge_pte size into this function. I don't think there is another way to resolve this.
Thanks,
Ryan
Quoted 4 lines
Thanks,
Ryan
Peter Xu
reviewerQuoted 12 lines · Ryan Roberts
mm/hugetlb.c static void move_huge_pte(struct vm_area_struct *vma, unsigned long old_addr, · line 5476
Quoted 8 lines
mm/hugetlb.c +3
-1@@ -5470,7 +5471,18 @@ static void move_huge_pte(struct vm_area_struct *vma, unsigned long old_addr,spin_lock_nested (src_ptl,SINGLE_DEPTH_NESTING ); pte =huge_ptep_get_and_clear (mm, old_addr, src_pte); -set_huge_pte_at (mm, new_addr, dst_pte, pte, sz); + +if (need_clear_uffd_wp &&pte_marker_uffd_wp (pte)) +huge_pte_clear (mm, new_addr, dst_pte, sz);This is checking if the source
huge_pteis a uffd-wp marker and clearing the destination if so. The destination could have previously held arbitrary valid mappings, I guess?
I think it should be all cleared. I didn't check all mremap paths, but for MREMAP_FIXED at least there should be:
if (flags & MREMAP_FIXED) {
/*
* In mremap_to().
* VMA is moved to dst address, and munmap dst first.
* do_munmap will check if dst is sealed.
*/
ret = do_munmap(mm, new_addr, new_len, uf_unmap_early);
if (ret)
goto out;
}It also doesn't sound right to leave anything in dest range, e.g. if there can be any leftover dest ptes in move_page_tables(), then it means HPAGE_P[MU]D won't work, as they install huge entries directly. For that I do see a hint in the comment too in that path:
move_normal_pud():
/* * The destination pud shouldn't be established, free_pgtables() * should have released it. */ if (WARN_ON_ONCE(!pud_none(*new_pud))) return false;
PMD path has similar implications.
Thanks,
Signature · 1 line
Peter Xu
Ryan Roberts
reviewerQuoted 28 lines · Peter Xu
Quoted 12 lines · Ryan Roberts
mm/hugetlb.c static void move_huge_pte(struct vm_area_struct *vma, unsigned long old_addr, · line 5476
Quoted 8 lines
mm/hugetlb.c +3
-1@@ -5470,7 +5471,18 @@ static void move_huge_pte(struct vm_area_struct *vma, unsigned long old_addr,spin_lock_nested (src_ptl,SINGLE_DEPTH_NESTING ); pte =huge_ptep_get_and_clear (mm, old_addr, src_pte); -set_huge_pte_at (mm, new_addr, dst_pte, pte, sz); + +if (need_clear_uffd_wp &&pte_marker_uffd_wp (pte)) +huge_pte_clear (mm, new_addr, dst_pte, sz);This is checking if the source
huge_pteis a uffd-wp marker and clearing the destination if so. The destination could have previously held arbitrary valid mappings, I guess?I think it should be all cleared. I didn't check all mremap paths, but for
MREMAP_FIXEDat least there should be:if (flags & MREMAP_FIXED) { /* * In mremap_to(). * VMA is moved to dst address, and munmap dst first. * do_munmap will check if dst is sealed. */ ret = do_munmap(mm, new_addr, new_len, uf_unmap_early); if (ret) goto out; }
Quoted 1 line
It also doesn't sound right to leave anything in dest range,
Yes, of course. And the loop over the old ptes actually skips doing anything if the old pte is none without doing any operations on the new pte; so it must be none by default. OK panic over! I just need to fix the arm64 issue I raised in the other email. I'm going to send a bunch of fixes/improvements in that area.
Thanks,
Ryan
Quoted 17 lines
e.g. if there
can be any leftover dest ptes inmove_page_tables(), then it means HPAGE_P[MU]D won't work, as they install huge entries directly. For that I do see a hint in the comment too in that path:
move_normal_pud():/* * The destination pud shouldn't be established, free_pgtables() * should have released it. */ if (WARN_ON_ONCE(!pud_none(*new_pud))) return false;PMD path has similar implications.
Thanks,
Ryan Roberts
reviewerPATCH 2/2 selftests/mm: Introduce uffd-wp-mremap regression test
In reply to Ryan RobertsIntroduce a test that registers a range of memory for UFFDIO_WRITEPROTECT_MODE_WP without UFFD_FEATURE_EVENT_REMAP. First check that the uffd-wp bit is set for every PTE in the range. Then mremap() the range to a new location and check that the uffd-wp bit is clear for every PTE in the range.
Run the test for small folios, all supported THP sizes and all supported hugetlb sizes, and for swapped out memory, shared and private.
There was previously a bug in the kernel where the uffd-wp bits remained set in all PTEs for this case, after fixing the kernel, the tests all pass.
--- tools/testing/selftests/mm/.gitignore | 1 + tools/testing/selftests/mm/Makefile | 2 + tools/testing/selftests/mm/run_vmtests.sh | 1 + tools/testing/selftests/mm/uffd-wp-mremap.c | 380 ++++++++++++++++++++ 4 files changed, 384 insertions(+) create mode 100644 tools/testing/selftests/mm/uffd-wp-mremap.c
tools/testing/selftests/mm/.gitignore +1 -0
@@ -27,6 +27,7 @@ protection_keys_64 madv_populate uffd-stress uffd-unit-tests +uffd-wp-mremap mlock-intersect-test mlock-random-test virtual_address_range
tools/testing/selftests/mm/Makefile +2 -0
@@ -81,6 +81,7 @@ TEST_GEN_FILES += thuge-gen TEST_GEN_FILES += transhuge-stress TEST_GEN_FILES += uffd-stress TEST_GEN_FILES += uffd-unit-tests +TEST_GEN_FILES += uffd-wp-mremap TEST_GEN_FILES += split_huge_page_test TEST_GEN_FILES += ksm_tests TEST_GEN_FILES += ksm_functional_tests
@@ -151,6 +152,7 @@ $(TEST_GEN_FILES): vm_util.c thp_settings.c $(OUTPUT)/uffd-stress: uffd-common.c $(OUTPUT)/uffd-unit-tests: uffd-common.c +$(OUTPUT)/uffd-wp-mremap: uffd-common.c $(OUTPUT)/protection_keys: pkey_util.c $(OUTPUT)/pkey_sighandler_tests: pkey_util.c
tools/testing/selftests/mm/run_vmtests.sh +1 -0
@@ -309,6 +309,7 @@ CATEGORY="userfaultfd" run_test ${uffd_stress_bin} hugetlb "$half_ufd_size_MB" 3 CATEGORY="userfaultfd" run_test ${uffd_stress_bin} hugetlb-private "$half_ufd_size_MB" 32 CATEGORY="userfaultfd" run_test ${uffd_stress_bin} shmem 20 16 CATEGORY="userfaultfd" run_test ${uffd_stress_bin} shmem-private 20 16 +CATEGORY="userfaultfd" run_test ./uffd-wp-mremap #cleanup echo "$nr_hugepgs" > /proc/sys/vm/nr_hugepages
tools/testing/selftests/mm/uffd-wp-mremap.c new file +380 -0
380 lines not on this page · raw message
Signature · 1 line
2.43.0