mm-support-gup-triggered-unsharing-of-anonymous-pages.patch removed from -mm tree
The quilt patch titled
Subject: mm: support GUP-triggered unsharing of anonymous pages
has been removed from the -mm tree. Its filename was
mm-support-gup-triggered-unsharing-of-anonymous-pages.patch
This patch was dropped because it was merged into mm-stable
------------------------------------------------------
From: David Hildenbrand <[email protected]>
Subject: mm: support GUP-triggered unsharing of anonymous pages
Whenever GUP currently ends up taking a R/O pin on an anonymous page that might be shared -- mapped R/O and !PageAnonExclusive() -- any write fault on the page table entry will end up replacing the mapped anonymous page due to COW, resulting in the GUP pin no longer being consistent with the page actually mapped into the page table.
The possible ways to deal with this situation are:
(1) Ignore and pin -- what we do right now.
(2) Fail to pin -- which would be rather surprising to callers and could break user space.
(3) Trigger unsharing and pin the now exclusive page -- reliable R/O pins.
We want to implement 3) because it provides the clearest semantics and allows for checking in unpin_user_pages() and friends for possible BUGs:
when trying to unpin a page that's no longer exclusive, clearly something went very wrong and might result in memory corruptions that might be hard to debug. So we better have a nice way to spot such issues.
To implement 3), we need a way for GUP to trigger unsharing:FAULT_FLAG_UNSHARE. FAULT_FLAG_UNSHARE is only applicable to R/O mapped anonymous pages and resembles COW logic during a write fault. However, in contrast to a write fault, GUP-triggered unsharing will, for example, still maintain the write protection.
Let's implement FAULT_FLAG_UNSHARE by hooking into the existing write fault handlers for all applicable anonymous page types: ordinary pages, THP and hugetlb.
* If FAULT_FLAG_UNSHARE finds a R/O-mapped anonymous page that has been marked exclusive in the meantime by someone else, there is nothing to do.
* If FAULT_FLAG_UNSHARE finds a R/O-mapped anonymous page that's not marked exclusive, it will try detecting if the process is the exclusive owner. If exclusive, it can be set exclusive similar to reuse logic during write faults via page_move_anon_rmap() and there is nothing else to do; otherwise, we either have to copy and map a fresh, anonymous exclusive page R/O (ordinary pages, hugetlb), or split the THP.
This commit is heavily based on patches by Andrea.
---
include/linux/mm_types.h | 8 ++ mm/huge_memory.c | 10 +++ mm/hugetlb.c | 56 ++++++++++++------- mm/memory.c | 107 +++++++++++++++++++++++++------------ 4 files changed, 126 insertions(+), 55 deletions(-)
include/linux/mm_types.h renamed from include/linux/mm_types.h~mm-support-gup-triggered-unsharing-of-anonymous-pages +8 -0
@@ -819,6 +819,9 @@ typedef struct {* @FAULT_FLAG_REMOTE: The fault is not for current task/mm. * @FAULT_FLAG_INSTRUCTION: The fault was during an instruction fetch. * @FAULT_FLAG_INTERRUPTIBLE: The fault can be interrupted by non-fatal signals. +* @FAULT_FLAG_UNSHARE: The fault is an unsharing request to unshare (and mark +* exclusive) a possibly shared anonymous page that is +* mapped R/O. * * About @FAULT_FLAG_ALLOW_RETRY and @FAULT_FLAG_TRIED: we can specify * whether we would allow page faults to retry by specifying these two
@@ -838,6 +841,10 @@ typedef struct {* continuous faults with flags (b). We should always try to detect pending * signals before a retry to make sure the continuous page faults can still be * interrupted if necessary. +* +* The combination FAULT_FLAG_WRITE|FAULT_FLAG_UNSHARE is illegal. +* FAULT_FLAG_UNSHARE is ignored and treated like an ordinary read fault when +* no existing R/O-mapped anonymous page is encountered. */ enum fault_flag {FAULT_FLAG_WRITE =1 <<0 ,
@@ -850,6 +857,7 @@ enum fault_flag {FAULT_FLAG_REMOTE =1 <<7 ,FAULT_FLAG_INSTRUCTION =1 <<8 ,FAULT_FLAG_INTERRUPTIBLE =1 <<9 , + FAULT_FLAG_UNSHARE = 1 << 10, };#endif /* _LINUX_MM_TYPES_H */
mm/huge_memory.c renamed from mm/huge_memory.c~mm-support-gup-triggered-unsharing-of-anonymous-pages +9 -1
@@ -1271,6 +1271,7 @@ unlock:vm_fault_t do_huge_pmd_wp_page (struct vm_fault *vmf) { +const bool unshare = vmf->flags &FAULT_FLAG_UNSHARE ;struct vm_area_struct *vma = vmf->vma;struct page *page;unsigned long haddr = vmf->address &HPAGE_PMD_MASK ;
@@ -1279,6 +1280,9 @@ vm_fault_t do_huge_pmd_wp_page(struct vm vmf->ptl =pmd_lockptr (vma->vm_mm, vmf->pmd);VM_BUG_ON_VMA (!vma->anon_vma, vma); +VM_BUG_ON (unshare && (vmf->flags &FAULT_FLAG_WRITE )); +VM_BUG_ON (!unshare && !(vmf->flags &FAULT_FLAG_WRITE )); +if (is_huge_zero_pmd (orig_pmd)) goto fallback;
@@ -1317,7 +1321,7 @@ vm_fault_t do_huge_pmd_wp_page(struct vm }/* -* See do_wp_page(): we can only map the page writable if there are +* See do_wp_page(): we can only reuse the page exclusively if there are * no additional references. Note that we always drain the LRU * pagevecs immediately after adding a THP. */
@@ -1331,6 +1335,10 @@ vm_fault_t do_huge_pmd_wp_page(struct vmpage_move_anon_rmap (page, vma);unlock_page (page); reuse: +if (unlikely (unshare)) { +spin_unlock (vmf->ptl); +return 0 ; + } entry =pmd_mkyoung (orig_pmd); entry =maybe_pmd_mkwrite (pmd_mkdirty (entry), vma);if (pmdp_set_access_flags (vma, haddr, vmf->pmd, entry,1 ))
mm/hugetlb.c renamed from mm/hugetlb.c~mm-support-gup-triggered-unsharing-of-anonymous-pages +35 -21
138 lines not on this page · raw message
mm/memory.c renamed from mm/memory.c~mm-support-gup-triggered-unsharing-of-anonymous-pages +74 -33
218 lines not on this page · raw message
_
Patches currently in -mm which might be from [email protected] are