[PATCH v2 00/15] mm: COW fixes part 2: reliable GUP pins of anonymous pages

[PATCH v2 00/15] mm: COW fixes part 2: reliable GUP pins of anonymous pages

[David Hildenbrand]

This series is the result of the discussion on the previous approach [2].
More information on the general COW issues can be found there. It is based
on v5.17-rc8 and [1], which resides in -mm and -next:
	[PATCH v3 0/9] mm: COW fixes part 1: fix the COW security issue for
	THP and swap

v2 is located at:
	https://github.com/davidhildenbrand/linux/tree/cow_fixes_part_2_v2

The plan is to rebase on top of v5.18-rc1 (there will be some collisions
with folio reworks), pull it early into -next, to then eventually have it
in v5.19. This should give it some good test coverage in -next. We could
then decide, whether we want to backport into -stable trees.


This series fixes memory corruptions when a GUP pin (FOLL_PIN) was taken
on an anonymous page and COW logic fails to detect exclusivity of the page
to then replacing the anonymous page by a copy in the page table: The
GUP pin lost synchronicity with the pages mapped into the page tables.

This issue, including other related COW issues, has been summarized in [3]
under 3):
"
  3. Intra Process Memory Corruptions due to Wrong COW (FOLL_PIN)

  page_maybe_dma_pinned() is used to check if a page may be pinned for
  DMA (using FOLL_PIN instead of FOLL_GET). While false positives are
  tolerable, false negatives are problematic: pages that are pinned for
  DMA must not be added to the swapcache. If it happens, the (now pinned)
  page could be faulted back from the swapcache into page tables
  read-only. Future write-access would detect the pinning and COW the
  page, losing synchronicity. For the interested reader, this is nicely
  documented in feb889fb40fa ("mm: don't put pinned pages into the swap
  cache").

  Peter reports [8] that page_maybe_dma_pinned() as used is racy in some
  cases and can result in a violation of the documented semantics:
  giving false negatives because of the race.

  There are cases where we call it without properly taking a per-process
  sequence lock, turning the usage of page_maybe_dma_pinned() racy. While
  one case (clear_refs SOFTDIRTY tracking, see below) seems to be easy to
  handle, there is especially one rmap case (shrink_page_list) that's hard
  to fix: in the rmap world, we're not limited to a single process.

  The shrink_page_list() issue is really subtle. If we race with
  someone pinning a page, we can trigger the same issue as in the FOLL_GET
  case. See the detail section at the end of this mail on a discussion how
  bad this can bite us with VFIO or other FOLL_PIN user.

  It's harder to reproduce, but I managed to modify the O_DIRECT
  reproducer to use io_uring fixed buffers [15] instead, which ends up
  using FOLL_PIN | FOLL_WRITE | FOLL_LONGTERM to pin buffer pages and can
  similarly trigger a loss of synchronicity and consequently a memory
  corruption.

  Again, the root issue is that a write-fault on a page that has
  additional references results in a COW and thereby a loss of
  synchronicity and consequently a memory corruption if two parties
  believe they are referencing the same page.
"

This series makes GUP pins (R/O and R/W) on anonymous pages fully reliable,
especially also taking care of concurrent pinning via GUP-fast,
for example, also fully fixing an issue reported regarding NUMA
balancing [4] recently. While doing that, it further reduces "unnecessary
COWs", especially when we don't fork()/KSM and don't swapout, and fixes the
COW security for hugetlb for FOLL_PIN.

In summary, we track via a pageflag (PG_anon_exclusive) whether a mapped
anonymous page is exclusive. Exclusive anonymous pages that are mapped
R/O can directly be mapped R/W by the COW logic in the write fault handler.
Exclusive anonymous pages that want to be shared (fork(), KSM) first have
to be marked shared -- which will fail if there are GUP pins on the page.
GUP is only allowed to take a pin on anonymous pages that are exclusive.
The PT lock is the primary mechanism to synchronize modifications of
PG_anon_exclusive. We syncronize against GUP-fast either via the
src_mm->write_protect_seq (during fork()) or via clear/invalidate+flush of
the relevant page table entry.

Special care has to be taken about swap, migration, and THPs (whereby a
PMD-mapping can be converted to a PTE mapping and we have to track
information for subpages). Besides these, we let the rmap code handle most
magic. For reliable R/O pins of anonymous pages, we need FAULT_FLAG_UNSHARE
logic as part of our previous approach [2], however, it's now 100% mapcount
free and I further simplified it a bit.

  #1 is a fix
  #3-#9 are mostly rmap preparations for PG_anon_exclusive handling
  #10 introduces PG_anon_exclusive
  #11 uses PG_anon_exclusive and make R/W pins of anonymous pages
   reliable
  #12 is a preparation for reliable R/O pins
  #13 and #14 is reused/modified GUP-triggered unsharing for R/O GUP pins
   make R/O pins of anonymous pages reliable
  #15 adds sanity check when (un)pinning anonymous pages

Patch #11 contains excessive explanations and the main logic for R/W pins.
#12 and #13 resemble what we proposed in the previous approach [2]. I
consider the general approach of #15 very nice and helpful, and I
remember Linus even envisioning something like that for finding BUGs.

It passes my growing set of tests for "wrong COW" and "missed COW",
including the ones in [3] -- I'd really appreciate some experienced eyes
to take a close look at corner cases.

I'll be sending out part 3 next, that will remember PG_anon_exclusive for
ordinary swap entries: this will make FOLL_GET | FOLL_WRITE references
reliable and fix the memory corruptions for O_DIRECT -- as described in
[3] under 2) -- as well, as long as there is no fork().

The long term goal should be to convert relevant users of FOLL_GET to
FOLL_PIN, however, with part 3 it wouldn't be required to fix the obvious
memory corruptions we are aware of.

[1] https://lkml.kernel.org/r/20220131162940.210846-1-david@redhat.com
[2] https://lkml.kernel.org/r/20211217113049.23850-1-david@redhat.com
[3] https://lore.kernel.org/r/3ae33b08-d9ef-f846-56fb-645e3b9b4c66@redhat.com
[4] https://bugzilla.kernel.org/show_bug.cgi?id=215616

v1 -> v2:
* Tested on aarch64, ppc64, s390x and x86_64
* "mm/page-flags: reuse PG_mappedtodisk as PG_anon_exclusive for PageAnon()
   pages"
  -> Use PG_mappedtodisk instead of PG_slab (thanks Willy!), this simlifies
     the patch and necessary handling a lot. Add safety BUG_ON's
  -> Move most documentation to the patch description, to be placed in a
     proper documentation doc in the future, once everything's in place
* ""mm: remember exclusively mapped anonymous pages with PG_anon_exclusive
  -> Skip check+clearing in page_try_dup_anon_rmap(), otherwise we might
     trigger a wrong VM_BUG_ON() for KSM pages in ClearPageAnonExclusive()
  -> In __split_huge_pmd_locked(), call page_try_share_anon_rmap() only
     for "anon_exclusive", otherwise we might trigger a wrong VM_BUG_ON()
  -> In __split_huge_page_tail(), drop any remaining PG_anon_exclusive on
     tail pages, and document why that is fine

RFC -> v1:
* Rephrased/extended some patch descriptions+comments
* Tested on aarch64, ppc64 and x86_64
* "mm/rmap: convert RMAP flags to a proper distinct rmap_t type"
 -> Added
* "mm/rmap: drop "compound" parameter from page_add_new_anon_rmap()"
 -> Added
* "mm: remember exclusively mapped anonymous pages with PG_anon_exclusive"
 -> Fixed __do_huge_pmd_anonymous_page() to recheck after temporarily
    dropping the PT lock.
 -> Use "reuse" label in __do_huge_pmd_anonymous_page()
 -> Slightly simplify logic in hugetlb_cow()
 -> In remove_migration_pte(), remove unrelated changes around
    page_remove_rmap()
* "mm: support GUP-triggered unsharing of anonymous pages"
 -> In handle_pte_fault(), trigger pte_mkdirty() only with
    FAULT_FLAG_WRITE
 -> In __handle_mm_fault(), extend comment regarding anonymous PUDs
* "mm/gup: trigger FAULT_FLAG_UNSHARE when R/O-pinning a possibly shared
   anonymous page"
   -> Added unsharing logic to gup_hugepte() and gup_huge_pud()
   -> Changed return logic in __follow_hugetlb_must_fault(), making sure
      that "unshare" is always set
* "mm/gup: sanity-check with CONFIG_DEBUG_VM that anonymous pages are
   exclusive when (un)pinning"
  -> Slightly simplified sanity_check_pinned_pages()

David Hildenbrand (15):
  mm/rmap: fix missing swap_free() in try_to_unmap() after
    arch_unmap_one() failed
  mm/hugetlb: take src_mm->write_protect_seq in
    copy_hugetlb_page_range()
  mm/memory: slightly simplify copy_present_pte()
  mm/rmap: split page_dup_rmap() into page_dup_file_rmap() and
    page_try_dup_anon_rmap()
  mm/rmap: convert RMAP flags to a proper distinct rmap_t type
  mm/rmap: remove do_page_add_anon_rmap()
  mm/rmap: pass rmap flags to hugepage_add_anon_rmap()
  mm/rmap: drop "compound" parameter from page_add_new_anon_rmap()
  mm/rmap: use page_move_anon_rmap() when reusing a mapped PageAnon()
    page exclusively
  mm/page-flags: reuse PG_mappedtodisk as PG_anon_exclusive for
    PageAnon() pages
  mm: remember exclusively mapped anonymous pages with PG_anon_exclusive
  mm/gup: disallow follow_page(FOLL_PIN)
  mm: support GUP-triggered unsharing of anonymous pages
  mm/gup: trigger FAULT_FLAG_UNSHARE when R/O-pinning a possibly shared
    anonymous page
  mm/gup: sanity-check with CONFIG_DEBUG_VM that anonymous pages are
    exclusive when (un)pinning

 include/linux/mm.h         |  46 +++++++-
 include/linux/mm_types.h   |   8 ++
 include/linux/page-flags.h |  39 ++++++-
 include/linux/rmap.h       | 116 +++++++++++++++++--
 include/linux/swap.h       |  15 ++-
 include/linux/swapops.h    |  25 ++++
 kernel/events/uprobes.c    |   2 +-
 mm/gup.c                   | 103 +++++++++++++++-
 mm/huge_memory.c           | 124 +++++++++++++++-----
 mm/hugetlb.c               | 135 ++++++++++++++-------
 mm/khugepaged.c            |   2 +-
 mm/ksm.c                   |  15 ++-
 mm/memory.c                | 232 +++++++++++++++++++++++--------------
 mm/memremap.c              |   9 ++
 mm/migrate.c               |  40 ++++++-
 mm/mprotect.c              |   8 +-
 mm/rmap.c                  |  95 +++++++++++----
 mm/swapfile.c              |   8 +-
 mm/userfaultfd.c           |   2 +-
 tools/vm/page-types.c      |   8 +-
 20 files changed, 815 insertions(+), 217 deletions(-)

-- 
2.35.1

[PATCH v2 01/15] mm/rmap: fix missing swap_free() in try_to_unmap() after arch_unmap_one() failed

[David Hildenbrand]

In case arch_unmap_one() fails, we already did a swap_duplicate(). let's
undo that properly via swap_free().

Fixes: ca827d55ebaa ("mm, swap: Add infrastructure for saving page metadata on swap")
Reviewed-by: Khalid Aziz <khalid.aziz@oracle.com>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 mm/rmap.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/mm/rmap.c b/mm/rmap.c
index 6a1e8c7f6213..f825aeef61ca 100644
--- a/mm/rmap.c
+++ b/mm/rmap.c
@@ -1625,6 +1625,7 @@ static bool try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
 				break;
 			}
 			if (arch_unmap_one(mm, vma, address, pteval) < 0) {
+				swap_free(entry);
 				set_pte_at(mm, address, pvmw.pte, pteval);
 				ret = false;
 				page_vma_mapped_walk_done(&pvmw);
-- 
2.35.1

[PATCH v2 02/15] mm/hugetlb: take src_mm->write_protect_seq in copy_hugetlb_page_range()

[David Hildenbrand]

Let's do it just like copy_page_range(), taking the seqlock and making
sure the mmap_lock is held in write mode.

This allows for add a VM_BUG_ON to page_needs_cow_for_dma() and
properly synchronizes cocnurrent fork() with GUP-fast of hugetlb pages,
which will be relevant for further changes.

Signed-off-by: David Hildenbrand <david@redhat.com>
---
 include/linux/mm.h | 4 ++++
 mm/hugetlb.c       | 8 ++++++--
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/include/linux/mm.h b/include/linux/mm.h
index 9530f950f156..391b950e919d 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -1323,6 +1323,8 @@ static inline bool is_cow_mapping(vm_flags_t flags)
 /*
  * This should most likely only be called during fork() to see whether we
  * should break the cow immediately for a page on the src mm.
+ *
+ * The caller has to hold the PT lock and the vma->vm_mm->->write_protect_seq.
  */
 static inline bool page_needs_cow_for_dma(struct vm_area_struct *vma,
 					  struct page *page)
@@ -1330,6 +1332,8 @@ static inline bool page_needs_cow_for_dma(struct vm_area_struct *vma,
 	if (!is_cow_mapping(vma->vm_flags))
 		return false;
 
+	VM_BUG_ON(!(raw_read_seqcount(&vma->vm_mm->write_protect_seq) & 1));
+
 	if (!test_bit(MMF_HAS_PINNED, &vma->vm_mm->flags))
 		return false;
 
diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index f294db835f4b..d3ce89697855 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -4710,6 +4710,8 @@ int copy_hugetlb_page_range(struct mm_struct *dst, struct mm_struct *src,
 					vma->vm_start,
 					vma->vm_end);
 		mmu_notifier_invalidate_range_start(&range);
+		mmap_assert_write_locked(src);
+		raw_write_seqcount_begin(&src->write_protect_seq);
 	} else {
 		/*
 		 * For shared mappings i_mmap_rwsem must be held to call
@@ -4842,10 +4844,12 @@ int copy_hugetlb_page_range(struct mm_struct *dst, struct mm_struct *src,
 		spin_unlock(dst_ptl);
 	}
 
-	if (cow)
+	if (cow) {
+		raw_write_seqcount_end(&src->write_protect_seq);
 		mmu_notifier_invalidate_range_end(&range);
-	else
+	} else {
 		i_mmap_unlock_read(mapping);
+	}
 
 	return ret;
 }
-- 
2.35.1

[PATCH v2 03/15] mm/memory: slightly simplify copy_present_pte()

[David Hildenbrand]

Let's move the pinning check into the caller, to simplify return code
logic and prepare for further changes: relocating the
page_needs_cow_for_dma() into rmap handling code.

While at it, remove the unused pte parameter and simplify the comments a
bit.

No functional change intended.

Signed-off-by: David Hildenbrand <david@redhat.com>
---
 mm/memory.c | 53 ++++++++++++++++-------------------------------------
 1 file changed, 16 insertions(+), 37 deletions(-)

diff --git a/mm/memory.c b/mm/memory.c
index c6177d897964..accb72a3343d 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -865,19 +865,11 @@ copy_nonpresent_pte(struct mm_struct *dst_mm, struct mm_struct *src_mm,
 }
 
 /*
- * Copy a present and normal page if necessary.
+ * Copy a present and normal page.
  *
- * NOTE! The usual case is that this doesn't need to do
- * anything, and can just return a positive value. That
- * will let the caller know that it can just increase
- * the page refcount and re-use the pte the traditional
- * way.
- *
- * But _if_ we need to copy it because it needs to be
- * pinned in the parent (and the child should get its own
- * copy rather than just a reference to the same page),
- * we'll do that here and return zero to let the caller
- * know we're done.
+ * NOTE! The usual case is that this isn't required;
+ * instead, the caller can just increase the page refcount
+ * and re-use the pte the traditional way.
  *
  * And if we need a pre-allocated page but don't yet have
  * one, return a negative error to let the preallocation
@@ -887,25 +879,10 @@ copy_nonpresent_pte(struct mm_struct *dst_mm, struct mm_struct *src_mm,
 static inline int
 copy_present_page(struct vm_area_struct *dst_vma, struct vm_area_struct *src_vma,
 		  pte_t *dst_pte, pte_t *src_pte, unsigned long addr, int *rss,
-		  struct page **prealloc, pte_t pte, struct page *page)
+		  struct page **prealloc, struct page *page)
 {
 	struct page *new_page;
-
-	/*
-	 * What we want to do is to check whether this page may
-	 * have been pinned by the parent process.  If so,
-	 * instead of wrprotect the pte on both sides, we copy
-	 * the page immediately so that we'll always guarantee
-	 * the pinned page won't be randomly replaced in the
-	 * future.
-	 *
-	 * The page pinning checks are just "has this mm ever
-	 * seen pinning", along with the (inexact) check of
-	 * the page count. That might give false positives for
-	 * for pinning, but it will work correctly.
-	 */
-	if (likely(!page_needs_cow_for_dma(src_vma, page)))
-		return 1;
+	pte_t pte;
 
 	new_page = *prealloc;
 	if (!new_page)
@@ -947,14 +924,16 @@ copy_present_pte(struct vm_area_struct *dst_vma, struct vm_area_struct *src_vma,
 	struct page *page;
 
 	page = vm_normal_page(src_vma, addr, pte);
-	if (page) {
-		int retval;
-
-		retval = copy_present_page(dst_vma, src_vma, dst_pte, src_pte,
-					   addr, rss, prealloc, pte, page);
-		if (retval <= 0)
-			return retval;
-
+	if (page && unlikely(page_needs_cow_for_dma(src_vma, page))) {
+		/*
+		 * If this page may have been pinned by the parent process,
+		 * copy the page immediately for the child so that we'll always
+		 * guarantee the pinned page won't be randomly replaced in the
+		 * future.
+		 */
+		return copy_present_page(dst_vma, src_vma, dst_pte, src_pte,
+					 addr, rss, prealloc, page);
+	} else if (page) {
 		get_page(page);
 		page_dup_rmap(page, false);
 		rss[mm_counter(page)]++;
-- 
2.35.1

[PATCH v2 04/15] mm/rmap: split page_dup_rmap() into page_dup_file_rmap() and page_try_dup_anon_rmap()

[David Hildenbrand]

... and move the special check for pinned pages into
page_try_dup_anon_rmap() to prepare for tracking exclusive anonymous
pages via a new pageflag, clearing it only after making sure that there
are no GUP pins on the anonymous page.

We really only care about pins on anonymous pages, because they are
prone to getting replaced in the COW handler once mapped R/O. For !anon
pages in cow-mappings (!VM_SHARED && VM_MAYWRITE) we shouldn't really
care about that, at least not that I could come up with an example.

Let's drop the is_cow_mapping() check from page_needs_cow_for_dma(), as we
know we're dealing with anonymous pages. Also, drop the handling of
pinned pages from copy_huge_pud() and add a comment if ever supporting
anonymous pages on the PUD level.

This is a preparation for tracking exclusivity of anonymous pages in
the rmap code, and disallowing marking a page shared (-> failing to
duplicate) if there are GUP pins on a page.

RFC notes: if I'm missing something important for !anon pages, we could
           similarly handle it via page_try_dup_file_rmap().

Signed-off-by: David Hildenbrand <david@redhat.com>
---
 include/linux/mm.h   |  5 +----
 include/linux/rmap.h | 48 +++++++++++++++++++++++++++++++++++++++++++-
 mm/huge_memory.c     | 27 ++++++++-----------------
 mm/hugetlb.c         | 16 ++++++++-------
 mm/memory.c          | 17 +++++++++++-----
 mm/migrate.c         |  2 +-
 6 files changed, 78 insertions(+), 37 deletions(-)

diff --git a/include/linux/mm.h b/include/linux/mm.h
index 391b950e919d..63ee06001189 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -1322,16 +1322,13 @@ static inline bool is_cow_mapping(vm_flags_t flags)
 
 /*
  * This should most likely only be called during fork() to see whether we
- * should break the cow immediately for a page on the src mm.
+ * should break the cow immediately for an anon page on the src mm.
  *
  * The caller has to hold the PT lock and the vma->vm_mm->->write_protect_seq.
  */
 static inline bool page_needs_cow_for_dma(struct vm_area_struct *vma,
 					  struct page *page)
 {
-	if (!is_cow_mapping(vma->vm_flags))
-		return false;
-
 	VM_BUG_ON(!(raw_read_seqcount(&vma->vm_mm->write_protect_seq) & 1));
 
 	if (!test_bit(MMF_HAS_PINNED, &vma->vm_mm->flags))
diff --git a/include/linux/rmap.h b/include/linux/rmap.h
index e704b1a4c06c..92c3585b8c6a 100644
--- a/include/linux/rmap.h
+++ b/include/linux/rmap.h
@@ -180,11 +180,57 @@ void hugepage_add_anon_rmap(struct page *, struct vm_area_struct *,
 void hugepage_add_new_anon_rmap(struct page *, struct vm_area_struct *,
 				unsigned long);
 
-static inline void page_dup_rmap(struct page *page, bool compound)
+static inline void __page_dup_rmap(struct page *page, bool compound)
 {
 	atomic_inc(compound ? compound_mapcount_ptr(page) : &page->_mapcount);
 }
 
+static inline void page_dup_file_rmap(struct page *page, bool compound)
+{
+	__page_dup_rmap(page, compound);
+}
+
+/**
+ * page_try_dup_anon_rmap - try duplicating a mapping of an already mapped
+ *			    anonymous page
+ * @page: the page to duplicate the mapping for
+ * @compound: the page is mapped as compound or as a small page
+ * @vma: the source vma
+ *
+ * The caller needs to hold the PT lock and the vma->vma_mm->write_protect_seq.
+ *
+ * Duplicating the mapping can only fail if the page may be pinned; device
+ * private pages cannot get pinned and consequently this function cannot fail.
+ *
+ * If duplicating the mapping succeeds, the page has to be mapped R/O into
+ * the parent and the child. It must *not* get mapped writable after this call.
+ *
+ * Returns 0 if duplicating the mapping succeeded. Returns -EBUSY otherwise.
+ */
+static inline int page_try_dup_anon_rmap(struct page *page, bool compound,
+					 struct vm_area_struct *vma)
+{
+	VM_BUG_ON_PAGE(!PageAnon(page), page);
+
+	/*
+	 * If this page may have been pinned by the parent process,
+	 * don't allow to duplicate the mapping but instead require to e.g.,
+	 * copy the page immediately for the child so that we'll always
+	 * guarantee the pinned page won't be randomly replaced in the
+	 * future on write faults.
+	 */
+	if (likely(!is_device_private_page(page) &&
+	    unlikely(page_needs_cow_for_dma(vma, page))))
+		return -EBUSY;
+
+	/*
+	 * It's okay to share the anon page between both processes, mapping
+	 * the page R/O into both processes.
+	 */
+	__page_dup_rmap(page, compound);
+	return 0;
+}
+
 /*
  * Called from mm/vmscan.c to handle paging out
  */
diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index cda88d8ac1bd..c126d728b8de 100644
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -1097,23 +1097,16 @@ int copy_huge_pmd(struct mm_struct *dst_mm, struct mm_struct *src_mm,
 	src_page = pmd_page(pmd);
 	VM_BUG_ON_PAGE(!PageHead(src_page), src_page);
 
-	/*
-	 * If this page is a potentially pinned page, split and retry the fault
-	 * with smaller page size.  Normally this should not happen because the
-	 * userspace should use MADV_DONTFORK upon pinned regions.  This is a
-	 * best effort that the pinned pages won't be replaced by another
-	 * random page during the coming copy-on-write.
-	 */
-	if (unlikely(page_needs_cow_for_dma(src_vma, src_page))) {
+	get_page(src_page);
+	if (unlikely(page_try_dup_anon_rmap(src_page, true, src_vma))) {
+		/* Page maybe pinned: split and retry the fault on PTEs. */
+		put_page(src_page);
 		pte_free(dst_mm, pgtable);
 		spin_unlock(src_ptl);
 		spin_unlock(dst_ptl);
 		__split_huge_pmd(src_vma, src_pmd, addr, false, NULL);
 		return -EAGAIN;
 	}
-
-	get_page(src_page);
-	page_dup_rmap(src_page, true);
 	add_mm_counter(dst_mm, MM_ANONPAGES, HPAGE_PMD_NR);
 out_zero_page:
 	mm_inc_nr_ptes(dst_mm);
@@ -1217,14 +1210,10 @@ int copy_huge_pud(struct mm_struct *dst_mm, struct mm_struct *src_mm,
 		/* No huge zero pud yet */
 	}
 
-	/* Please refer to comments in copy_huge_pmd() */
-	if (unlikely(page_needs_cow_for_dma(vma, pud_page(pud)))) {
-		spin_unlock(src_ptl);
-		spin_unlock(dst_ptl);
-		__split_huge_pud(vma, src_pud, addr);
-		return -EAGAIN;
-	}
-
+	/*
+	 * TODO: once we support anonymous pages, use page_try_dup_anon_rmap()
+	 * and split if duplicating fails.
+	 */
 	pudp_set_wrprotect(src_mm, addr, src_pud);
 	pud = pud_mkold(pud_wrprotect(pud));
 	set_pud_at(dst_mm, addr, dst_pud, pud);
diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index d3ce89697855..9fb990d95dab 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -4781,15 +4781,18 @@ int copy_hugetlb_page_range(struct mm_struct *dst, struct mm_struct *src,
 			get_page(ptepage);
 
 			/*
-			 * This is a rare case where we see pinned hugetlb
-			 * pages while they're prone to COW.  We need to do the
-			 * COW earlier during fork.
+			 * Failing to duplicate the anon rmap is a rare case
+			 * where we see pinned hugetlb pages while they're
+			 * prone to COW. We need to do the COW earlier during
+			 * fork.
 			 *
 			 * When pre-allocating the page or copying data, we
 			 * need to be without the pgtable locks since we could
 			 * sleep during the process.
 			 */
-			if (unlikely(page_needs_cow_for_dma(vma, ptepage))) {
+			if (!PageAnon(ptepage)) {
+				page_dup_file_rmap(ptepage, true);
+			} else if (page_try_dup_anon_rmap(ptepage, true, vma)) {
 				pte_t src_pte_old = entry;
 				struct page *new;
 
@@ -4836,7 +4839,6 @@ int copy_hugetlb_page_range(struct mm_struct *dst, struct mm_struct *src,
 				entry = huge_pte_wrprotect(entry);
 			}
 
-			page_dup_rmap(ptepage, true);
 			set_huge_pte_at(dst, addr, dst_pte, entry);
 			hugetlb_count_add(npages, dst);
 		}
@@ -5514,7 +5516,7 @@ static vm_fault_t hugetlb_no_page(struct mm_struct *mm,
 		ClearHPageRestoreReserve(page);
 		hugepage_add_new_anon_rmap(page, vma, haddr);
 	} else
-		page_dup_rmap(page, true);
+		page_dup_file_rmap(page, true);
 	new_pte = make_huge_pte(vma, page, ((vma->vm_flags & VM_WRITE)
 				&& (vma->vm_flags & VM_SHARED)));
 	set_huge_pte_at(mm, haddr, ptep, new_pte);
@@ -5874,7 +5876,7 @@ int hugetlb_mcopy_atomic_pte(struct mm_struct *dst_mm,
 		goto out_release_unlock;
 
 	if (vm_shared) {
-		page_dup_rmap(page, true);
+		page_dup_file_rmap(page, true);
 	} else {
 		ClearHPageRestoreReserve(page);
 		hugepage_add_new_anon_rmap(page, dst_vma, dst_addr);
diff --git a/mm/memory.c b/mm/memory.c
index accb72a3343d..b9602d41d907 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -828,7 +828,8 @@ copy_nonpresent_pte(struct mm_struct *dst_mm, struct mm_struct *src_mm,
 		 */
 		get_page(page);
 		rss[mm_counter(page)]++;
-		page_dup_rmap(page, false);
+		/* Cannot fail as these pages cannot get pinned. */
+		BUG_ON(page_try_dup_anon_rmap(page, false, src_vma));
 
 		/*
 		 * We do not preserve soft-dirty information, because so
@@ -924,18 +925,24 @@ copy_present_pte(struct vm_area_struct *dst_vma, struct vm_area_struct *src_vma,
 	struct page *page;
 
 	page = vm_normal_page(src_vma, addr, pte);
-	if (page && unlikely(page_needs_cow_for_dma(src_vma, page))) {
+	if (page && PageAnon(page)) {
 		/*
 		 * If this page may have been pinned by the parent process,
 		 * copy the page immediately for the child so that we'll always
 		 * guarantee the pinned page won't be randomly replaced in the
 		 * future.
 		 */
-		return copy_present_page(dst_vma, src_vma, dst_pte, src_pte,
-					 addr, rss, prealloc, page);
+		get_page(page);
+		if (unlikely(page_try_dup_anon_rmap(page, false, src_vma))) {
+			/* Page maybe pinned, we have to copy. */
+			put_page(page);
+			return copy_present_page(dst_vma, src_vma, dst_pte, src_pte,
+						 addr, rss, prealloc, page);
+		}
+		rss[mm_counter(page)]++;
 	} else if (page) {
 		get_page(page);
-		page_dup_rmap(page, false);
+		page_dup_file_rmap(page, false);
 		rss[mm_counter(page)]++;
 	}
 
diff --git a/mm/migrate.c b/mm/migrate.c
index c7da064b4781..524c2648ab36 100644
--- a/mm/migrate.c
+++ b/mm/migrate.c
@@ -240,7 +240,7 @@ static bool remove_migration_pte(struct page *page, struct vm_area_struct *vma,
 			if (PageAnon(new))
 				hugepage_add_anon_rmap(new, vma, pvmw.address);
 			else
-				page_dup_rmap(new, true);
+				page_dup_file_rmap(new, true);
 			set_huge_pte_at(vma->vm_mm, pvmw.address, pvmw.pte, pte);
 		} else
 #endif
-- 
2.35.1

[PATCH v2 05/15] mm/rmap: convert RMAP flags to a proper distinct rmap_t type

[David Hildenbrand]

We want to pass the flags to more than one anon rmap function, getting
rid of special "do_page_add_anon_rmap()". So let's pass around a distinct
__bitwise type and refine documentation.

Signed-off-by: David Hildenbrand <david@redhat.com>
---
 include/linux/rmap.h | 22 ++++++++++++++++++----
 mm/memory.c          |  6 +++---
 mm/rmap.c            |  7 ++++---
 3 files changed, 25 insertions(+), 10 deletions(-)

diff --git a/include/linux/rmap.h b/include/linux/rmap.h
index 92c3585b8c6a..49f6b208938c 100644
--- a/include/linux/rmap.h
+++ b/include/linux/rmap.h
@@ -158,9 +158,23 @@ static inline void anon_vma_merge(struct vm_area_struct *vma,
 
 struct anon_vma *page_get_anon_vma(struct page *page);
 
-/* bitflags for do_page_add_anon_rmap() */
-#define RMAP_EXCLUSIVE 0x01
-#define RMAP_COMPOUND 0x02
+/* RMAP flags, currently only relevant for some anon rmap operations. */
+typedef int __bitwise rmap_t;
+
+/*
+ * No special request: if the page is a subpage of a compound page, it is
+ * mapped via a PTE. The mapped (sub)page is possibly shared between processes.
+ */
+#define RMAP_NONE		((__force rmap_t)0)
+
+/* The (sub)page is exclusive to a single process. */
+#define RMAP_EXCLUSIVE		((__force rmap_t)BIT(0))
+
+/*
+ * The compound page is not mapped via PTEs, but instead via a single PMD and
+ * should be accounted accordingly.
+ */
+#define RMAP_COMPOUND		((__force rmap_t)BIT(1))
 
 /*
  * rmap interfaces called when adding or removing pte of page
@@ -169,7 +183,7 @@ void page_move_anon_rmap(struct page *, struct vm_area_struct *);
 void page_add_anon_rmap(struct page *, struct vm_area_struct *,
 		unsigned long, bool);
 void do_page_add_anon_rmap(struct page *, struct vm_area_struct *,
-			   unsigned long, int);
+			   unsigned long, rmap_t);
 void page_add_new_anon_rmap(struct page *, struct vm_area_struct *,
 		unsigned long, bool);
 void page_add_file_rmap(struct page *, bool);
diff --git a/mm/memory.c b/mm/memory.c
index b9602d41d907..bbce3ca72974 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -3515,10 +3515,10 @@ vm_fault_t do_swap_page(struct vm_fault *vmf)
 	struct vm_area_struct *vma = vmf->vma;
 	struct page *page = NULL, *swapcache;
 	struct swap_info_struct *si = NULL;
+	rmap_t rmap_flags = RMAP_NONE;
 	swp_entry_t entry;
 	pte_t pte;
 	int locked;
-	int exclusive = 0;
 	vm_fault_t ret = 0;
 	void *shadow = NULL;
 
@@ -3693,7 +3693,7 @@ vm_fault_t do_swap_page(struct vm_fault *vmf)
 		pte = maybe_mkwrite(pte_mkdirty(pte), vma);
 		vmf->flags &= ~FAULT_FLAG_WRITE;
 		ret |= VM_FAULT_WRITE;
-		exclusive = RMAP_EXCLUSIVE;
+		rmap_flags |= RMAP_EXCLUSIVE;
 	}
 	flush_icache_page(vma, page);
 	if (pte_swp_soft_dirty(vmf->orig_pte))
@@ -3709,7 +3709,7 @@ vm_fault_t do_swap_page(struct vm_fault *vmf)
 		page_add_new_anon_rmap(page, vma, vmf->address, false);
 		lru_cache_add_inactive_or_unevictable(page, vma);
 	} else {
-		do_page_add_anon_rmap(page, vma, vmf->address, exclusive);
+		do_page_add_anon_rmap(page, vma, vmf->address, rmap_flags);
 	}
 
 	set_pte_at(vma->vm_mm, vmf->address, vmf->pte, pte);
diff --git a/mm/rmap.c b/mm/rmap.c
index f825aeef61ca..3d7028d100ea 100644
--- a/mm/rmap.c
+++ b/mm/rmap.c
@@ -1139,7 +1139,8 @@ static void __page_check_anon_rmap(struct page *page,
 void page_add_anon_rmap(struct page *page,
 	struct vm_area_struct *vma, unsigned long address, bool compound)
 {
-	do_page_add_anon_rmap(page, vma, address, compound ? RMAP_COMPOUND : 0);
+	do_page_add_anon_rmap(page, vma, address,
+			      compound ? RMAP_COMPOUND : RMAP_NONE);
 }
 
 /*
@@ -1148,7 +1149,7 @@ void page_add_anon_rmap(struct page *page,
  * Everybody else should continue to use page_add_anon_rmap above.
  */
 void do_page_add_anon_rmap(struct page *page,
-	struct vm_area_struct *vma, unsigned long address, int flags)
+	struct vm_area_struct *vma, unsigned long address, rmap_t flags)
 {
 	bool compound = flags & RMAP_COMPOUND;
 	bool first;
@@ -1189,7 +1190,7 @@ void do_page_add_anon_rmap(struct page *page,
 	/* address might be in next vma when migration races vma_adjust */
 	if (first)
 		__page_set_anon_rmap(page, vma, address,
-				flags & RMAP_EXCLUSIVE);
+				     !!(flags & RMAP_EXCLUSIVE));
 	else
 		__page_check_anon_rmap(page, vma, address);
 }
-- 
2.35.1

[PATCH v2 06/15] mm/rmap: remove do_page_add_anon_rmap()

[David Hildenbrand]

... and instead convert page_add_anon_rmap() to accept flags.

Passing flags instead of bools is usually nicer either way, and we want
to more often also pass RMAP_EXCLUSIVE in follow up patches when
detecting that an anonymous page is exclusive: for example, when
restoring an anonymous page from a writable migration entry.

This is a preparation for marking an anonymous page inside
page_add_anon_rmap() as exclusive when RMAP_EXCLUSIVE is passed.

Signed-off-by: David Hildenbrand <david@redhat.com>
---
 include/linux/rmap.h |  4 +---
 mm/huge_memory.c     |  2 +-
 mm/ksm.c             |  2 +-
 mm/memory.c          |  2 +-
 mm/migrate.c         |  3 ++-
 mm/rmap.c            | 14 +-------------
 mm/swapfile.c        |  2 +-
 7 files changed, 8 insertions(+), 21 deletions(-)

diff --git a/include/linux/rmap.h b/include/linux/rmap.h
index 49f6b208938c..a269f80fbeef 100644
--- a/include/linux/rmap.h
+++ b/include/linux/rmap.h
@@ -181,9 +181,7 @@ typedef int __bitwise rmap_t;
  */
 void page_move_anon_rmap(struct page *, struct vm_area_struct *);
 void page_add_anon_rmap(struct page *, struct vm_area_struct *,
-		unsigned long, bool);
-void do_page_add_anon_rmap(struct page *, struct vm_area_struct *,
-			   unsigned long, rmap_t);
+		unsigned long, rmap_t);
 void page_add_new_anon_rmap(struct page *, struct vm_area_struct *,
 		unsigned long, bool);
 void page_add_file_rmap(struct page *, bool);
diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index c126d728b8de..2ca137e01e84 100644
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -3115,7 +3115,7 @@ void remove_migration_pmd(struct page_vma_mapped_walk *pvmw, struct page *new)
 
 	flush_cache_range(vma, mmun_start, mmun_start + HPAGE_PMD_SIZE);
 	if (PageAnon(new))
-		page_add_anon_rmap(new, vma, mmun_start, true);
+		page_add_anon_rmap(new, vma, mmun_start, RMAP_COMPOUND);
 	else
 		page_add_file_rmap(new, true);
 	set_pmd_at(mm, mmun_start, pvmw->pmd, pmde);
diff --git a/mm/ksm.c b/mm/ksm.c
index c20bd4d9a0d9..9ff28097bc0a 100644
--- a/mm/ksm.c
+++ b/mm/ksm.c
@@ -1153,7 +1153,7 @@ static int replace_page(struct vm_area_struct *vma, struct page *page,
 	 */
 	if (!is_zero_pfn(page_to_pfn(kpage))) {
 		get_page(kpage);
-		page_add_anon_rmap(kpage, vma, addr, false);
+		page_add_anon_rmap(kpage, vma, addr, RMAP_NONE);
 		newpte = mk_pte(kpage, vma->vm_page_prot);
 	} else {
 		newpte = pte_mkspecial(pfn_pte(page_to_pfn(kpage),
diff --git a/mm/memory.c b/mm/memory.c
index bbce3ca72974..e2d8e55c55c0 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -3709,7 +3709,7 @@ vm_fault_t do_swap_page(struct vm_fault *vmf)
 		page_add_new_anon_rmap(page, vma, vmf->address, false);
 		lru_cache_add_inactive_or_unevictable(page, vma);
 	} else {
-		do_page_add_anon_rmap(page, vma, vmf->address, rmap_flags);
+		page_add_anon_rmap(page, vma, vmf->address, rmap_flags);
 	}
 
 	set_pte_at(vma->vm_mm, vmf->address, vmf->pte, pte);
diff --git a/mm/migrate.c b/mm/migrate.c
index 524c2648ab36..907052b72581 100644
--- a/mm/migrate.c
+++ b/mm/migrate.c
@@ -246,7 +246,8 @@ static bool remove_migration_pte(struct page *page, struct vm_area_struct *vma,
 #endif
 		{
 			if (PageAnon(new))
-				page_add_anon_rmap(new, vma, pvmw.address, false);
+				page_add_anon_rmap(new, vma, pvmw.address,
+						   RMAP_NONE);
 			else
 				page_add_file_rmap(new, false);
 			set_pte_at(vma->vm_mm, pvmw.address, pvmw.pte, pte);
diff --git a/mm/rmap.c b/mm/rmap.c
index 3d7028d100ea..97bcc50c3489 100644
--- a/mm/rmap.c
+++ b/mm/rmap.c
@@ -1129,7 +1129,7 @@ static void __page_check_anon_rmap(struct page *page,
  * @page:	the page to add the mapping to
  * @vma:	the vm area in which the mapping is added
  * @address:	the user virtual address mapped
- * @compound:	charge the page as compound or small page
+ * @flags:	the rmap flags
  *
  * The caller needs to hold the pte lock, and the page must be locked in
  * the anon_vma case: to serialize mapping,index checking after setting,
@@ -1137,18 +1137,6 @@ static void __page_check_anon_rmap(struct page *page,
  * (but PageKsm is never downgraded to PageAnon).
  */
 void page_add_anon_rmap(struct page *page,
-	struct vm_area_struct *vma, unsigned long address, bool compound)
-{
-	do_page_add_anon_rmap(page, vma, address,
-			      compound ? RMAP_COMPOUND : RMAP_NONE);
-}
-
-/*
- * Special version of the above for do_swap_page, which often runs
- * into pages that are exclusively owned by the current process.
- * Everybody else should continue to use page_add_anon_rmap above.
- */
-void do_page_add_anon_rmap(struct page *page,
 	struct vm_area_struct *vma, unsigned long address, rmap_t flags)
 {
 	bool compound = flags & RMAP_COMPOUND;
diff --git a/mm/swapfile.c b/mm/swapfile.c
index a5183315dc58..41ba8238d16b 100644
--- a/mm/swapfile.c
+++ b/mm/swapfile.c
@@ -1800,7 +1800,7 @@ static int unuse_pte(struct vm_area_struct *vma, pmd_t *pmd,
 	inc_mm_counter(vma->vm_mm, MM_ANONPAGES);
 	get_page(page);
 	if (page == swapcache) {
-		page_add_anon_rmap(page, vma, addr, false);
+		page_add_anon_rmap(page, vma, addr, RMAP_NONE);
 	} else { /* ksm created a completely new copy */
 		page_add_new_anon_rmap(page, vma, addr, false);
 		lru_cache_add_inactive_or_unevictable(page, vma);
-- 
2.35.1

[PATCH v2 07/15] mm/rmap: pass rmap flags to hugepage_add_anon_rmap()

[David Hildenbrand]

Let's prepare for passing RMAP_EXCLUSIVE, similarly as we do for
page_add_anon_rmap() now. RMAP_COMPOUND is implicit for hugetlb
pages and ignored.

Signed-off-by: David Hildenbrand <david@redhat.com>
---
 include/linux/rmap.h | 2 +-
 mm/migrate.c         | 3 ++-
 mm/rmap.c            | 9 ++++++---
 3 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/include/linux/rmap.h b/include/linux/rmap.h
index a269f80fbeef..94ee38829c63 100644
--- a/include/linux/rmap.h
+++ b/include/linux/rmap.h
@@ -188,7 +188,7 @@ void page_add_file_rmap(struct page *, bool);
 void page_remove_rmap(struct page *, bool);
 
 void hugepage_add_anon_rmap(struct page *, struct vm_area_struct *,
-			    unsigned long);
+			    unsigned long, rmap_t);
 void hugepage_add_new_anon_rmap(struct page *, struct vm_area_struct *,
 				unsigned long);
 
diff --git a/mm/migrate.c b/mm/migrate.c
index 907052b72581..e6b3cb3d148b 100644
--- a/mm/migrate.c
+++ b/mm/migrate.c
@@ -238,7 +238,8 @@ static bool remove_migration_pte(struct page *page, struct vm_area_struct *vma,
 			pte = pte_mkhuge(pte);
 			pte = arch_make_huge_pte(pte, shift, vma->vm_flags);
 			if (PageAnon(new))
-				hugepage_add_anon_rmap(new, vma, pvmw.address);
+				hugepage_add_anon_rmap(new, vma, pvmw.address,
+						       RMAP_NONE);
 			else
 				page_dup_file_rmap(new, true);
 			set_huge_pte_at(vma->vm_mm, pvmw.address, pvmw.pte, pte);
diff --git a/mm/rmap.c b/mm/rmap.c
index 97bcc50c3489..7162689203fc 100644
--- a/mm/rmap.c
+++ b/mm/rmap.c
@@ -2409,9 +2409,11 @@ void rmap_walk_locked(struct page *page, struct rmap_walk_control *rwc)
  * The following two functions are for anonymous (private mapped) hugepages.
  * Unlike common anonymous pages, anonymous hugepages have no accounting code
  * and no lru code, because we handle hugepages differently from common pages.
+ *
+ * RMAP_COMPOUND is ignored.
  */
-void hugepage_add_anon_rmap(struct page *page,
-			    struct vm_area_struct *vma, unsigned long address)
+void hugepage_add_anon_rmap(struct page *page, struct vm_area_struct *vma,
+			    unsigned long address, rmap_t flags)
 {
 	struct anon_vma *anon_vma = vma->anon_vma;
 	int first;
@@ -2421,7 +2423,8 @@ void hugepage_add_anon_rmap(struct page *page,
 	/* address might be in next vma when migration races vma_adjust */
 	first = atomic_inc_and_test(compound_mapcount_ptr(page));
 	if (first)
-		__page_set_anon_rmap(page, vma, address, 0);
+		__page_set_anon_rmap(page, vma, address,
+				     flags & RMAP_EXCLUSIVE);
 }
 
 void hugepage_add_new_anon_rmap(struct page *page,
-- 
2.35.1

[PATCH v2 08/15] mm/rmap: drop "compound" parameter from page_add_new_anon_rmap()

[David Hildenbrand]

New anonymous pages are always mapped natively: only THP/khugepagd code
maps a new compound anonymous page and passes "true". Otherwise, we're
just dealing with simple, non-compound pages.

Let's give the interface clearer semantics and document these.

Signed-off-by: David Hildenbrand <david@redhat.com>
---
 include/linux/rmap.h    |  2 +-
 kernel/events/uprobes.c |  2 +-
 mm/huge_memory.c        |  2 +-
 mm/khugepaged.c         |  2 +-
 mm/memory.c             | 10 +++++-----
 mm/migrate.c            |  2 +-
 mm/rmap.c               |  9 ++++++---
 mm/swapfile.c           |  2 +-
 mm/userfaultfd.c        |  2 +-
 9 files changed, 18 insertions(+), 15 deletions(-)

diff --git a/include/linux/rmap.h b/include/linux/rmap.h
index 94ee38829c63..51953bace0a3 100644
--- a/include/linux/rmap.h
+++ b/include/linux/rmap.h
@@ -183,7 +183,7 @@ void page_move_anon_rmap(struct page *, struct vm_area_struct *);
 void page_add_anon_rmap(struct page *, struct vm_area_struct *,
 		unsigned long, rmap_t);
 void page_add_new_anon_rmap(struct page *, struct vm_area_struct *,
-		unsigned long, bool);
+		unsigned long);
 void page_add_file_rmap(struct page *, bool);
 void page_remove_rmap(struct page *, bool);
 
diff --git a/kernel/events/uprobes.c b/kernel/events/uprobes.c
index 6357c3580d07..b6fdb23fb3ea 100644
--- a/kernel/events/uprobes.c
+++ b/kernel/events/uprobes.c
@@ -184,7 +184,7 @@ static int __replace_page(struct vm_area_struct *vma, unsigned long addr,
 
 	if (new_page) {
 		get_page(new_page);
-		page_add_new_anon_rmap(new_page, vma, addr, false);
+		page_add_new_anon_rmap(new_page, vma, addr);
 		lru_cache_add_inactive_or_unevictable(new_page, vma);
 	} else
 		/* no new page, just dec_mm_counter for old_page */
diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index 2ca137e01e84..c1f7eaba23ff 100644
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -647,7 +647,7 @@ static vm_fault_t __do_huge_pmd_anonymous_page(struct vm_fault *vmf,
 
 		entry = mk_huge_pmd(page, vma->vm_page_prot);
 		entry = maybe_pmd_mkwrite(pmd_mkdirty(entry), vma);
-		page_add_new_anon_rmap(page, vma, haddr, true);
+		page_add_new_anon_rmap(page, vma, haddr);
 		lru_cache_add_inactive_or_unevictable(page, vma);
 		pgtable_trans_huge_deposit(vma->vm_mm, vmf->pmd, pgtable);
 		set_pmd_at(vma->vm_mm, haddr, vmf->pmd, entry);
diff --git a/mm/khugepaged.c b/mm/khugepaged.c
index a325a646be33..96cc903c4788 100644
--- a/mm/khugepaged.c
+++ b/mm/khugepaged.c
@@ -1183,7 +1183,7 @@ static void collapse_huge_page(struct mm_struct *mm,
 
 	spin_lock(pmd_ptl);
 	BUG_ON(!pmd_none(*pmd));
-	page_add_new_anon_rmap(new_page, vma, address, true);
+	page_add_new_anon_rmap(new_page, vma, address);
 	lru_cache_add_inactive_or_unevictable(new_page, vma);
 	pgtable_trans_huge_deposit(mm, pmd, pgtable);
 	set_pmd_at(mm, address, pmd, _pmd);
diff --git a/mm/memory.c b/mm/memory.c
index e2d8e55c55c0..00c45b3a9576 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -896,7 +896,7 @@ copy_present_page(struct vm_area_struct *dst_vma, struct vm_area_struct *src_vma
 	*prealloc = NULL;
 	copy_user_highpage(new_page, page, addr, src_vma);
 	__SetPageUptodate(new_page);
-	page_add_new_anon_rmap(new_page, dst_vma, addr, false);
+	page_add_new_anon_rmap(new_page, dst_vma, addr);
 	lru_cache_add_inactive_or_unevictable(new_page, dst_vma);
 	rss[mm_counter(new_page)]++;
 
@@ -3052,7 +3052,7 @@ static vm_fault_t wp_page_copy(struct vm_fault *vmf)
 		 * some TLBs while the old PTE remains in others.
 		 */
 		ptep_clear_flush_notify(vma, vmf->address, vmf->pte);
-		page_add_new_anon_rmap(new_page, vma, vmf->address, false);
+		page_add_new_anon_rmap(new_page, vma, vmf->address);
 		lru_cache_add_inactive_or_unevictable(new_page, vma);
 		/*
 		 * We call the notify macro here because, when using secondary
@@ -3706,7 +3706,7 @@ vm_fault_t do_swap_page(struct vm_fault *vmf)
 
 	/* ksm created a completely new copy */
 	if (unlikely(page != swapcache && swapcache)) {
-		page_add_new_anon_rmap(page, vma, vmf->address, false);
+		page_add_new_anon_rmap(page, vma, vmf->address);
 		lru_cache_add_inactive_or_unevictable(page, vma);
 	} else {
 		page_add_anon_rmap(page, vma, vmf->address, rmap_flags);
@@ -3856,7 +3856,7 @@ static vm_fault_t do_anonymous_page(struct vm_fault *vmf)
 	}
 
 	inc_mm_counter_fast(vma->vm_mm, MM_ANONPAGES);
-	page_add_new_anon_rmap(page, vma, vmf->address, false);
+	page_add_new_anon_rmap(page, vma, vmf->address);
 	lru_cache_add_inactive_or_unevictable(page, vma);
 setpte:
 	set_pte_at(vma->vm_mm, vmf->address, vmf->pte, entry);
@@ -4033,7 +4033,7 @@ void do_set_pte(struct vm_fault *vmf, struct page *page, unsigned long addr)
 	/* copy-on-write page */
 	if (write && !(vma->vm_flags & VM_SHARED)) {
 		inc_mm_counter_fast(vma->vm_mm, MM_ANONPAGES);
-		page_add_new_anon_rmap(page, vma, addr, false);
+		page_add_new_anon_rmap(page, vma, addr);
 		lru_cache_add_inactive_or_unevictable(page, vma);
 	} else {
 		inc_mm_counter_fast(vma->vm_mm, mm_counter_file(page));
diff --git a/mm/migrate.c b/mm/migrate.c
index e6b3cb3d148b..fd9eba33b34a 100644
--- a/mm/migrate.c
+++ b/mm/migrate.c
@@ -2725,7 +2725,7 @@ static void migrate_vma_insert_page(struct migrate_vma *migrate,
 		goto unlock_abort;
 
 	inc_mm_counter(mm, MM_ANONPAGES);
-	page_add_new_anon_rmap(page, vma, addr, false);
+	page_add_new_anon_rmap(page, vma, addr);
 	if (!is_zone_device_page(page))
 		lru_cache_add_inactive_or_unevictable(page, vma);
 	get_page(page);
diff --git a/mm/rmap.c b/mm/rmap.c
index 7162689203fc..ebe7140c4493 100644
--- a/mm/rmap.c
+++ b/mm/rmap.c
@@ -1184,19 +1184,22 @@ void page_add_anon_rmap(struct page *page,
 }
 
 /**
- * page_add_new_anon_rmap - add pte mapping to a new anonymous page
+ * page_add_new_anon_rmap - add mapping to a new anonymous page
  * @page:	the page to add the mapping to
  * @vma:	the vm area in which the mapping is added
  * @address:	the user virtual address mapped
- * @compound:	charge the page as compound or small page
+ *
+ * If it's a compound page, it is accounted as a compound page. As the page
+ * is new, it's assume to get mapped exclusively by a single process.
  *
  * Same as page_add_anon_rmap but must only be called on *new* pages.
  * This means the inc-and-test can be bypassed.
  * Page does not have to be locked.
  */
 void page_add_new_anon_rmap(struct page *page,
-	struct vm_area_struct *vma, unsigned long address, bool compound)
+	struct vm_area_struct *vma, unsigned long address)
 {
+	const bool compound = PageCompound(page);
 	int nr = compound ? thp_nr_pages(page) : 1;
 
 	VM_BUG_ON_VMA(address < vma->vm_start || address >= vma->vm_end, vma);
diff --git a/mm/swapfile.c b/mm/swapfile.c
index 41ba8238d16b..7edc8e099b22 100644
--- a/mm/swapfile.c
+++ b/mm/swapfile.c
@@ -1802,7 +1802,7 @@ static int unuse_pte(struct vm_area_struct *vma, pmd_t *pmd,
 	if (page == swapcache) {
 		page_add_anon_rmap(page, vma, addr, RMAP_NONE);
 	} else { /* ksm created a completely new copy */
-		page_add_new_anon_rmap(page, vma, addr, false);
+		page_add_new_anon_rmap(page, vma, addr);
 		lru_cache_add_inactive_or_unevictable(page, vma);
 	}
 	set_pte_at(vma->vm_mm, addr, pte,
diff --git a/mm/userfaultfd.c b/mm/userfaultfd.c
index 0780c2a57ff1..4ca854ce14f0 100644
--- a/mm/userfaultfd.c
+++ b/mm/userfaultfd.c
@@ -98,7 +98,7 @@ int mfill_atomic_install_pte(struct mm_struct *dst_mm, pmd_t *dst_pmd,
 	if (page_in_cache)
 		page_add_file_rmap(page, false);
 	else
-		page_add_new_anon_rmap(page, dst_vma, dst_addr, false);
+		page_add_new_anon_rmap(page, dst_vma, dst_addr);
 
 	/*
 	 * Must happen after rmap, as mm_counter() checks mapping (via
-- 
2.35.1

[PATCH v2 09/15] mm/rmap: use page_move_anon_rmap() when reusing a mapped PageAnon() page exclusively

[David Hildenbrand]

We want to mark anonymous pages exclusive, and when using
page_move_anon_rmap() we know that we are the exclusive user, as
properly documented. This is a preparation for marking anonymous pages
exclusive in page_move_anon_rmap().

In both instances, we're holding page lock and are sure that we're the
exclusive owner (page_count() == 1). hugetlb already properly uses
page_move_anon_rmap() in the write fault handler.

Note that in case of a PTE-mapped THP, we'll only end up calling this
function if the whole THP is only referenced by the single PTE mapping
a single subpage (page_count() == 1); consequently, it's fine to modify
the compound page mapping inside page_move_anon_rmap().

Signed-off-by: David Hildenbrand <david@redhat.com>
---
 mm/huge_memory.c | 2 ++
 mm/memory.c      | 1 +
 2 files changed, 3 insertions(+)

diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index c1f7eaba23ff..0b6fb409b9e4 100644
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -1317,6 +1317,8 @@ vm_fault_t do_huge_pmd_wp_page(struct vm_fault *vmf)
 		try_to_free_swap(page);
 	if (page_count(page) == 1) {
 		pmd_t entry;
+
+		page_move_anon_rmap(page, vma);
 		entry = pmd_mkyoung(orig_pmd);
 		entry = maybe_pmd_mkwrite(pmd_mkdirty(entry), vma);
 		if (pmdp_set_access_flags(vma, haddr, vmf->pmd, entry, 1))
diff --git a/mm/memory.c b/mm/memory.c
index 00c45b3a9576..7b32f422798d 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -3307,6 +3307,7 @@ static vm_fault_t do_wp_page(struct vm_fault *vmf)
 		 * and the page is locked, it's dark out, and we're wearing
 		 * sunglasses. Hit it.
 		 */
+		page_move_anon_rmap(page, vma);
 		unlock_page(page);
 		wp_page_reuse(vmf);
 		return VM_FAULT_WRITE;
-- 
2.35.1

[PATCH v2 10/15] mm/page-flags: reuse PG_mappedtodisk as PG_anon_exclusive for PageAnon() pages

[David Hildenbrand]

The basic question we would like to have a reliable and efficient answer
to is: is this anonymous page exclusive to a single process or might it
be shared? We need that information for ordinary/single pages, hugetlb
pages, and possibly each subpage of a THP.

Introduce a way to mark an anonymous page as exclusive, with the
ultimate goal of teaching our COW logic to not do "wrong COWs", whereby
GUP pins lose consistency with the pages mapped into the page table,
resulting in reported memory corruptions.

Most pageflags already have semantics for anonymous pages, however,
PG_mappedtodisk should never apply to pages in the swapcache, so let's
reuse that flag.

As PG_has_hwpoisoned also uses that flag on the second tail page of a
compound page, convert it to PG_error instead, which is marked as
PF_NO_TAIL, so never used for tail pages.

Use custom page flag modification functions such that we can do
additional sanity checks. The semantics we'll put into some kernel doc
in the future are:

"
  PG_anon_exclusive is *usually* only expressive in combination with a
  page table entry. Depending on the page table entry type it might
  store the following information:

       Is what's mapped via this page table entry exclusive to the
       single process and can be mapped writable without further
       checks? If not, it might be shared and we might have to COW.

  For now, we only expect PTE-mapped THPs to make use of
  PG_anon_exclusive in subpages. For other anonymous compound
  folios (i.e., hugetlb), only the head page is logically mapped and
  holds this information.

  For example, an exclusive, PMD-mapped THP only has PG_anon_exclusive
  set on the head page. When replacing the PMD by a page table full
  of PTEs, PG_anon_exclusive, if set on the head page, will be set on
  all tail pages accordingly. Note that converting from a PTE-mapping
  to a PMD mapping using the same compound page is currently not
  possible and consequently doesn't require care.

  If GUP wants to take a reliable pin (FOLL_PIN) on an anonymous page,
  it should only pin if the relevant PG_anon_bit is set. In that case,
  the pin will be fully reliable and stay consistent with the pages
  mapped into the page table, as the bit cannot get cleared (e.g., by
  fork(), KSM) while the page is pinned. For anonymous pages that
  are mapped R/W, PG_anon_exclusive can be assumed to always be set
  because such pages cannot possibly be shared.

  The page table lock protecting the page table entry is the primary
  synchronization mechanism for PG_anon_exclusive; GUP-fast that does
  not take the PT lock needs special care when trying to clear the
  flag.

  Page table entry types and PG_anon_exclusive:
  * Present: PG_anon_exclusive applies.
  * Swap: the information is lost. PG_anon_exclusive was cleared.
  * Migration: the entry holds this information instead.
               PG_anon_exclusive was cleared.
  * Device private: PG_anon_exclusive applies.
  * Device exclusive: PG_anon_exclusive applies.
  * HW Poison: PG_anon_exclusive is stale and not changed.

  If the page may be pinned (FOLL_PIN), clearing PG_anon_exclusive is
  not allowed and the flag will stick around until the page is freed
  and folio->mapping is cleared.
"

We won't be clearing PG_anon_exclusive on destructive unmapping (i.e.,
zapping) of page table entries, page freeing code will handle that when
also invalidate page->mapping to not indicate PageAnon() anymore.
Letting information about exclusivity stick around will be an important
property when adding sanity checks to unpinning code.

Note that we properly clear the flag in free_pages_prepare() via
PAGE_FLAGS_CHECK_AT_PREP for each individual subpage of a compound page,
so there is no need to manually clear the flag.

Signed-off-by: David Hildenbrand <david@redhat.com>
---
 include/linux/page-flags.h | 39 +++++++++++++++++++++++++++++++++++++-
 mm/hugetlb.c               |  2 ++
 mm/memory.c                | 11 +++++++++++
 mm/memremap.c              |  9 +++++++++
 mm/swapfile.c              |  4 ++++
 tools/vm/page-types.c      |  8 +++++++-
 6 files changed, 71 insertions(+), 2 deletions(-)

diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
index 1c3b6e5c8bfd..e905247dd984 100644
--- a/include/linux/page-flags.h
+++ b/include/linux/page-flags.h
@@ -142,6 +142,15 @@ enum pageflags {
 
 	PG_readahead = PG_reclaim,
 
+	/*
+	 * Depending on the way an anonymous folio can be mapped into a page
+	 * table (e.g., single PMD/PUD/CONT of the head page vs. PTE-mapped
+	 * THP), PG_anon_exclusive may be set only for the head page or for
+	 * tail pages of an anonymous folio. For now, we only expect it to be
+	 * set on tail pages for PTE-mapped THP.
+	 */
+	PG_anon_exclusive = PG_mappedtodisk,
+
 	/* Filesystems */
 	PG_checked = PG_owner_priv_1,
 
@@ -176,7 +185,7 @@ enum pageflags {
 	 * Indicates that at least one subpage is hwpoisoned in the
 	 * THP.
 	 */
-	PG_has_hwpoisoned = PG_mappedtodisk,
+	PG_has_hwpoisoned = PG_error,
 #endif
 
 	/* non-lru isolated movable page */
@@ -920,6 +929,34 @@ extern bool is_free_buddy_page(struct page *page);
 
 __PAGEFLAG(Isolated, isolated, PF_ANY);
 
+static __always_inline int PageAnonExclusive(struct page *page)
+{
+	VM_BUG_ON_PGFLAGS(!PageAnon(page), page);
+	VM_BUG_ON_PGFLAGS(PageHuge(page) && !PageHead(page), page);
+	return test_bit(PG_anon_exclusive, &PF_ANY(page, 1)->flags);
+}
+
+static __always_inline void SetPageAnonExclusive(struct page *page)
+{
+	VM_BUG_ON_PGFLAGS(!PageAnon(page) || PageKsm(page), page);
+	VM_BUG_ON_PGFLAGS(PageHuge(page) && !PageHead(page), page);
+	set_bit(PG_anon_exclusive, &PF_ANY(page, 1)->flags);
+}
+
+static __always_inline void ClearPageAnonExclusive(struct page *page)
+{
+	VM_BUG_ON_PGFLAGS(!PageAnon(page) || PageKsm(page), page);
+	VM_BUG_ON_PGFLAGS(PageHuge(page) && !PageHead(page), page);
+	clear_bit(PG_anon_exclusive, &PF_ANY(page, 1)->flags);
+}
+
+static __always_inline void __ClearPageAnonExclusive(struct page *page)
+{
+	VM_BUG_ON_PGFLAGS(!PageAnon(page), page);
+	VM_BUG_ON_PGFLAGS(PageHuge(page) && !PageHead(page), page);
+	__clear_bit(PG_anon_exclusive, &PF_ANY(page, 1)->flags);
+}
+
 #ifdef CONFIG_MMU
 #define __PG_MLOCKED		(1UL << PG_mlocked)
 #else
diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index 9fb990d95dab..1ff0b9e1e28e 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -1669,6 +1669,8 @@ void free_huge_page(struct page *page)
 	VM_BUG_ON_PAGE(page_mapcount(page), page);
 
 	hugetlb_set_page_subpool(page, NULL);
+	if (PageAnon(page))
+		__ClearPageAnonExclusive(page);
 	page->mapping = NULL;
 	restore_reserve = HPageRestoreReserve(page);
 	ClearHPageRestoreReserve(page);
diff --git a/mm/memory.c b/mm/memory.c
index 7b32f422798d..d01fab481134 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -3671,6 +3671,17 @@ vm_fault_t do_swap_page(struct vm_fault *vmf)
 		goto out_nomap;
 	}
 
+	/*
+	 * PG_anon_exclusive reuses PG_mappedtodisk for anon pages. A swap pte
+	 * must never point at an anonymous page in the swapcache that is
+	 * PG_anon_exclusive. Sanity check that this holds and especially, that
+	 * no filesystem set PG_mappedtodisk on a page in the swapcache. Sanity
+	 * check after taking the PT lock and making sure that nobody
+	 * concurrently faulted in this page and set PG_anon_exclusive.
+	 */
+	BUG_ON(!PageAnon(page) && PageMappedToDisk(page));
+	BUG_ON(PageAnon(page) && PageAnonExclusive(page));
+
 	/*
 	 * Remove the swap entry and conditionally try to free up the swapcache.
 	 * We're already holding a reference on the page but haven't mapped it
diff --git a/mm/memremap.c b/mm/memremap.c
index 6aa5f0c2d11f..160ea92e4e17 100644
--- a/mm/memremap.c
+++ b/mm/memremap.c
@@ -478,6 +478,15 @@ void free_devmap_managed_page(struct page *page)
 
 	mem_cgroup_uncharge(page_folio(page));
 
+	/*
+	 * Note: we don't expect anonymous compound pages yet. Once supported
+	 * and we could PTE-map them similar to THP, we'd have to clear
+	 * PG_anon_exclusive on all tail pages.
+	 */
+	VM_BUG_ON_PAGE(PageAnon(page) && PageCompound(page), page);
+	if (PageAnon(page))
+		__ClearPageAnonExclusive(page);
+
 	/*
 	 * When a device_private page is freed, the page->mapping field
 	 * may still contain a (stale) mapping value. For example, the
diff --git a/mm/swapfile.c b/mm/swapfile.c
index 7edc8e099b22..493acb967b7a 100644
--- a/mm/swapfile.c
+++ b/mm/swapfile.c
@@ -1796,6 +1796,10 @@ static int unuse_pte(struct vm_area_struct *vma, pmd_t *pmd,
 		goto out;
 	}
 
+	/* See do_swap_page() */
+	BUG_ON(!PageAnon(page) && PageMappedToDisk(page));
+	BUG_ON(PageAnon(page) && PageAnonExclusive(page));
+
 	dec_mm_counter(vma->vm_mm, MM_SWAPENTS);
 	inc_mm_counter(vma->vm_mm, MM_ANONPAGES);
 	get_page(page);
diff --git a/tools/vm/page-types.c b/tools/vm/page-types.c
index b1ed76d9a979..381dcc00cb62 100644
--- a/tools/vm/page-types.c
+++ b/tools/vm/page-types.c
@@ -80,9 +80,10 @@
 #define KPF_SOFTDIRTY		40
 #define KPF_ARCH_2		41
 
-/* [48-] take some arbitrary free slots for expanding overloaded flags
+/* [47-] take some arbitrary free slots for expanding overloaded flags
  * not part of kernel API
  */
+#define KPF_ANON_EXCLUSIVE	47
 #define KPF_READAHEAD		48
 #define KPF_SLOB_FREE		49
 #define KPF_SLUB_FROZEN		50
@@ -138,6 +139,7 @@ static const char * const page_flag_names[] = {
 	[KPF_SOFTDIRTY]		= "f:softdirty",
 	[KPF_ARCH_2]		= "H:arch_2",
 
+	[KPF_ANON_EXCLUSIVE]	= "d:anon_exclusive",
 	[KPF_READAHEAD]		= "I:readahead",
 	[KPF_SLOB_FREE]		= "P:slob_free",
 	[KPF_SLUB_FROZEN]	= "A:slub_frozen",
@@ -472,6 +474,10 @@ static int bit_mask_ok(uint64_t flags)
 
 static uint64_t expand_overloaded_flags(uint64_t flags, uint64_t pme)
 {
+	/* Anonymous pages overload PG_mappedtodisk */
+	if ((flags & BIT(ANON)) && (flags & BIT(MAPPEDTODISK)))
+		flags ^= BIT(MAPPEDTODISK) | BIT(ANON_EXCLUSIVE);
+
 	/* SLOB/SLUB overload several page flags */
 	if (flags & BIT(SLAB)) {
 		if (flags & BIT(PRIVATE))
-- 
2.35.1

[PATCH v2 11/15] mm: remember exclusively mapped anonymous pages with PG_anon_exclusive

[David Hildenbrand]

Let's mark exclusively mapped anonymous pages with PG_anon_exclusive as
exclusive, and use that information to make GUP pins reliable and stay
consistent with the page mapped into the page table even if the
page table entry gets write-protected.

With that information at hand, we can extend our COW logic to always
reuse anonymous pages that are exclusive. For anonymous pages that
might be shared, the existing logic applies.

As already documented, PG_anon_exclusive is usually only expressive in
combination with a page table entry. Especially PTE vs. PMD-mapped
anonymous pages require more thought, some examples: due to mremap() we
can easily have a single compound page PTE-mapped into multiple page tables
exclusively in a single process -- multiple page table locks apply.
Further, due to MADV_WIPEONFORK we might not necessarily write-protect
all PTEs, and only some subpages might be pinned. Long story short: once
PTE-mapped, we have to track information about exclusivity per sub-page,
but until then, we can just track it for the compound page in the head
page and not having to update a whole bunch of subpages all of the time
for a simple PMD mapping of a THP.

For simplicity, this commit mostly talks about "anonymous pages", while
it's for THP actually "the part of an anonymous folio referenced via
a page table entry".

To not spill PG_anon_exclusive code all over the mm code-base, we let
the anon rmap code to handle all PG_anon_exclusive logic it can easily
handle.

If a writable, present page table entry points at an anonymous (sub)page,
that (sub)page must be PG_anon_exclusive. If GUP wants to take a reliably
pin (FOLL_PIN) on an anonymous page references via a present
page table entry, it must only pin if PG_anon_exclusive is set for the
mapped (sub)page.

This commit doesn't adjust GUP, so this is only implicitly handled for
FOLL_WRITE, follow-up commits will teach GUP to also respect it for
FOLL_PIN without !FOLL_WRITE, to make all GUP pins of anonymous pages
fully reliable.

Whenever an anonymous page is to be shared (fork(), KSM), or when
temporarily unmapping an anonymous page (swap, migration), the relevant
PG_anon_exclusive bit has to be cleared to mark the anonymous page
possibly shared. Clearing will fail if there are GUP pins on the page:
* For fork(), this means having to copy the page and not being able to
  share it. fork() protects against concurrent GUP using the PT lock and
  the src_mm->write_protect_seq.
* For KSM, this means sharing will fail. For swap this means, unmapping
  will fail, For migration this means, migration will fail early. All
  three cases protect against concurrent GUP using the PT lock and a
  proper clear/invalidate+flush of the relevant page table entry.

This fixes memory corruptions reported for FOLL_PIN | FOLL_WRITE, when a
pinned page gets mapped R/O and the successive write fault ends up
replacing the page instead of reusing it. It improves the situation for
O_DIRECT/vmsplice/... that still use FOLL_GET instead of FOLL_PIN,
if fork() is *not* involved, however swapout and fork() are still
problematic. Properly using FOLL_PIN instead of FOLL_GET for these
GUP users will fix the issue for them.

I. Details about basic handling

I.1. Fresh anonymous pages

page_add_new_anon_rmap() and hugepage_add_new_anon_rmap() will mark the
given page exclusive via __page_set_anon_rmap(exclusive=1). As that is
the mechanism fresh anonymous pages come into life (besides migration
code where we copy the page->mapping), all fresh anonymous pages will
start out as exclusive.

I.2. COW reuse handling of anonymous pages

When a COW handler stumbles over a (sub)page that's marked exclusive, it
simply reuses it. Otherwise, the handler tries harder under page lock to
detect if the (sub)page is exclusive and can be reused. If exclusive,
page_move_anon_rmap() will mark the given (sub)page exclusive.

Note that hugetlb code does not yet check for PageAnonExclusive(), as it
still uses the old COW logic that is prone to the COW security issue
because hugetlb code cannot really tolerate unnecessary/wrong COW as
huge pages are a scarce resource.

I.3. Migration handling

try_to_migrate() has to try marking an exclusive anonymous page shared
via page_try_share_anon_rmap(). If it fails because there are GUP pins
on the page, unmap fails. migrate_vma_collect_pmd() and
__split_huge_pmd_locked() are handled similarly.

Writable migration entries implicitly point at shared anonymous pages.
For readable migration entries that information is stored via a new
"readable-exclusive" migration entry, specific to anonymous pages.

When restoring a migration entry in remove_migration_pte(), information
about exlusivity is detected via the migration entry type, and
RMAP_EXCLUSIVE is set accordingly for
page_add_anon_rmap()/hugepage_add_anon_rmap() to restore that
information.

I.4. Swapout handling

try_to_unmap() has to try marking the mapped page possibly shared via
page_try_share_anon_rmap(). If it fails because there are GUP pins on the
page, unmap fails. For now, information about exclusivity is lost. In the
future, we might want to remember that information in the swap entry in
some cases, however, it requires more thought, care, and a way to store
that information in swap entries.

I.5. Swapin handling

do_swap_page() will never stumble over exclusive anonymous pages in the
swap cache, as try_to_migrate() prohibits that. do_swap_page() always has
to detect manually if an anonymous page is exclusive and has to set
RMAP_EXCLUSIVE for page_add_anon_rmap() accordingly.

I.6. THP handling

__split_huge_pmd_locked() has to move the information about exclusivity
from the PMD to the PTEs.

a) In case we have a readable-exclusive PMD migration entry, simply insert
readable-exclusive PTE migration entries.

b) In case we have a present PMD entry and we don't want to freeze
("convert to migration entries"), simply forward PG_anon_exclusive to
all sub-pages, no need to temporarily clear the bit.

c) In case we have a present PMD entry and want to freeze, handle it
similar to try_to_migrate(): try marking the page shared first. In case
we fail, we ignore the "freeze" instruction and simply split ordinarily.
try_to_migrate() will properly fail because the THP is still mapped via
PTEs.

When splitting a compound anonymous folio (THP), the information about
exclusivity is implicitly handled via the migration entries: no need to
replicate PG_anon_exclusive manually.

I.7. fork() handling

fork() handling is relatively easy, because PG_anon_exclusive is only
expressive for some page table entry types.

a) Present anonymous pages

page_try_dup_anon_rmap() will mark the given subpage shared -- which
will fail if the page is pinned. If it failed, we have to copy (or
PTE-map a PMD to handle it on the PTE level).

Note that device exclusive entries are just a pointer at a PageAnon()
page. fork() will first convert a device exclusive entry to a present
page table and handle it just like present anonymous pages.

b) Device private entry

Device private entries point at PageAnon() pages that cannot be mapped
directly and, therefore, cannot get pinned.

page_try_dup_anon_rmap() will mark the given subpage shared, which
cannot fail because they cannot get pinned.

c) HW poison entries

PG_anon_exclusive will remain untouched and is stale -- the page table
entry is just a placeholder after all.

d) Migration entries

Writable and readable-exclusive entries are converted to readable
entries: possibly shared.

I.8. mprotect() handling

mprotect() only has to properly handle the new readable-exclusive
migration entry:

When write-protecting a migration entry that points at an anonymous
page, remember the information about exclusivity via the
"readable-exclusive" migration entry type.

II. Migration and GUP-fast

Whenever replacing a present page table entry that maps an exclusive
anonymous page by a migration entry, we have to mark the page possibly
shared and synchronize against GUP-fast by a proper
clear/invalidate+flush to make the following scenario impossible:

1. try_to_migrate() places a migration entry after checking for GUP pins
   and marks the page possibly shared.
2. GUP-fast pins the page due to lack of synchronization
3. fork() converts the "writable/readable-exclusive" migration entry into a
   readable migration entry
4. Migration fails due to the GUP pin (failing to freeze the refcount)
5. Migration entries are restored. PG_anon_exclusive is lost

-> We have a pinned page that is not marked exclusive anymore.

Note that we move information about exclusivity from the page to the
migration entry as it otherwise highly overcomplicates fork() and
PTE-mapping a THP.

III. Swapout and GUP-fast

Whenever replacing a present page table entry that maps an exclusive
anonymous page by a swap entry, we have to mark the page possibly
shared and synchronize against GUP-fast by a proper
clear/invalidate+flush to make the following scenario impossible:

1. try_to_unmap() places a swap entry after checking for GUP pins and
   clears exclusivity information on the page.
2. GUP-fast pins the page due to lack of synchronization.

-> We have a pinned page that is not marked exclusive anymore.

If we'd ever store information about exclusivity in the swap entry,
similar to migration handling, the same considerations as in II would
apply. This is future work.

Signed-off-by: David Hildenbrand <david@redhat.com>
---
 include/linux/rmap.h    | 40 +++++++++++++++++++++
 include/linux/swap.h    | 15 +++++---
 include/linux/swapops.h | 25 +++++++++++++
 mm/huge_memory.c        | 77 +++++++++++++++++++++++++++++++++++++----
 mm/hugetlb.c            | 15 +++++---
 mm/ksm.c                | 13 ++++++-
 mm/memory.c             | 33 +++++++++++++-----
 mm/migrate.c            | 34 ++++++++++++++++--
 mm/mprotect.c           |  8 +++--
 mm/rmap.c               | 59 ++++++++++++++++++++++++++++---
 10 files changed, 285 insertions(+), 34 deletions(-)

diff --git a/include/linux/rmap.h b/include/linux/rmap.h
index 51953bace0a3..1aef834e1d60 100644
--- a/include/linux/rmap.h
+++ b/include/linux/rmap.h
@@ -224,6 +224,13 @@ static inline int page_try_dup_anon_rmap(struct page *page, bool compound,
 {
 	VM_BUG_ON_PAGE(!PageAnon(page), page);
 
+	/*
+	 * No need to check+clear for already shared pages, including KSM
+	 * pages.
+	 */
+	if (!PageAnonExclusive(page))
+		goto dup;
+
 	/*
 	 * If this page may have been pinned by the parent process,
 	 * don't allow to duplicate the mapping but instead require to e.g.,
@@ -235,14 +242,47 @@ static inline int page_try_dup_anon_rmap(struct page *page, bool compound,
 	    unlikely(page_needs_cow_for_dma(vma, page))))
 		return -EBUSY;
 
+	ClearPageAnonExclusive(page);
 	/*
 	 * It's okay to share the anon page between both processes, mapping
 	 * the page R/O into both processes.
 	 */
+dup:
 	__page_dup_rmap(page, compound);
 	return 0;
 }
 
+/**
+ * page_try_share_anon_rmap - try marking an exclusive anonymous page possibly
+ *			      shared to prepare for KSM or temporary unmapping
+ * @page: the exclusive anonymous page to try marking possibly shared
+ *
+ * The caller needs to hold the PT lock and has to have the page table entry
+ * cleared/invalidated+flushed, to properly sync against GUP-fast.
+ *
+ * This is similar to page_try_dup_anon_rmap(), however, not used during fork()
+ * to duplicate a mapping, but instead to prepare for KSM or temporarily
+ * unmapping a page (swap, migration) via page_remove_rmap().
+ *
+ * Marking the page shared can only fail if the page may be pinned; device
+ * private pages cannot get pinned and consequently this function cannot fail.
+ *
+ * Returns 0 if marking the page possibly shared succeeded. Returns -EBUSY
+ * otherwise.
+ */
+static inline int page_try_share_anon_rmap(struct page *page)
+{
+	VM_BUG_ON_PAGE(!PageAnon(page) || !PageAnonExclusive(page), page);
+
+	/* See page_try_dup_anon_rmap(). */
+	if (likely(!is_device_private_page(page) &&
+	    unlikely(page_maybe_dma_pinned(page))))
+		return -EBUSY;
+
+	ClearPageAnonExclusive(page);
+	return 0;
+}
+
 /*
  * Called from mm/vmscan.c to handle paging out
  */
diff --git a/include/linux/swap.h b/include/linux/swap.h
index b546e4bd5c5a..422765d1141c 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -78,12 +78,19 @@ static inline int current_is_kswapd(void)
 #endif
 
 /*
- * NUMA node memory migration support
+ * Page migration support.
+ *
+ * SWP_MIGRATION_READ_EXCLUSIVE is only applicable to anonymous pages and
+ * indicates that the referenced (part of) an anonymous page is exclusive to
+ * a single process. For SWP_MIGRATION_WRITE, that information is implicit:
+ * (part of) an anonymous page that are mapped writable are exclusive to a
+ * single process.
  */
 #ifdef CONFIG_MIGRATION
-#define SWP_MIGRATION_NUM 2
-#define SWP_MIGRATION_READ	(MAX_SWAPFILES + SWP_HWPOISON_NUM)
-#define SWP_MIGRATION_WRITE	(MAX_SWAPFILES + SWP_HWPOISON_NUM + 1)
+#define SWP_MIGRATION_NUM 3
+#define SWP_MIGRATION_READ (MAX_SWAPFILES + SWP_HWPOISON_NUM)
+#define SWP_MIGRATION_READ_EXCLUSIVE (MAX_SWAPFILES + SWP_HWPOISON_NUM + 1)
+#define SWP_MIGRATION_WRITE (MAX_SWAPFILES + SWP_HWPOISON_NUM + 2)
 #else
 #define SWP_MIGRATION_NUM 0
 #endif
diff --git a/include/linux/swapops.h b/include/linux/swapops.h
index d356ab4047f7..06280fc1c99b 100644
--- a/include/linux/swapops.h
+++ b/include/linux/swapops.h
@@ -194,6 +194,7 @@ static inline bool is_writable_device_exclusive_entry(swp_entry_t entry)
 static inline int is_migration_entry(swp_entry_t entry)
 {
 	return unlikely(swp_type(entry) == SWP_MIGRATION_READ ||
+			swp_type(entry) == SWP_MIGRATION_READ_EXCLUSIVE ||
 			swp_type(entry) == SWP_MIGRATION_WRITE);
 }
 
@@ -202,11 +203,26 @@ static inline int is_writable_migration_entry(swp_entry_t entry)
 	return unlikely(swp_type(entry) == SWP_MIGRATION_WRITE);
 }
 
+static inline int is_readable_migration_entry(swp_entry_t entry)
+{
+	return unlikely(swp_type(entry) == SWP_MIGRATION_READ);
+}
+
+static inline int is_readable_exclusive_migration_entry(swp_entry_t entry)
+{
+	return unlikely(swp_type(entry) == SWP_MIGRATION_READ_EXCLUSIVE);
+}
+
 static inline swp_entry_t make_readable_migration_entry(pgoff_t offset)
 {
 	return swp_entry(SWP_MIGRATION_READ, offset);
 }
 
+static inline swp_entry_t make_readable_exclusive_migration_entry(pgoff_t offset)
+{
+	return swp_entry(SWP_MIGRATION_READ_EXCLUSIVE, offset);
+}
+
 static inline swp_entry_t make_writable_migration_entry(pgoff_t offset)
 {
 	return swp_entry(SWP_MIGRATION_WRITE, offset);
@@ -224,6 +240,11 @@ static inline swp_entry_t make_readable_migration_entry(pgoff_t offset)
 	return swp_entry(0, 0);
 }
 
+static inline swp_entry_t make_readable_exclusive_migration_entry(pgoff_t offset)
+{
+	return swp_entry(0, 0);
+}
+
 static inline swp_entry_t make_writable_migration_entry(pgoff_t offset)
 {
 	return swp_entry(0, 0);
@@ -244,6 +265,10 @@ static inline int is_writable_migration_entry(swp_entry_t entry)
 {
 	return 0;
 }
+static inline int is_readable_migration_entry(swp_entry_t entry)
+{
+	return 0;
+}
 
 #endif
 
diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index 0b6fb409b9e4..4872e7120ee1 100644
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -1054,7 +1054,7 @@ int copy_huge_pmd(struct mm_struct *dst_mm, struct mm_struct *src_mm,
 		swp_entry_t entry = pmd_to_swp_entry(pmd);
 
 		VM_BUG_ON(!is_pmd_migration_entry(pmd));
-		if (is_writable_migration_entry(entry)) {
+		if (!is_readable_migration_entry(entry)) {
 			entry = make_readable_migration_entry(
 							swp_offset(entry));
 			pmd = swp_entry_to_pmd(entry);
@@ -1292,6 +1292,10 @@ vm_fault_t do_huge_pmd_wp_page(struct vm_fault *vmf)
 	page = pmd_page(orig_pmd);
 	VM_BUG_ON_PAGE(!PageHead(page), page);
 
+	/* Early check when only holding the PT lock. */
+	if (PageAnonExclusive(page))
+		goto reuse;
+
 	if (!trylock_page(page)) {
 		get_page(page);
 		spin_unlock(vmf->ptl);
@@ -1306,6 +1310,12 @@ vm_fault_t do_huge_pmd_wp_page(struct vm_fault *vmf)
 		put_page(page);
 	}
 
+	/* Recheck after temporarily dropping the PT lock. */
+	if (PageAnonExclusive(page)) {
+		unlock_page(page);
+		goto reuse;
+	}
+
 	/*
 	 * See do_wp_page(): we can only map the page writable if there are
 	 * no additional references. Note that we always drain the LRU
@@ -1319,11 +1329,12 @@ vm_fault_t do_huge_pmd_wp_page(struct vm_fault *vmf)
 		pmd_t entry;
 
 		page_move_anon_rmap(page, vma);
+		unlock_page(page);
+reuse:
 		entry = pmd_mkyoung(orig_pmd);
 		entry = maybe_pmd_mkwrite(pmd_mkdirty(entry), vma);
 		if (pmdp_set_access_flags(vma, haddr, vmf->pmd, entry, 1))
 			update_mmu_cache_pmd(vma, vmf->address, vmf->pmd);
-		unlock_page(page);
 		spin_unlock(vmf->ptl);
 		return VM_FAULT_WRITE;
 	}
@@ -1741,6 +1752,7 @@ int change_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd,
 #ifdef CONFIG_ARCH_ENABLE_THP_MIGRATION
 	if (is_swap_pmd(*pmd)) {
 		swp_entry_t entry = pmd_to_swp_entry(*pmd);
+		struct page *page = pfn_swap_entry_to_page(entry);
 
 		VM_BUG_ON(!is_pmd_migration_entry(*pmd));
 		if (is_writable_migration_entry(entry)) {
@@ -1749,8 +1761,10 @@ int change_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd,
 			 * A protection check is difficult so
 			 * just be safe and disable write
 			 */
-			entry = make_readable_migration_entry(
-							swp_offset(entry));
+			if (PageAnon(page))
+				entry = make_readable_exclusive_migration_entry(swp_offset(entry));
+			else
+				entry = make_readable_migration_entry(swp_offset(entry));
 			newpmd = swp_entry_to_pmd(entry);
 			if (pmd_swp_soft_dirty(*pmd))
 				newpmd = pmd_swp_mksoft_dirty(newpmd);
@@ -1959,6 +1973,7 @@ static void __split_huge_pmd_locked(struct vm_area_struct *vma, pmd_t *pmd,
 	pgtable_t pgtable;
 	pmd_t old_pmd, _pmd;
 	bool young, write, soft_dirty, pmd_migration = false, uffd_wp = false;
+	bool anon_exclusive = false;
 	unsigned long addr;
 	int i;
 
@@ -2040,6 +2055,8 @@ static void __split_huge_pmd_locked(struct vm_area_struct *vma, pmd_t *pmd,
 		entry = pmd_to_swp_entry(old_pmd);
 		page = pfn_swap_entry_to_page(entry);
 		write = is_writable_migration_entry(entry);
+		if (PageAnon(page))
+			anon_exclusive = is_readable_exclusive_migration_entry(entry);
 		young = false;
 		soft_dirty = pmd_swp_soft_dirty(old_pmd);
 		uffd_wp = pmd_swp_uffd_wp(old_pmd);
@@ -2051,6 +2068,23 @@ static void __split_huge_pmd_locked(struct vm_area_struct *vma, pmd_t *pmd,
 		young = pmd_young(old_pmd);
 		soft_dirty = pmd_soft_dirty(old_pmd);
 		uffd_wp = pmd_uffd_wp(old_pmd);
+
+		/*
+		 * Without "freeze", we'll simply split the PMD, propagating the
+		 * PageAnonExclusive() flag for each PTE by setting it for
+		 * each subpage -- no need to (temporarily) clear.
+		 *
+		 * With "freeze" we want to replace mapped pages by
+		 * migration entries right away. This is only possible if we
+		 * managed to clear PageAnonExclusive() -- see
+		 * set_pmd_migration_entry().
+		 *
+		 * In case we cannot clear PageAnonExclusive(), split the PMD
+		 * only and let try_to_migrate_one() fail later.
+		 */
+		anon_exclusive = PageAnon(page) && PageAnonExclusive(page);
+		if (freeze && anon_exclusive && page_try_share_anon_rmap(page))
+			freeze = false;
 	}
 	VM_BUG_ON_PAGE(!page_count(page), page);
 	page_ref_add(page, HPAGE_PMD_NR - 1);
@@ -2074,6 +2108,9 @@ static void __split_huge_pmd_locked(struct vm_area_struct *vma, pmd_t *pmd,
 			if (write)
 				swp_entry = make_writable_migration_entry(
 							page_to_pfn(page + i));
+			else if (anon_exclusive)
+				swp_entry = make_readable_exclusive_migration_entry(
+							page_to_pfn(page + i));
 			else
 				swp_entry = make_readable_migration_entry(
 							page_to_pfn(page + i));
@@ -2085,6 +2122,8 @@ static void __split_huge_pmd_locked(struct vm_area_struct *vma, pmd_t *pmd,
 		} else {
 			entry = mk_pte(page + i, READ_ONCE(vma->vm_page_prot));
 			entry = maybe_mkwrite(entry, vma);
+			if (anon_exclusive)
+				SetPageAnonExclusive(page + i);
 			if (!write)
 				entry = pte_wrprotect(entry);
 			if (!young)
@@ -2315,6 +2354,13 @@ static void __split_huge_page_tail(struct page *head, int tail,
 	 *
 	 * After successful get_page_unless_zero() might follow flags change,
 	 * for example lock_page() which set PG_waiters.
+	 *
+	 * Note that for mapped sub-pages of an anonymous THP,
+	 * PG_anon_exclusive has been cleared in unmap_page() and is stored in
+	 * the migration entry instead from where remap_page() will restore it.
+	 * We can still have PG_anon_exclusive set on effectively unmapped and
+	 * unreferenced sub-pages of an anonymous THP: we can simply drop
+	 * PG_anon_exclusive (-> PG_mappedtodisk) for these here.
 	 */
 	page_tail->flags &= ~PAGE_FLAGS_CHECK_AT_PREP;
 	page_tail->flags |= (head->flags &
@@ -3070,6 +3116,7 @@ void set_pmd_migration_entry(struct page_vma_mapped_walk *pvmw,
 	struct vm_area_struct *vma = pvmw->vma;
 	struct mm_struct *mm = vma->vm_mm;
 	unsigned long address = pvmw->address;
+	bool anon_exclusive;
 	pmd_t pmdval;
 	swp_entry_t entry;
 	pmd_t pmdswp;
@@ -3079,10 +3126,19 @@ void set_pmd_migration_entry(struct page_vma_mapped_walk *pvmw,
 
 	flush_cache_range(vma, address, address + HPAGE_PMD_SIZE);
 	pmdval = pmdp_invalidate(vma, address, pvmw->pmd);
+
+	anon_exclusive = PageAnon(page) && PageAnonExclusive(page);
+	if (anon_exclusive && page_try_share_anon_rmap(page)) {
+		set_pmd_at(mm, address, pvmw->pmd, pmdval);
+		return;
+	}
+
 	if (pmd_dirty(pmdval))
 		set_page_dirty(page);
 	if (pmd_write(pmdval))
 		entry = make_writable_migration_entry(page_to_pfn(page));
+	else if (anon_exclusive)
+		entry = make_readable_exclusive_migration_entry(page_to_pfn(page));
 	else
 		entry = make_readable_migration_entry(page_to_pfn(page));
 	pmdswp = swp_entry_to_pmd(entry);
@@ -3116,10 +3172,17 @@ void remove_migration_pmd(struct page_vma_mapped_walk *pvmw, struct page *new)
 		pmde = pmd_wrprotect(pmd_mkuffd_wp(pmde));
 
 	flush_cache_range(vma, mmun_start, mmun_start + HPAGE_PMD_SIZE);
-	if (PageAnon(new))
-		page_add_anon_rmap(new, vma, mmun_start, RMAP_COMPOUND);
-	else
+	if (PageAnon(new)) {
+		int rmap_flags = RMAP_COMPOUND;
+
+		if (!is_readable_migration_entry(entry))
+			rmap_flags |= RMAP_EXCLUSIVE;
+
+		page_add_anon_rmap(new, vma, mmun_start, rmap_flags);
+	} else {
 		page_add_file_rmap(new, true);
+	}
+	VM_BUG_ON(pmd_write(pmde) && PageAnon(new) && !PageAnonExclusive(new));
 	set_pmd_at(mm, mmun_start, pvmw->pmd, pmde);
 	if ((vma->vm_flags & VM_LOCKED) && !PageDoubleMap(new))
 		mlock_vma_page(new);
diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index 1ff0b9e1e28e..c0e19ea5ebb5 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -4765,7 +4765,7 @@ int copy_hugetlb_page_range(struct mm_struct *dst, struct mm_struct *src,
 				    is_hugetlb_entry_hwpoisoned(entry))) {
 			swp_entry_t swp_entry = pte_to_swp_entry(entry);
 
-			if (is_writable_migration_entry(swp_entry) && cow) {
+			if (!is_readable_migration_entry(swp_entry) && cow) {
 				/*
 				 * COW mappings require pages in both
 				 * parent and child to be set to read.
@@ -5165,6 +5165,8 @@ static vm_fault_t hugetlb_cow(struct mm_struct *mm, struct vm_area_struct *vma,
 		set_huge_ptep_writable(vma, haddr, ptep);
 		return 0;
 	}
+	VM_BUG_ON_PAGE(PageAnon(old_page) && PageAnonExclusive(old_page),
+		       old_page);
 
 	/*
 	 * If the process that created a MAP_PRIVATE mapping is about to
@@ -6160,12 +6162,17 @@ unsigned long hugetlb_change_protection(struct vm_area_struct *vma,
 		}
 		if (unlikely(is_hugetlb_entry_migration(pte))) {
 			swp_entry_t entry = pte_to_swp_entry(pte);
+			struct page *page = pfn_swap_entry_to_page(entry);
 
-			if (is_writable_migration_entry(entry)) {
+			if (!is_readable_migration_entry(entry)) {
 				pte_t newpte;
 
-				entry = make_readable_migration_entry(
-							swp_offset(entry));
+				if (PageAnon(page))
+					entry = make_readable_exclusive_migration_entry(
+								swp_offset(entry));
+				else
+					entry = make_readable_migration_entry(
+								swp_offset(entry));
 				newpte = swp_entry_to_pte(entry);
 				set_huge_swap_pte_at(mm, address, ptep,
 						     newpte, huge_page_size(h));
diff --git a/mm/ksm.c b/mm/ksm.c
index 9ff28097bc0a..350b46432d65 100644
--- a/mm/ksm.c
+++ b/mm/ksm.c
@@ -866,6 +866,7 @@ static inline struct stable_node *page_stable_node(struct page *page)
 static inline void set_page_stable_node(struct page *page,
 					struct stable_node *stable_node)
 {
+	VM_BUG_ON_PAGE(PageAnon(page) && PageAnonExclusive(page), page);
 	page->mapping = (void *)((unsigned long)stable_node | PAGE_MAPPING_KSM);
 }
 
@@ -1041,6 +1042,7 @@ static int write_protect_page(struct vm_area_struct *vma, struct page *page,
 	int swapped;
 	int err = -EFAULT;
 	struct mmu_notifier_range range;
+	bool anon_exclusive;
 
 	pvmw.address = page_address_in_vma(page, vma);
 	if (pvmw.address == -EFAULT)
@@ -1058,9 +1060,10 @@ static int write_protect_page(struct vm_area_struct *vma, struct page *page,
 	if (WARN_ONCE(!pvmw.pte, "Unexpected PMD mapping?"))
 		goto out_unlock;
 
+	anon_exclusive = PageAnonExclusive(page);
 	if (pte_write(*pvmw.pte) || pte_dirty(*pvmw.pte) ||
 	    (pte_protnone(*pvmw.pte) && pte_savedwrite(*pvmw.pte)) ||
-						mm_tlb_flush_pending(mm)) {
+	    anon_exclusive || mm_tlb_flush_pending(mm)) {
 		pte_t entry;
 
 		swapped = PageSwapCache(page);
@@ -1088,6 +1091,12 @@ static int write_protect_page(struct vm_area_struct *vma, struct page *page,
 			set_pte_at(mm, pvmw.address, pvmw.pte, entry);
 			goto out_unlock;
 		}
+
+		if (anon_exclusive && page_try_share_anon_rmap(page)) {
+			set_pte_at(mm, pvmw.address, pvmw.pte, entry);
+			goto out_unlock;
+		}
+
 		if (pte_dirty(entry))
 			set_page_dirty(page);
 
@@ -1146,6 +1155,8 @@ static int replace_page(struct vm_area_struct *vma, struct page *page,
 		pte_unmap_unlock(ptep, ptl);
 		goto out_mn;
 	}
+	VM_BUG_ON_PAGE(PageAnonExclusive(page), page);
+	VM_BUG_ON_PAGE(PageAnon(kpage) && PageAnonExclusive(kpage), kpage);
 
 	/*
 	 * No need to check ksm_use_zero_pages here: we can only have a
diff --git a/mm/memory.c b/mm/memory.c
index d01fab481134..222aaf277af4 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -720,6 +720,8 @@ static void restore_exclusive_pte(struct vm_area_struct *vma,
 	else if (is_writable_device_exclusive_entry(entry))
 		pte = maybe_mkwrite(pte_mkdirty(pte), vma);
 
+	VM_BUG_ON(pte_write(pte) && !(PageAnon(page) && PageAnonExclusive(page)));
+
 	/*
 	 * No need to take a page reference as one was already
 	 * created when the swap entry was made.
@@ -799,11 +801,12 @@ copy_nonpresent_pte(struct mm_struct *dst_mm, struct mm_struct *src_mm,
 
 		rss[mm_counter(page)]++;
 
-		if (is_writable_migration_entry(entry) &&
+		if (!is_readable_migration_entry(entry) &&
 				is_cow_mapping(vm_flags)) {
 			/*
-			 * COW mappings require pages in both
-			 * parent and child to be set to read.
+			 * COW mappings require pages in both parent and child
+			 * to be set to read. A previously exclusive entry is
+			 * now shared.
 			 */
 			entry = make_readable_migration_entry(
 							swp_offset(entry));
@@ -954,6 +957,7 @@ copy_present_pte(struct vm_area_struct *dst_vma, struct vm_area_struct *src_vma,
 		ptep_set_wrprotect(src_mm, addr, src_pte);
 		pte = pte_wrprotect(pte);
 	}
+	VM_BUG_ON(page && PageAnon(page) && PageAnonExclusive(page));
 
 	/*
 	 * If it's a shared mapping, mark it clean in
@@ -2943,6 +2947,9 @@ static inline void wp_page_reuse(struct vm_fault *vmf)
 	struct vm_area_struct *vma = vmf->vma;
 	struct page *page = vmf->page;
 	pte_t entry;
+
+	VM_BUG_ON(PageAnon(page) && !PageAnonExclusive(page));
+
 	/*
 	 * Clear the pages cpupid information as the existing
 	 * information potentially belongs to a now completely
@@ -3277,6 +3284,13 @@ static vm_fault_t do_wp_page(struct vm_fault *vmf)
 	if (PageAnon(vmf->page)) {
 		struct page *page = vmf->page;
 
+		/*
+		 * If the page is exclusive to this process we must reuse the
+		 * page without further checks.
+		 */
+		if (PageAnonExclusive(page))
+			goto reuse;
+
 		/*
 		 * We have to verify under page lock: these early checks are
 		 * just an optimization to avoid locking the page and freeing
@@ -3309,6 +3323,7 @@ static vm_fault_t do_wp_page(struct vm_fault *vmf)
 		 */
 		page_move_anon_rmap(page, vma);
 		unlock_page(page);
+reuse:
 		wp_page_reuse(vmf);
 		return VM_FAULT_WRITE;
 	} else if (unlikely((vma->vm_flags & (VM_WRITE|VM_SHARED)) ==
@@ -3700,11 +3715,12 @@ vm_fault_t do_swap_page(struct vm_fault *vmf)
 	 * that are certainly not shared because we just allocated them without
 	 * exposing them to the swapcache.
 	 */
-	if ((vmf->flags & FAULT_FLAG_WRITE) && !PageKsm(page) &&
-	    (page != swapcache || page_count(page) == 1)) {
-		pte = maybe_mkwrite(pte_mkdirty(pte), vma);
-		vmf->flags &= ~FAULT_FLAG_WRITE;
-		ret |= VM_FAULT_WRITE;
+	if (!PageKsm(page) && (page != swapcache || page_count(page) == 1)) {
+		if (vmf->flags & FAULT_FLAG_WRITE) {
+			pte = maybe_mkwrite(pte_mkdirty(pte), vma);
+			vmf->flags &= ~FAULT_FLAG_WRITE;
+			ret |= VM_FAULT_WRITE;
+		}
 		rmap_flags |= RMAP_EXCLUSIVE;
 	}
 	flush_icache_page(vma, page);
@@ -3724,6 +3740,7 @@ vm_fault_t do_swap_page(struct vm_fault *vmf)
 		page_add_anon_rmap(page, vma, vmf->address, rmap_flags);
 	}
 
+	VM_BUG_ON(!PageAnon(page) || (pte_write(pte) && !PageAnonExclusive(page)));
 	set_pte_at(vma->vm_mm, vmf->address, vmf->pte, pte);
 	arch_do_swap_page(vma->vm_mm, vma, vmf->address, pte, vmf->orig_pte);
 
diff --git a/mm/migrate.c b/mm/migrate.c
index fd9eba33b34a..7f440d2103ce 100644
--- a/mm/migrate.c
+++ b/mm/migrate.c
@@ -188,6 +188,8 @@ static bool remove_migration_pte(struct page *page, struct vm_area_struct *vma,
 
 	VM_BUG_ON_PAGE(PageTail(page), page);
 	while (page_vma_mapped_walk(&pvmw)) {
+		rmap_t rmap_flags = RMAP_NONE;
+
 		if (PageKsm(page))
 			new = page;
 		else
@@ -217,6 +219,9 @@ static bool remove_migration_pte(struct page *page, struct vm_area_struct *vma,
 		else if (pte_swp_uffd_wp(*pvmw.pte))
 			pte = pte_mkuffd_wp(pte);
 
+		if (PageAnon(new) && !is_readable_migration_entry(entry))
+			rmap_flags |= RMAP_EXCLUSIVE;
+
 		if (unlikely(is_device_private_page(new))) {
 			if (pte_write(pte))
 				entry = make_writable_device_private_entry(
@@ -239,7 +244,7 @@ static bool remove_migration_pte(struct page *page, struct vm_area_struct *vma,
 			pte = arch_make_huge_pte(pte, shift, vma->vm_flags);
 			if (PageAnon(new))
 				hugepage_add_anon_rmap(new, vma, pvmw.address,
-						       RMAP_NONE);
+						       rmap_flags);
 			else
 				page_dup_file_rmap(new, true);
 			set_huge_pte_at(vma->vm_mm, pvmw.address, pvmw.pte, pte);
@@ -248,7 +253,7 @@ static bool remove_migration_pte(struct page *page, struct vm_area_struct *vma,
 		{
 			if (PageAnon(new))
 				page_add_anon_rmap(new, vma, pvmw.address,
-						   RMAP_NONE);
+						   rmap_flags);
 			else
 				page_add_file_rmap(new, false);
 			set_pte_at(vma->vm_mm, pvmw.address, pvmw.pte, pte);
@@ -379,6 +384,10 @@ int folio_migrate_mapping(struct address_space *mapping,
 		/* No turning back from here */
 		newfolio->index = folio->index;
 		newfolio->mapping = folio->mapping;
+		/*
+		 * Note: PG_anon_exclusive is always migrated via migration
+		 * entries.
+		 */
 		if (folio_test_swapbacked(folio))
 			__folio_set_swapbacked(newfolio);
 
@@ -2302,15 +2311,34 @@ static int migrate_vma_collect_pmd(pmd_t *pmdp,
 		 * set up a special migration page table entry now.
 		 */
 		if (trylock_page(page)) {
+			bool anon_exclusive;
 			pte_t swp_pte;
 
+			anon_exclusive = PageAnon(page) && PageAnonExclusive(page);
+			if (anon_exclusive) {
+				flush_cache_page(vma, addr, pte_pfn(*ptep));
+				ptep_clear_flush(vma, addr, ptep);
+
+				if (page_try_share_anon_rmap(page)) {
+					set_pte_at(mm, addr, ptep, pte);
+					unlock_page(page);
+					put_page(page);
+					mpfn = 0;
+					goto next;
+				}
+			} else {
+				ptep_get_and_clear(mm, addr, ptep);
+			}
+
 			migrate->cpages++;
-			ptep_get_and_clear(mm, addr, ptep);
 
 			/* Setup special migration page table entry */
 			if (mpfn & MIGRATE_PFN_WRITE)
 				entry = make_writable_migration_entry(
 							page_to_pfn(page));
+			else if (anon_exclusive)
+				entry = make_readable_exclusive_migration_entry(
+							page_to_pfn(page));
 			else
 				entry = make_readable_migration_entry(
 							page_to_pfn(page));
diff --git a/mm/mprotect.c b/mm/mprotect.c
index 2887644fd150..9441675e993c 100644
--- a/mm/mprotect.c
+++ b/mm/mprotect.c
@@ -141,6 +141,7 @@ static unsigned long change_pte_range(struct vm_area_struct *vma, pmd_t *pmd,
 			pages++;
 		} else if (is_swap_pte(oldpte)) {
 			swp_entry_t entry = pte_to_swp_entry(oldpte);
+			struct page *page = pfn_swap_entry_to_page(entry);
 			pte_t newpte;
 
 			if (is_writable_migration_entry(entry)) {
@@ -148,8 +149,11 @@ static unsigned long change_pte_range(struct vm_area_struct *vma, pmd_t *pmd,
 				 * A protection check is difficult so
 				 * just be safe and disable write
 				 */
-				entry = make_readable_migration_entry(
-							swp_offset(entry));
+				if (PageAnon(page))
+					entry = make_readable_exclusive_migration_entry(
+							     swp_offset(entry));
+				else
+					entry = make_readable_migration_entry(swp_offset(entry));
 				newpte = swp_entry_to_pte(entry);
 				if (pte_swp_soft_dirty(oldpte))
 					newpte = pte_swp_mksoft_dirty(newpte);
diff --git a/mm/rmap.c b/mm/rmap.c
index ebe7140c4493..9d2a7e11e8cc 100644
--- a/mm/rmap.c
+++ b/mm/rmap.c
@@ -1048,6 +1048,7 @@ EXPORT_SYMBOL_GPL(folio_mkclean);
 void page_move_anon_rmap(struct page *page, struct vm_area_struct *vma)
 {
 	struct anon_vma *anon_vma = vma->anon_vma;
+	struct page *subpage = page;
 
 	page = compound_head(page);
 
@@ -1061,6 +1062,7 @@ void page_move_anon_rmap(struct page *page, struct vm_area_struct *vma)
 	 * PageAnon()) will not see one without the other.
 	 */
 	WRITE_ONCE(page->mapping, (struct address_space *) anon_vma);
+	SetPageAnonExclusive(subpage);
 }
 
 /**
@@ -1078,7 +1080,7 @@ static void __page_set_anon_rmap(struct page *page,
 	BUG_ON(!anon_vma);
 
 	if (PageAnon(page))
-		return;
+		goto out;
 
 	/*
 	 * If the page isn't exclusively mapped into this vma,
@@ -1097,6 +1099,9 @@ static void __page_set_anon_rmap(struct page *page,
 	anon_vma = (void *) anon_vma + PAGE_MAPPING_ANON;
 	WRITE_ONCE(page->mapping, (struct address_space *) anon_vma);
 	page->index = linear_page_index(vma, address);
+out:
+	if (exclusive)
+		SetPageAnonExclusive(page);
 }
 
 /**
@@ -1156,6 +1161,8 @@ void page_add_anon_rmap(struct page *page,
 	} else {
 		first = atomic_inc_and_test(&page->_mapcount);
 	}
+	VM_BUG_ON_PAGE(!first && (flags & RMAP_EXCLUSIVE), page);
+	VM_BUG_ON_PAGE(!first && PageAnonExclusive(page), page);
 
 	if (first) {
 		int nr = compound ? thp_nr_pages(page) : 1;
@@ -1422,7 +1429,7 @@ static bool try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
 	};
 	pte_t pteval;
 	struct page *subpage;
-	bool ret = true;
+	bool anon_exclusive, ret = true;
 	struct mmu_notifier_range range;
 	enum ttu_flags flags = (enum ttu_flags)(long)arg;
 
@@ -1485,6 +1492,7 @@ static bool try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
 
 		subpage = page - page_to_pfn(page) + pte_pfn(*pvmw.pte);
 		address = pvmw.address;
+		anon_exclusive = PageAnon(page) && PageAnonExclusive(subpage);
 
 		if (PageHuge(page) && !PageAnon(page)) {
 			/*
@@ -1520,9 +1528,12 @@ static bool try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
 			}
 		}
 
-		/* Nuke the page table entry. */
+		/*
+		 * Nuke the page table entry. When having to clear
+		 * PageAnonExclusive(), we always have to flush.
+		 */
 		flush_cache_page(vma, address, pte_pfn(*pvmw.pte));
-		if (should_defer_flush(mm, flags)) {
+		if (should_defer_flush(mm, flags) && !anon_exclusive) {
 			/*
 			 * We clear the PTE but do not flush so potentially
 			 * a remote CPU could still be writing to the page.
@@ -1623,6 +1634,24 @@ static bool try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
 				page_vma_mapped_walk_done(&pvmw);
 				break;
 			}
+			if (anon_exclusive &&
+			    page_try_share_anon_rmap(subpage)) {
+				swap_free(entry);
+				set_pte_at(mm, address, pvmw.pte, pteval);
+				ret = false;
+				page_vma_mapped_walk_done(&pvmw);
+				break;
+			}
+			/*
+			 * Note: We *don't* remember yet if the page was mapped
+			 * exclusively in the swap entry, so swapin code has
+			 * to re-determine that manually and might detect the
+			 * page as possibly shared, for example, if there are
+			 * other references on the page or if the page is under
+			 * writeback. We made sure that there are no GUP pins
+			 * on the page that would rely on it, so for GUP pins
+			 * this is fine.
+			 */
 			if (list_empty(&mm->mmlist)) {
 				spin_lock(&mmlist_lock);
 				if (list_empty(&mm->mmlist))
@@ -1723,7 +1752,7 @@ static bool try_to_migrate_one(struct page *page, struct vm_area_struct *vma,
 	};
 	pte_t pteval;
 	struct page *subpage;
-	bool ret = true;
+	bool anon_exclusive, ret = true;
 	struct mmu_notifier_range range;
 	enum ttu_flags flags = (enum ttu_flags)(long)arg;
 
@@ -1782,6 +1811,7 @@ static bool try_to_migrate_one(struct page *page, struct vm_area_struct *vma,
 
 		subpage = page - page_to_pfn(page) + pte_pfn(*pvmw.pte);
 		address = pvmw.address;
+		anon_exclusive = PageAnon(page) && PageAnonExclusive(subpage);
 
 		if (PageHuge(page) && !PageAnon(page)) {
 			/*
@@ -1833,6 +1863,9 @@ static bool try_to_migrate_one(struct page *page, struct vm_area_struct *vma,
 			swp_entry_t entry;
 			pte_t swp_pte;
 
+			if (anon_exclusive)
+				BUG_ON(page_try_share_anon_rmap(subpage));
+
 			/*
 			 * Store the pfn of the page in a special migration
 			 * pte. do_swap_page() will wait until the migration
@@ -1841,6 +1874,8 @@ static bool try_to_migrate_one(struct page *page, struct vm_area_struct *vma,
 			entry = pte_to_swp_entry(pteval);
 			if (is_writable_device_private_entry(entry))
 				entry = make_writable_migration_entry(pfn);
+			else if (anon_exclusive)
+				entry = make_readable_exclusive_migration_entry(pfn);
 			else
 				entry = make_readable_migration_entry(pfn);
 			swp_pte = swp_entry_to_pte(entry);
@@ -1903,6 +1938,15 @@ static bool try_to_migrate_one(struct page *page, struct vm_area_struct *vma,
 				page_vma_mapped_walk_done(&pvmw);
 				break;
 			}
+			VM_BUG_ON_PAGE(pte_write(pteval) && PageAnon(page) &&
+				       !anon_exclusive, page);
+			if (anon_exclusive &&
+			    page_try_share_anon_rmap(subpage)) {
+				set_pte_at(mm, address, pvmw.pte, pteval);
+				ret = false;
+				page_vma_mapped_walk_done(&pvmw);
+				break;
+			}
 
 			/*
 			 * Store the pfn of the page in a special migration
@@ -1912,6 +1956,9 @@ static bool try_to_migrate_one(struct page *page, struct vm_area_struct *vma,
 			if (pte_write(pteval))
 				entry = make_writable_migration_entry(
 							page_to_pfn(subpage));
+			else if (anon_exclusive)
+				entry = make_readable_exclusive_migration_entry(
+							page_to_pfn(subpage));
 			else
 				entry = make_readable_migration_entry(
 							page_to_pfn(subpage));
@@ -2425,6 +2472,8 @@ void hugepage_add_anon_rmap(struct page *page, struct vm_area_struct *vma,
 	BUG_ON(!anon_vma);
 	/* address might be in next vma when migration races vma_adjust */
 	first = atomic_inc_and_test(compound_mapcount_ptr(page));
+	VM_BUG_ON_PAGE(!first && (flags & RMAP_EXCLUSIVE), page);
+	VM_BUG_ON_PAGE(!first && PageAnonExclusive(page), page);
 	if (first)
 		__page_set_anon_rmap(page, vma, address,
 				     flags & RMAP_EXCLUSIVE);
-- 
2.35.1

[PATCH v2 12/15] mm/gup: disallow follow_page(FOLL_PIN)

[David Hildenbrand]

We want to change the way we handle R/O pins on anonymous pages that
might be shared: if we detect a possibly shared anonymous page --
mapped R/O and not !PageAnonExclusive() -- we want to trigger unsharing
via a page fault, resulting in an exclusive anonymous page that can be
pinned reliably without getting replaced via COW on the next write
fault.

However, the required page fault will be problematic for follow_page():
in contrast to ordinary GUP, follow_page() doesn't trigger faults
internally. So we would have to end up failing a R/O pin via
follow_page(), although there is something mapped R/O into the page
table, which might be rather surprising.

We don't seem to have follow_page(FOLL_PIN) users, and it's a purely
internal MM function. Let's just make our life easier and the semantics of
follow_page() clearer by just disallowing FOLL_PIN for follow_page()
completely.

Signed-off-by: David Hildenbrand <david@redhat.com>
---
 mm/gup.c     | 3 +++
 mm/hugetlb.c | 8 +++++---
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/mm/gup.c b/mm/gup.c
index 7bc1ba9ce440..ae1aa2e93b0f 100644
--- a/mm/gup.c
+++ b/mm/gup.c
@@ -875,6 +875,9 @@ struct page *follow_page(struct vm_area_struct *vma, unsigned long address,
 	if (vma_is_secretmem(vma))
 		return NULL;
 
+	if (foll_flags & FOLL_PIN)
+		return NULL;
+
 	page = follow_page_mask(vma, address, foll_flags, &ctx);
 	if (ctx.pgmap)
 		put_dev_pagemap(ctx.pgmap);
diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index c0e19ea5ebb5..640364a11336 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -6692,9 +6692,11 @@ follow_huge_pmd(struct mm_struct *mm, unsigned long address,
 	spinlock_t *ptl;
 	pte_t pte;
 
-	/* FOLL_GET and FOLL_PIN are mutually exclusive. */
-	if (WARN_ON_ONCE((flags & (FOLL_PIN | FOLL_GET)) ==
-			 (FOLL_PIN | FOLL_GET)))
+	/*
+	 * FOLL_PIN is not supported for follow_page(). Ordinary GUP goes via
+	 * follow_hugetlb_page().
+	 */
+	if (WARN_ON_ONCE(flags & FOLL_PIN))
 		return NULL;
 
 retry:
-- 
2.35.1

[PATCH v2 13/15] mm: support GUP-triggered unsharing of anonymous pages

[David Hildenbrand]

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.

Co-developed-by: Andrea Arcangeli <aarcange@redhat.com>
Signed-off-by: Andrea Arcangeli <aarcange@redhat.com>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 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(-)

diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index 0f549870da6a..7e1c7d03dcd8 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -794,6 +794,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
@@ -813,6 +816,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,
@@ -825,6 +832,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 */
diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index 4872e7120ee1..e7addf1aeabd 100644
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -1271,6 +1271,7 @@ void huge_pmd_set_accessed(struct vm_fault *vmf)
 
 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_fault *vmf)
 	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_fault *vmf)
 	}
 
 	/*
-	 * 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 vm_fault *vmf)
 		page_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))
diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index 640364a11336..8a40f3f5867a 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -5137,15 +5137,16 @@ static void unmap_ref_private(struct mm_struct *mm, struct vm_area_struct *vma,
 }
 
 /*
- * Hugetlb_cow() should be called with page lock of the original hugepage held.
+ * hugetlb_wp() should be called with page lock of the original hugepage held.
  * Called with hugetlb_fault_mutex_table held and pte_page locked so we
  * cannot race with other handlers or page migration.
  * Keep the pte_same checks anyway to make transition from the mutex easier.
  */
-static vm_fault_t hugetlb_cow(struct mm_struct *mm, struct vm_area_struct *vma,
-		       unsigned long address, pte_t *ptep,
+static vm_fault_t hugetlb_wp(struct mm_struct *mm, struct vm_area_struct *vma,
+		       unsigned long address, pte_t *ptep, unsigned int flags,
 		       struct page *pagecache_page, spinlock_t *ptl)
 {
+	const bool unshare = flags & FAULT_FLAG_UNSHARE;
 	pte_t pte;
 	struct hstate *h = hstate_vma(vma);
 	struct page *old_page, *new_page;
@@ -5154,15 +5155,22 @@ static vm_fault_t hugetlb_cow(struct mm_struct *mm, struct vm_area_struct *vma,
 	unsigned long haddr = address & huge_page_mask(h);
 	struct mmu_notifier_range range;
 
+	VM_BUG_ON(unshare && (flags & FOLL_WRITE));
+	VM_BUG_ON(!unshare && !(flags & FOLL_WRITE));
+
 	pte = huge_ptep_get(ptep);
 	old_page = pte_page(pte);
 
 retry_avoidcopy:
-	/* If no-one else is actually using this page, avoid the copy
-	 * and just make the page writable */
+	/*
+	 * If no-one else is actually using this page, we're the exclusive
+	 * owner and can reuse this page.
+	 */
 	if (page_mapcount(old_page) == 1 && PageAnon(old_page)) {
-		page_move_anon_rmap(old_page, vma);
-		set_huge_ptep_writable(vma, haddr, ptep);
+		if (!PageAnonExclusive(old_page))
+			page_move_anon_rmap(old_page, vma);
+		if (likely(!unshare))
+			set_huge_ptep_writable(vma, haddr, ptep);
 		return 0;
 	}
 	VM_BUG_ON_PAGE(PageAnon(old_page) && PageAnonExclusive(old_page),
@@ -5265,13 +5273,13 @@ static vm_fault_t hugetlb_cow(struct mm_struct *mm, struct vm_area_struct *vma,
 	if (likely(ptep && pte_same(huge_ptep_get(ptep), pte))) {
 		ClearHPageRestoreReserve(new_page);
 
-		/* Break COW */
+		/* Break COW or unshare */
 		huge_ptep_clear_flush(vma, haddr, ptep);
 		mmu_notifier_invalidate_range(mm, range.start, range.end);
 		page_remove_rmap(old_page, true);
 		hugepage_add_new_anon_rmap(new_page, vma, haddr);
 		set_huge_pte_at(mm, haddr, ptep,
-				make_huge_pte(vma, new_page, 1));
+				make_huge_pte(vma, new_page, !unshare));
 		SetHPageMigratable(new_page);
 		/* Make the old page be freed below */
 		new_page = old_page;
@@ -5279,7 +5287,10 @@ static vm_fault_t hugetlb_cow(struct mm_struct *mm, struct vm_area_struct *vma,
 	spin_unlock(ptl);
 	mmu_notifier_invalidate_range_end(&range);
 out_release_all:
-	/* No restore in case of successful pagetable update (Break COW) */
+	/*
+	 * No restore in case of successful pagetable update (Break COW or
+	 * unshare)
+	 */
 	if (new_page != old_page)
 		restore_reserve_on_error(h, vma, haddr, new_page);
 	put_page(new_page);
@@ -5402,7 +5413,8 @@ static vm_fault_t hugetlb_no_page(struct mm_struct *mm,
 	/*
 	 * Currently, we are forced to kill the process in the event the
 	 * original mapper has unmapped pages from the child due to a failed
-	 * COW. Warn that such a situation has occurred as it may not be obvious
+	 * COW/unsharing. Warn that such a situation has occurred as it may not
+	 * be obvious.
 	 */
 	if (is_vma_resv_set(vma, HPAGE_RESV_UNMAPPED)) {
 		pr_warn_ratelimited("PID %d killed due to inadequate hugepage pool\n",
@@ -5528,7 +5540,7 @@ static vm_fault_t hugetlb_no_page(struct mm_struct *mm,
 	hugetlb_count_add(pages_per_huge_page(h), mm);
 	if ((flags & FAULT_FLAG_WRITE) && !(vma->vm_flags & VM_SHARED)) {
 		/* Optimization, do the COW without a second fault */
-		ret = hugetlb_cow(mm, vma, address, ptep, page, ptl);
+		ret = hugetlb_wp(mm, vma, address, ptep, flags, page, ptl);
 	}
 
 	spin_unlock(ptl);
@@ -5658,14 +5670,15 @@ vm_fault_t hugetlb_fault(struct mm_struct *mm, struct vm_area_struct *vma,
 		goto out_mutex;
 
 	/*
-	 * If we are going to COW the mapping later, we examine the pending
-	 * reservations for this page now. This will ensure that any
+	 * If we are going to COW/unshare the mapping later, we examine the
+	 * pending reservations for this page now. This will ensure that any
 	 * allocations necessary to record that reservation occur outside the
 	 * spinlock. For private mappings, we also lookup the pagecache
 	 * page now as it is used to determine if a reservation has been
 	 * consumed.
 	 */
-	if ((flags & FAULT_FLAG_WRITE) && !huge_pte_write(entry)) {
+	if ((flags & (FAULT_FLAG_WRITE|FAULT_FLAG_UNSHARE)) &&
+	    !huge_pte_write(entry)) {
 		if (vma_needs_reservation(h, vma, haddr) < 0) {
 			ret = VM_FAULT_OOM;
 			goto out_mutex;
@@ -5680,12 +5693,12 @@ vm_fault_t hugetlb_fault(struct mm_struct *mm, struct vm_area_struct *vma,
 
 	ptl = huge_pte_lock(h, mm, ptep);
 
-	/* Check for a racing update before calling hugetlb_cow */
+	/* Check for a racing update before calling hugetlb_wp() */
 	if (unlikely(!pte_same(entry, huge_ptep_get(ptep))))
 		goto out_ptl;
 
 	/*
-	 * hugetlb_cow() requires page locks of pte_page(entry) and
+	 * hugetlb_wp() requires page locks of pte_page(entry) and
 	 * pagecache_page, so here we need take the former one
 	 * when page != pagecache_page or !pagecache_page.
 	 */
@@ -5698,13 +5711,14 @@ vm_fault_t hugetlb_fault(struct mm_struct *mm, struct vm_area_struct *vma,
 
 	get_page(page);
 
-	if (flags & FAULT_FLAG_WRITE) {
+	if (flags & (FAULT_FLAG_WRITE|FAULT_FLAG_UNSHARE)) {
 		if (!huge_pte_write(entry)) {
-			ret = hugetlb_cow(mm, vma, address, ptep,
-					  pagecache_page, ptl);
+			ret = hugetlb_wp(mm, vma, address, ptep, flags,
+					 pagecache_page, ptl);
 			goto out_put_page;
+		} else if (likely(flags & FAULT_FLAG_WRITE)) {
+			entry = huge_pte_mkdirty(entry);
 		}
-		entry = huge_pte_mkdirty(entry);
 	}
 	entry = pte_mkyoung(entry);
 	if (huge_ptep_set_access_flags(vma, haddr, ptep, entry,
diff --git a/mm/memory.c b/mm/memory.c
index 222aaf277af4..b0b9d07a2850 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -2739,8 +2739,8 @@ static inline int pte_unmap_same(struct vm_fault *vmf)
 	return same;
 }
 
-static inline bool cow_user_page(struct page *dst, struct page *src,
-				 struct vm_fault *vmf)
+static inline bool __wp_page_copy_user(struct page *dst, struct page *src,
+				       struct vm_fault *vmf)
 {
 	bool ret;
 	void *kaddr;
@@ -2948,6 +2948,7 @@ static inline void wp_page_reuse(struct vm_fault *vmf)
 	struct page *page = vmf->page;
 	pte_t entry;
 
+	VM_BUG_ON(!(vmf->flags & FAULT_FLAG_WRITE));
 	VM_BUG_ON(PageAnon(page) && !PageAnonExclusive(page));
 
 	/*
@@ -2968,7 +2969,8 @@ static inline void wp_page_reuse(struct vm_fault *vmf)
 }
 
 /*
- * Handle the case of a page which we actually need to copy to a new page.
+ * Handle the case of a page which we actually need to copy to a new page,
+ * either due to COW or unsharing.
  *
  * Called with mmap_lock locked and the old page referenced, but
  * without the ptl held.
@@ -2985,6 +2987,7 @@ static inline void wp_page_reuse(struct vm_fault *vmf)
  */
 static vm_fault_t wp_page_copy(struct vm_fault *vmf)
 {
+	const bool unshare = vmf->flags & FAULT_FLAG_UNSHARE;
 	struct vm_area_struct *vma = vmf->vma;
 	struct mm_struct *mm = vma->vm_mm;
 	struct page *old_page = vmf->page;
@@ -3007,7 +3010,7 @@ static vm_fault_t wp_page_copy(struct vm_fault *vmf)
 		if (!new_page)
 			goto oom;
 
-		if (!cow_user_page(new_page, old_page, vmf)) {
+		if (!__wp_page_copy_user(new_page, old_page, vmf)) {
 			/*
 			 * COW failed, if the fault was solved by other,
 			 * it's fine. If not, userspace would re-fault on
@@ -3049,7 +3052,14 @@ static vm_fault_t wp_page_copy(struct vm_fault *vmf)
 		flush_cache_page(vma, vmf->address, pte_pfn(vmf->orig_pte));
 		entry = mk_pte(new_page, vma->vm_page_prot);
 		entry = pte_sw_mkyoung(entry);
-		entry = maybe_mkwrite(pte_mkdirty(entry), vma);
+		if (unlikely(unshare)) {
+			if (pte_soft_dirty(vmf->orig_pte))
+				entry = pte_mksoft_dirty(entry);
+			if (pte_uffd_wp(vmf->orig_pte))
+				entry = pte_mkuffd_wp(entry);
+		} else {
+			entry = maybe_mkwrite(pte_mkdirty(entry), vma);
+		}
 
 		/*
 		 * Clear the pte entry and flush it first, before updating the
@@ -3066,6 +3076,7 @@ static vm_fault_t wp_page_copy(struct vm_fault *vmf)
 		 * mmu page tables (such as kvm shadow page tables), we want the
 		 * new page to be mapped directly into the secondary page table.
 		 */
+		BUG_ON(unshare && pte_write(entry));
 		set_pte_at_notify(mm, vmf->address, vmf->pte, entry);
 		update_mmu_cache(vma, vmf->address, vmf->pte);
 		if (old_page) {
@@ -3125,7 +3136,7 @@ static vm_fault_t wp_page_copy(struct vm_fault *vmf)
 			free_swap_cache(old_page);
 		put_page(old_page);
 	}
-	return page_copied ? VM_FAULT_WRITE : 0;
+	return page_copied && !unshare ? VM_FAULT_WRITE : 0;
 oom_free_new:
 	put_page(new_page);
 oom:
@@ -3225,18 +3236,22 @@ static vm_fault_t wp_page_shared(struct vm_fault *vmf)
 }
 
 /*
- * This routine handles present pages, when users try to write
- * to a shared page. It is done by copying the page to a new address
- * and decrementing the shared-page counter for the old page.
+ * This routine handles present pages, when
+ * * users try to write to a shared page (FAULT_FLAG_WRITE)
+ * * GUP wants to take a R/O pin on a possibly shared anonymous page
+ *   (FAULT_FLAG_UNSHARE)
+ *
+ * It is done by copying the page to a new address and decrementing the
+ * shared-page counter for the old page.
  *
  * Note that this routine assumes that the protection checks have been
  * done by the caller (the low-level page fault routine in most cases).
- * Thus we can safely just mark it writable once we've done any necessary
- * COW.
+ * Thus, with FAULT_FLAG_WRITE, we can safely just mark it writable once we've
+ * done any necessary COW.
  *
- * We also mark the page dirty at this point even though the page will
- * change only once the write actually happens. This avoids a few races,
- * and potentially makes it more efficient.
+ * In case of FAULT_FLAG_WRITE, we also mark the page dirty at this point even
+ * though the page will change only once the write actually happens. This
+ * avoids a few races, and potentially makes it more efficient.
  *
  * We enter with non-exclusive mmap_lock (to exclude vma changes,
  * but allow concurrent faults), with pte both mapped and locked.
@@ -3245,23 +3260,35 @@ static vm_fault_t wp_page_shared(struct vm_fault *vmf)
 static vm_fault_t do_wp_page(struct vm_fault *vmf)
 	__releases(vmf->ptl)
 {
+	const bool unshare = vmf->flags & FAULT_FLAG_UNSHARE;
 	struct vm_area_struct *vma = vmf->vma;
 
-	if (userfaultfd_pte_wp(vma, *vmf->pte)) {
-		pte_unmap_unlock(vmf->pte, vmf->ptl);
-		return handle_userfault(vmf, VM_UFFD_WP);
-	}
+	VM_BUG_ON(unshare && (vmf->flags & FAULT_FLAG_WRITE));
+	VM_BUG_ON(!unshare && !(vmf->flags & FAULT_FLAG_WRITE));
 
-	/*
-	 * Userfaultfd write-protect can defer flushes. Ensure the TLB
-	 * is flushed in this case before copying.
-	 */
-	if (unlikely(userfaultfd_wp(vmf->vma) &&
-		     mm_tlb_flush_pending(vmf->vma->vm_mm)))
-		flush_tlb_page(vmf->vma, vmf->address);
+	if (likely(!unshare)) {
+		if (userfaultfd_pte_wp(vma, *vmf->pte)) {
+			pte_unmap_unlock(vmf->pte, vmf->ptl);
+			return handle_userfault(vmf, VM_UFFD_WP);
+		}
+
+		/*
+		 * Userfaultfd write-protect can defer flushes. Ensure the TLB
+		 * is flushed in this case before copying.
+		 */
+		if (unlikely(userfaultfd_wp(vmf->vma) &&
+			     mm_tlb_flush_pending(vmf->vma->vm_mm)))
+			flush_tlb_page(vmf->vma, vmf->address);
+	}
 
 	vmf->page = vm_normal_page(vma, vmf->address, vmf->orig_pte);
 	if (!vmf->page) {
+		if (unlikely(unshare)) {
+			/* No anonymous page -> nothing to do. */
+			pte_unmap_unlock(vmf->pte, vmf->ptl);
+			return 0;
+		}
+
 		/*
 		 * VM_MIXEDMAP !pfn_valid() case, or VM_SOFTDIRTY clear on a
 		 * VM_PFNMAP VMA.
@@ -3324,8 +3351,16 @@ static vm_fault_t do_wp_page(struct vm_fault *vmf)
 		page_move_anon_rmap(page, vma);
 		unlock_page(page);
 reuse:
+		if (unlikely(unshare)) {
+			pte_unmap_unlock(vmf->pte, vmf->ptl);
+			return 0;
+		}
 		wp_page_reuse(vmf);
 		return VM_FAULT_WRITE;
+	} else if (unshare) {
+		/* No anonymous page -> nothing to do. */
+		pte_unmap_unlock(vmf->pte, vmf->ptl);
+		return 0;
 	} else if (unlikely((vma->vm_flags & (VM_WRITE|VM_SHARED)) ==
 					(VM_WRITE|VM_SHARED))) {
 		return wp_page_shared(vmf);
@@ -4517,8 +4552,11 @@ static inline vm_fault_t create_huge_pmd(struct vm_fault *vmf)
 /* `inline' is required to avoid gcc 4.1.2 build error */
 static inline vm_fault_t wp_huge_pmd(struct vm_fault *vmf)
 {
+	const bool unshare = vmf->flags & FAULT_FLAG_UNSHARE;
+
 	if (vma_is_anonymous(vmf->vma)) {
-		if (userfaultfd_huge_pmd_wp(vmf->vma, vmf->orig_pmd))
+		if (unlikely(unshare) &&
+		    userfaultfd_huge_pmd_wp(vmf->vma, vmf->orig_pmd))
 			return handle_userfault(vmf, VM_UFFD_WP);
 		return do_huge_pmd_wp_page(vmf);
 	}
@@ -4653,10 +4691,11 @@ static vm_fault_t handle_pte_fault(struct vm_fault *vmf)
 		update_mmu_tlb(vmf->vma, vmf->address, vmf->pte);
 		goto unlock;
 	}
-	if (vmf->flags & FAULT_FLAG_WRITE) {
+	if (vmf->flags & (FAULT_FLAG_WRITE|FAULT_FLAG_UNSHARE)) {
 		if (!pte_write(entry))
 			return do_wp_page(vmf);
-		entry = pte_mkdirty(entry);
+		else if (likely(vmf->flags & FAULT_FLAG_WRITE))
+			entry = pte_mkdirty(entry);
 	}
 	entry = pte_mkyoung(entry);
 	if (ptep_set_access_flags(vmf->vma, vmf->address, vmf->pte, entry,
@@ -4696,7 +4735,6 @@ static vm_fault_t __handle_mm_fault(struct vm_area_struct *vma,
 		.pgoff = linear_page_index(vma, address),
 		.gfp_mask = __get_fault_gfp_mask(vma),
 	};
-	unsigned int dirty = flags & FAULT_FLAG_WRITE;
 	struct mm_struct *mm = vma->vm_mm;
 	pgd_t *pgd;
 	p4d_t *p4d;
@@ -4721,9 +4759,11 @@ static vm_fault_t __handle_mm_fault(struct vm_area_struct *vma,
 		barrier();
 		if (pud_trans_huge(orig_pud) || pud_devmap(orig_pud)) {
 
-			/* NUMA case for anonymous PUDs would go here */
-
-			if (dirty && !pud_write(orig_pud)) {
+			/*
+			 * TODO once we support anonymous PUDs: NUMA case and
+			 * FAULT_FLAG_UNSHARE handling.
+			 */
+			if ((flags & FAULT_FLAG_WRITE) && !pud_write(orig_pud)) {
 				ret = wp_huge_pud(&vmf, orig_pud);
 				if (!(ret & VM_FAULT_FALLBACK))
 					return ret;
@@ -4761,7 +4801,8 @@ static vm_fault_t __handle_mm_fault(struct vm_area_struct *vma,
 			if (pmd_protnone(vmf.orig_pmd) && vma_is_accessible(vma))
 				return do_huge_pmd_numa_page(&vmf);
 
-			if (dirty && !pmd_write(vmf.orig_pmd)) {
+			if ((flags & (FAULT_FLAG_WRITE|FAULT_FLAG_UNSHARE)) &&
+			    !pmd_write(vmf.orig_pmd)) {
 				ret = wp_huge_pmd(&vmf);
 				if (!(ret & VM_FAULT_FALLBACK))
 					return ret;
-- 
2.35.1

[PATCH v2 14/15] mm/gup: trigger FAULT_FLAG_UNSHARE when R/O-pinning a possibly shared anonymous page

[David Hildenbrand]

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.

Let's 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.

This change implies that whenever user space *wrote* to a private
mapping (IOW, we have an anonymous page mapped), that GUP pins will
always remain consistent: reliable R/O GUP pins of anonymous pages.

As a side note, this commit fixes the COW security issue for hugetlb with
FOLL_PIN as documented in:
  https://lore.kernel.org/r/3ae33b08-d9ef-f846-56fb-645e3b9b4c66@redhat.com
The vmsplice reproducer still applies, because vmsplice uses FOLL_GET
instead of FOLL_PIN.

Note that follow_huge_pmd() doesn't apply because we cannot end up in
there with FOLL_PIN.

This commit is heavily based on prototype patches by Andrea.

Co-developed-by: Andrea Arcangeli <aarcange@redhat.com>
Signed-off-by: Andrea Arcangeli <aarcange@redhat.com>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 include/linux/mm.h | 39 +++++++++++++++++++++++++++++++++++++++
 mm/gup.c           | 42 +++++++++++++++++++++++++++++++++++++++---
 mm/huge_memory.c   |  3 +++
 mm/hugetlb.c       | 27 ++++++++++++++++++++++++---
 4 files changed, 105 insertions(+), 6 deletions(-)

diff --git a/include/linux/mm.h b/include/linux/mm.h
index 63ee06001189..45fe97213a27 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -3003,6 +3003,45 @@ static inline int vm_fault_to_errno(vm_fault_t vm_fault, int foll_flags)
 	return 0;
 }
 
+/*
+ * Indicates for which pages that are write-protected in the page table,
+ * whether GUP has to trigger unsharing via FAULT_FLAG_UNSHARE such that the
+ * GUP pin will remain consistent with the pages mapped into the page tables
+ * of the MM.
+ *
+ * Temporary unmapping of PageAnonExclusive() pages or clearing of
+ * PageAnonExclusive() has to protect against concurrent GUP:
+ * * Ordinary GUP: Using the PT lock
+ * * GUP-fast and fork(): mm->write_protect_seq
+ * * GUP-fast and KSM or temporary unmapping (swap, migration):
+ *   clear/invalidate+flush of the page table entry
+ *
+ * Must be called with the (sub)page that's actually referenced via the
+ * page table entry, which might not necessarily be the head page for a
+ * PTE-mapped THP.
+ */
+static inline bool gup_must_unshare(unsigned int flags, struct page *page)
+{
+	/*
+	 * FOLL_WRITE is implicitly handled correctly as the page table entry
+	 * has to be writable -- and if it references (part of) an anonymous
+	 * folio, that part is required to be marked exclusive.
+	 */
+	if ((flags & (FOLL_WRITE | FOLL_PIN)) != FOLL_PIN)
+		return false;
+	/*
+	 * Note: PageAnon(page) is stable until the page is actually getting
+	 * freed.
+	 */
+	if (!PageAnon(page))
+		return false;
+	/*
+	 * Note that PageKsm() pages cannot be exclusive, and consequently,
+	 * cannot get pinned.
+	 */
+	return !PageAnonExclusive(page);
+}
+
 typedef int (*pte_fn_t)(pte_t *pte, unsigned long addr, void *data);
 extern int apply_to_page_range(struct mm_struct *mm, unsigned long address,
 			       unsigned long size, pte_fn_t fn, void *data);
diff --git a/mm/gup.c b/mm/gup.c
index ae1aa2e93b0f..92dcd92f9d67 100644
--- a/mm/gup.c
+++ b/mm/gup.c
@@ -568,6 +568,10 @@ static struct page *follow_page_pte(struct vm_area_struct *vma,
 		}
 	}
 
+	if (!pte_write(pte) && gup_must_unshare(flags, page)) {
+		page = ERR_PTR(-EMLINK);
+		goto out;
+	}
 	/* try_grab_page() does nothing unless FOLL_GET or FOLL_PIN is set. */
 	if (unlikely(!try_grab_page(page, flags))) {
 		page = ERR_PTR(-ENOMEM);
@@ -820,6 +824,11 @@ static struct page *follow_p4d_mask(struct vm_area_struct *vma,
  * When getting pages from ZONE_DEVICE memory, the @ctx->pgmap caches
  * the device's dev_pagemap metadata to avoid repeating expensive lookups.
  *
+ * When getting an anonymous page and the caller has to trigger unsharing
+ * of a shared anonymous page first, -EMLINK is returned. The caller should
+ * trigger a fault with FAULT_FLAG_UNSHARE set. Note that unsharing is only
+ * relevant with FOLL_PIN and !FOLL_WRITE.
+ *
  * On output, the @ctx->page_mask is set according to the size of the page.
  *
  * Return: the mapped (struct page *), %NULL if no mapping exists, or
@@ -943,7 +952,8 @@ static int get_gate_page(struct mm_struct *mm, unsigned long address,
  * is, *@locked will be set to 0 and -EBUSY returned.
  */
 static int faultin_page(struct vm_area_struct *vma,
-		unsigned long address, unsigned int *flags, int *locked)
+		unsigned long address, unsigned int *flags, bool unshare,
+		int *locked)
 {
 	unsigned int fault_flags = 0;
 	vm_fault_t ret;
@@ -968,6 +978,11 @@ static int faultin_page(struct vm_area_struct *vma,
 		 */
 		fault_flags |= FAULT_FLAG_TRIED;
 	}
+	if (unshare) {
+		fault_flags |= FAULT_FLAG_UNSHARE;
+		/* FAULT_FLAG_WRITE and FAULT_FLAG_UNSHARE are incompatible */
+		VM_BUG_ON(fault_flags & FAULT_FLAG_WRITE);
+	}
 
 	ret = handle_mm_fault(vma, address, fault_flags, NULL);
 	if (ret & VM_FAULT_ERROR) {
@@ -1189,8 +1204,9 @@ static long __get_user_pages(struct mm_struct *mm,
 		cond_resched();
 
 		page = follow_page_mask(vma, start, foll_flags, &ctx);
-		if (!page) {
-			ret = faultin_page(vma, start, &foll_flags, locked);
+		if (!page || PTR_ERR(page) == -EMLINK) {
+			ret = faultin_page(vma, start, &foll_flags,
+					   PTR_ERR(page) == -EMLINK, locked);
 			switch (ret) {
 			case 0:
 				goto retry;
@@ -2327,6 +2343,11 @@ static int gup_pte_range(pmd_t pmd, unsigned long addr, unsigned long end,
 			goto pte_unmap;
 		}
 
+		if (!pte_write(pte) && gup_must_unshare(flags, page)) {
+			put_compound_head(head, 1, flags);
+			goto pte_unmap;
+		}
+
 		VM_BUG_ON_PAGE(compound_head(page) != head, page);
 
 		/*
@@ -2510,6 +2531,11 @@ static int gup_hugepte(pte_t *ptep, unsigned long sz, unsigned long addr,
 		return 0;
 	}
 
+	if (!pte_write(pte) && gup_must_unshare(flags, head)) {
+		put_compound_head(head, refs, flags);
+		return 0;
+	}
+
 	*nr += refs;
 	SetPageReferenced(head);
 	return 1;
@@ -2570,6 +2596,11 @@ static int gup_huge_pmd(pmd_t orig, pmd_t *pmdp, unsigned long addr,
 		return 0;
 	}
 
+	if (!pmd_write(orig) && gup_must_unshare(flags, head)) {
+		put_compound_head(head, refs, flags);
+		return 0;
+	}
+
 	*nr += refs;
 	SetPageReferenced(head);
 	return 1;
@@ -2604,6 +2635,11 @@ static int gup_huge_pud(pud_t orig, pud_t *pudp, unsigned long addr,
 		return 0;
 	}
 
+	if (!pud_write(orig) && gup_must_unshare(flags, head)) {
+		put_compound_head(head, refs, flags);
+		return 0;
+	}
+
 	*nr += refs;
 	SetPageReferenced(head);
 	return 1;
diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index e7addf1aeabd..1896388b1e30 100644
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -1389,6 +1389,9 @@ struct page *follow_trans_huge_pmd(struct vm_area_struct *vma,
 	page = pmd_page(*pmd);
 	VM_BUG_ON_PAGE(!PageHead(page) && !is_zone_device_page(page), page);
 
+	if (!pmd_write(*pmd) && gup_must_unshare(flags, page))
+		return ERR_PTR(-EMLINK);
+
 	if (!try_grab_page(page, flags))
 		return ERR_PTR(-ENOMEM);
 
diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index 8a40f3f5867a..c40478b5bead 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -5954,6 +5954,25 @@ static void record_subpages_vmas(struct page *page, struct vm_area_struct *vma,
 	}
 }
 
+static inline bool __follow_hugetlb_must_fault(unsigned int flags, pte_t *pte,
+					       bool *unshare)
+{
+	pte_t pteval = huge_ptep_get(pte);
+
+	*unshare = false;
+	if (is_swap_pte(pteval))
+		return true;
+	if (huge_pte_write(pteval))
+		return false;
+	if (flags & FOLL_WRITE)
+		return true;
+	if (gup_must_unshare(flags, pte_page(pteval))) {
+		*unshare = true;
+		return true;
+	}
+	return false;
+}
+
 long follow_hugetlb_page(struct mm_struct *mm, struct vm_area_struct *vma,
 			 struct page **pages, struct vm_area_struct **vmas,
 			 unsigned long *position, unsigned long *nr_pages,
@@ -5968,6 +5987,7 @@ long follow_hugetlb_page(struct mm_struct *mm, struct vm_area_struct *vma,
 	while (vaddr < vma->vm_end && remainder) {
 		pte_t *pte;
 		spinlock_t *ptl = NULL;
+		bool unshare = false;
 		int absent;
 		struct page *page;
 
@@ -6018,9 +6038,8 @@ long follow_hugetlb_page(struct mm_struct *mm, struct vm_area_struct *vma,
 		 * both cases, and because we can't follow correct pages
 		 * directly from any kind of swap entries.
 		 */
-		if (absent || is_swap_pte(huge_ptep_get(pte)) ||
-		    ((flags & FOLL_WRITE) &&
-		      !huge_pte_write(huge_ptep_get(pte)))) {
+		if (absent ||
+		    __follow_hugetlb_must_fault(flags, pte, &unshare)) {
 			vm_fault_t ret;
 			unsigned int fault_flags = 0;
 
@@ -6028,6 +6047,8 @@ long follow_hugetlb_page(struct mm_struct *mm, struct vm_area_struct *vma,
 				spin_unlock(ptl);
 			if (flags & FOLL_WRITE)
 				fault_flags |= FAULT_FLAG_WRITE;
+			else if (unshare)
+				fault_flags |= FAULT_FLAG_UNSHARE;
 			if (locked)
 				fault_flags |= FAULT_FLAG_ALLOW_RETRY |
 					FAULT_FLAG_KILLABLE;
-- 
2.35.1

[PATCH v2 15/15] mm/gup: sanity-check with CONFIG_DEBUG_VM that anonymous pages are exclusive when (un)pinning

[David Hildenbrand]

Let's verify when (un)pinning anonymous pages that we always deal with
exclusive anonymous pages, which guarantees that we'll have a reliable
PIN, meaning that we cannot end up with the GUP pin being inconsistent
with he pages mapped into the page tables due to a COW triggered
by a write fault.

When pinning pages, after conditionally triggering GUP unsharing of
possibly shared anonymous pages, we should always only see exclusive
anonymous pages. Note that anonymous pages that are mapped writable
must be marked exclusive, otherwise we'd have a BUG.

When pinning during ordinary GUP, simply add a check after our
conditional GUP-triggered unsharing checks. As we know exactly how the
page is mapped, we know exactly in which page we have to check for
PageAnonExclusive().

When pinning via GUP-fast we have to be careful, because we can race with
fork(): verify only after we made sure via the seqcount that we didn't
race with concurrent fork() that we didn't end up pinning a possibly
shared anonymous page.

Similarly, when unpinning, verify that the pages are still marked as
exclusive: otherwise something turned the pages possibly shared, which
can result in random memory corruptions, which we really want to catch.

With only the pinned pages at hand and not the actual page table entries
we have to be a bit careful: hugetlb pages are always mapped via a
single logical page table entry referencing the head page and
PG_anon_exclusive of the head page applies. Anon THP are a bit more
complicated, because we might have obtained the page reference either via
a PMD or a PTE -- depending on the mapping type we either have to check
PageAnonExclusive of the head page (PMD-mapped THP) or the tail page
(PTE-mapped THP) applies: as we don't know and to make our life easier,
check that either is set.

Take care to not verify in case we're unpinning during GUP-fast because
we detected concurrent fork(): we might stumble over an anonymous page
that is now shared.

Signed-off-by: David Hildenbrand <david@redhat.com>
---
 mm/gup.c         | 58 +++++++++++++++++++++++++++++++++++++++++++++++-
 mm/huge_memory.c |  3 +++
 mm/hugetlb.c     |  3 +++
 3 files changed, 63 insertions(+), 1 deletion(-)

diff --git a/mm/gup.c b/mm/gup.c
index 92dcd92f9d67..72e39b77da10 100644
--- a/mm/gup.c
+++ b/mm/gup.c
@@ -45,6 +45,38 @@ static void hpage_pincount_sub(struct page *page, int refs)
 	atomic_sub(refs, compound_pincount_ptr(page));
 }
 
+static inline void sanity_check_pinned_pages(struct page **pages,
+					     unsigned long npages)
+{
+#ifdef CONFIG_DEBUG_VM
+	/*
+	 * We only pin anonymous pages if they are exclusive. Once pinned, we
+	 * can no longer turn them possibly shared and PageAnonExclusive() will
+	 * stick around until the page is freed.
+	 *
+	 * We'd like to verify that our pinned anonymous pages are still mapped
+	 * exclusively. The issue with anon THP is that we don't know how
+	 * they are/were mapped when pinning them. However, for anon
+	 * THP we can assume that either the given page (PTE-mapped THP) or
+	 * the head page (PMD-mapped THP) should be PageAnonExclusive(). If
+	 * neither is the case, there is certainly something wrong.
+	 */
+	for (; npages; npages--, pages++) {
+		struct page *page = *pages;
+		struct page *head = compound_head(page);
+
+		if (!PageAnon(head))
+			continue;
+		if (!PageCompound(head) || PageHuge(head))
+			VM_BUG_ON_PAGE(!PageAnonExclusive(head), page);
+		else
+			/* Either a PTE-mapped or a PMD-mapped THP. */
+			VM_BUG_ON_PAGE(!PageAnonExclusive(head) &&
+				       !PageAnonExclusive(page), page);
+	}
+#endif /* CONFIG_DEBUG_VM */
+}
+
 /* Equivalent to calling put_page() @refs times. */
 static void put_page_refs(struct page *page, int refs)
 {
@@ -250,6 +282,7 @@ bool __must_check try_grab_page(struct page *page, unsigned int flags)
  */
 void unpin_user_page(struct page *page)
 {
+	sanity_check_pinned_pages(&page, 1);
 	put_compound_head(compound_head(page), 1, FOLL_PIN);
 }
 EXPORT_SYMBOL(unpin_user_page);
@@ -340,6 +373,7 @@ void unpin_user_pages_dirty_lock(struct page **pages, unsigned long npages,
 		return;
 	}
 
+	sanity_check_pinned_pages(pages, npages);
 	for_each_compound_head(index, pages, npages, head, ntails) {
 		/*
 		 * Checking PageDirty at this point may race with
@@ -404,6 +438,21 @@ void unpin_user_page_range_dirty_lock(struct page *page, unsigned long npages,
 }
 EXPORT_SYMBOL(unpin_user_page_range_dirty_lock);
 
+static void unpin_user_pages_lockless(struct page **pages, unsigned long npages)
+{
+	unsigned long index;
+	struct page *head;
+	unsigned int ntails;
+
+	/*
+	 * Don't perform any sanity checks because we might have raced with
+	 * fork() and some anonymous pages might now actually be shared --
+	 * which is why we're unpinning after all.
+	 */
+	for_each_compound_head(index, pages, npages, head, ntails)
+		put_compound_head(head, ntails, FOLL_PIN);
+}
+
 /**
  * unpin_user_pages() - release an array of gup-pinned pages.
  * @pages:  array of pages to be marked dirty and released.
@@ -426,6 +475,7 @@ void unpin_user_pages(struct page **pages, unsigned long npages)
 	 */
 	if (WARN_ON(IS_ERR_VALUE(npages)))
 		return;
+	sanity_check_pinned_pages(pages, npages);
 
 	for_each_compound_head(index, pages, npages, head, ntails)
 		put_compound_head(head, ntails, FOLL_PIN);
@@ -572,6 +622,10 @@ static struct page *follow_page_pte(struct vm_area_struct *vma,
 		page = ERR_PTR(-EMLINK);
 		goto out;
 	}
+
+	VM_BUG_ON((flags & FOLL_PIN) && PageAnon(page) &&
+		  !PageAnonExclusive(page));
+
 	/* try_grab_page() does nothing unless FOLL_GET or FOLL_PIN is set. */
 	if (unlikely(!try_grab_page(page, flags))) {
 		page = ERR_PTR(-ENOMEM);
@@ -2876,8 +2930,10 @@ static unsigned long lockless_pages_from_mm(unsigned long start,
 	 */
 	if (gup_flags & FOLL_PIN) {
 		if (read_seqcount_retry(&current->mm->write_protect_seq, seq)) {
-			unpin_user_pages(pages, nr_pinned);
+			unpin_user_pages_lockless(pages, nr_pinned);
 			return 0;
+		} else {
+			sanity_check_pinned_pages(pages, nr_pinned);
 		}
 	}
 	return nr_pinned;
diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index 1896388b1e30..0cc34addd911 100644
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -1392,6 +1392,9 @@ struct page *follow_trans_huge_pmd(struct vm_area_struct *vma,
 	if (!pmd_write(*pmd) && gup_must_unshare(flags, page))
 		return ERR_PTR(-EMLINK);
 
+	VM_BUG_ON((flags & FOLL_PIN) && PageAnon(page) &&
+		  !PageAnonExclusive(page));
+
 	if (!try_grab_page(page, flags))
 		return ERR_PTR(-ENOMEM);
 
diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index c40478b5bead..8ba2fdd6f2e3 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -6090,6 +6090,9 @@ long follow_hugetlb_page(struct mm_struct *mm, struct vm_area_struct *vma,
 		pfn_offset = (vaddr & ~huge_page_mask(h)) >> PAGE_SHIFT;
 		page = pte_page(huge_ptep_get(pte));
 
+		VM_BUG_ON((flags & FOLL_PIN) && PageAnon(page) &&
+			  !PageAnonExclusive(page));
+
 		/*
 		 * If subpage information not requested, update counters
 		 * and skip the same_page loop below.
-- 
2.35.1

Re: [PATCH v2 04/15] mm/rmap: split page_dup_rmap() into page_dup_file_rmap() and page_try_dup_anon_rmap()

[Yang Shi]

On Tue, Mar 15, 2022 at 3:50 AM David Hildenbrand <david@redhat.com> wrote:
>
> ... and move the special check for pinned pages into
> page_try_dup_anon_rmap() to prepare for tracking exclusive anonymous
> pages via a new pageflag, clearing it only after making sure that there
> are no GUP pins on the anonymous page.
>
> We really only care about pins on anonymous pages, because they are
> prone to getting replaced in the COW handler once mapped R/O. For !anon
> pages in cow-mappings (!VM_SHARED && VM_MAYWRITE) we shouldn't really
> care about that, at least not that I could come up with an example.
>
> Let's drop the is_cow_mapping() check from page_needs_cow_for_dma(), as we
> know we're dealing with anonymous pages. Also, drop the handling of
> pinned pages from copy_huge_pud() and add a comment if ever supporting
> anonymous pages on the PUD level.
>
> This is a preparation for tracking exclusivity of anonymous pages in
> the rmap code, and disallowing marking a page shared (-> failing to
> duplicate) if there are GUP pins on a page.
>
> RFC notes: if I'm missing something important for !anon pages, we could
>            similarly handle it via page_try_dup_file_rmap().
>
> Signed-off-by: David Hildenbrand <david@redhat.com>
> ---
>  include/linux/mm.h   |  5 +----
>  include/linux/rmap.h | 48 +++++++++++++++++++++++++++++++++++++++++++-
>  mm/huge_memory.c     | 27 ++++++++-----------------
>  mm/hugetlb.c         | 16 ++++++++-------
>  mm/memory.c          | 17 +++++++++++-----
>  mm/migrate.c         |  2 +-
>  6 files changed, 78 insertions(+), 37 deletions(-)
>
> diff --git a/include/linux/mm.h b/include/linux/mm.h
> index 391b950e919d..63ee06001189 100644
> --- a/include/linux/mm.h
> +++ b/include/linux/mm.h
> @@ -1322,16 +1322,13 @@ static inline bool is_cow_mapping(vm_flags_t flags)
>
>  /*
>   * This should most likely only be called during fork() to see whether we
> - * should break the cow immediately for a page on the src mm.
> + * should break the cow immediately for an anon page on the src mm.
>   *
>   * The caller has to hold the PT lock and the vma->vm_mm->->write_protect_seq.
>   */
>  static inline bool page_needs_cow_for_dma(struct vm_area_struct *vma,
>                                           struct page *page)
>  {
> -       if (!is_cow_mapping(vma->vm_flags))
> -               return false;
> -
>         VM_BUG_ON(!(raw_read_seqcount(&vma->vm_mm->write_protect_seq) & 1));
>
>         if (!test_bit(MMF_HAS_PINNED, &vma->vm_mm->flags))
> diff --git a/include/linux/rmap.h b/include/linux/rmap.h
> index e704b1a4c06c..92c3585b8c6a 100644
> --- a/include/linux/rmap.h
> +++ b/include/linux/rmap.h
> @@ -180,11 +180,57 @@ void hugepage_add_anon_rmap(struct page *, struct vm_area_struct *,
>  void hugepage_add_new_anon_rmap(struct page *, struct vm_area_struct *,
>                                 unsigned long);
>
> -static inline void page_dup_rmap(struct page *page, bool compound)
> +static inline void __page_dup_rmap(struct page *page, bool compound)
>  {
>         atomic_inc(compound ? compound_mapcount_ptr(page) : &page->_mapcount);
>  }
>
> +static inline void page_dup_file_rmap(struct page *page, bool compound)
> +{
> +       __page_dup_rmap(page, compound);
> +}
> +
> +/**
> + * page_try_dup_anon_rmap - try duplicating a mapping of an already mapped
> + *                         anonymous page
> + * @page: the page to duplicate the mapping for
> + * @compound: the page is mapped as compound or as a small page
> + * @vma: the source vma
> + *
> + * The caller needs to hold the PT lock and the vma->vma_mm->write_protect_seq.
> + *
> + * Duplicating the mapping can only fail if the page may be pinned; device
> + * private pages cannot get pinned and consequently this function cannot fail.
> + *
> + * If duplicating the mapping succeeds, the page has to be mapped R/O into
> + * the parent and the child. It must *not* get mapped writable after this call.
> + *
> + * Returns 0 if duplicating the mapping succeeded. Returns -EBUSY otherwise.
> + */
> +static inline int page_try_dup_anon_rmap(struct page *page, bool compound,
> +                                        struct vm_area_struct *vma)
> +{
> +       VM_BUG_ON_PAGE(!PageAnon(page), page);
> +
> +       /*
> +        * If this page may have been pinned by the parent process,
> +        * don't allow to duplicate the mapping but instead require to e.g.,
> +        * copy the page immediately for the child so that we'll always
> +        * guarantee the pinned page won't be randomly replaced in the
> +        * future on write faults.
> +        */
> +       if (likely(!is_device_private_page(page) &&
> +           unlikely(page_needs_cow_for_dma(vma, page))))
> +               return -EBUSY;
> +
> +       /*
> +        * It's okay to share the anon page between both processes, mapping
> +        * the page R/O into both processes.
> +        */
> +       __page_dup_rmap(page, compound);
> +       return 0;
> +}
> +
>  /*
>   * Called from mm/vmscan.c to handle paging out
>   */
> diff --git a/mm/huge_memory.c b/mm/huge_memory.c
> index cda88d8ac1bd..c126d728b8de 100644
> --- a/mm/huge_memory.c
> +++ b/mm/huge_memory.c
> @@ -1097,23 +1097,16 @@ int copy_huge_pmd(struct mm_struct *dst_mm, struct mm_struct *src_mm,
>         src_page = pmd_page(pmd);
>         VM_BUG_ON_PAGE(!PageHead(src_page), src_page);
>
> -       /*
> -        * If this page is a potentially pinned page, split and retry the fault
> -        * with smaller page size.  Normally this should not happen because the
> -        * userspace should use MADV_DONTFORK upon pinned regions.  This is a
> -        * best effort that the pinned pages won't be replaced by another
> -        * random page during the coming copy-on-write.
> -        */
> -       if (unlikely(page_needs_cow_for_dma(src_vma, src_page))) {
> +       get_page(src_page);
> +       if (unlikely(page_try_dup_anon_rmap(src_page, true, src_vma))) {
> +               /* Page maybe pinned: split and retry the fault on PTEs. */
> +               put_page(src_page);

Do we have to do the get_page()/put_page() sequence? It seems we don't
have to get the page before calling page_try_dup_anon_rmap(), right?
We just need to bump page refcount when dupping rmap successfully. So
we could do:

if (unlikely(page_try_dup_anon_rmap(src_page, true, src_vma))) {
    /* do something */
}

get_page(src_page)

>                 pte_free(dst_mm, pgtable);
>                 spin_unlock(src_ptl);
>                 spin_unlock(dst_ptl);
>                 __split_huge_pmd(src_vma, src_pmd, addr, false, NULL);
>                 return -EAGAIN;
>         }
> -
> -       get_page(src_page);
> -       page_dup_rmap(src_page, true);
>         add_mm_counter(dst_mm, MM_ANONPAGES, HPAGE_PMD_NR);
>  out_zero_page:
>         mm_inc_nr_ptes(dst_mm);
> @@ -1217,14 +1210,10 @@ int copy_huge_pud(struct mm_struct *dst_mm, struct mm_struct *src_mm,
>                 /* No huge zero pud yet */
>         }
>
> -       /* Please refer to comments in copy_huge_pmd() */
> -       if (unlikely(page_needs_cow_for_dma(vma, pud_page(pud)))) {
> -               spin_unlock(src_ptl);
> -               spin_unlock(dst_ptl);
> -               __split_huge_pud(vma, src_pud, addr);
> -               return -EAGAIN;
> -       }
> -
> +       /*
> +        * TODO: once we support anonymous pages, use page_try_dup_anon_rmap()
> +        * and split if duplicating fails.
> +        */
>         pudp_set_wrprotect(src_mm, addr, src_pud);
>         pud = pud_mkold(pud_wrprotect(pud));
>         set_pud_at(dst_mm, addr, dst_pud, pud);
> diff --git a/mm/hugetlb.c b/mm/hugetlb.c
> index d3ce89697855..9fb990d95dab 100644
> --- a/mm/hugetlb.c
> +++ b/mm/hugetlb.c
> @@ -4781,15 +4781,18 @@ int copy_hugetlb_page_range(struct mm_struct *dst, struct mm_struct *src,
>                         get_page(ptepage);
>
>                         /*
> -                        * This is a rare case where we see pinned hugetlb
> -                        * pages while they're prone to COW.  We need to do the
> -                        * COW earlier during fork.
> +                        * Failing to duplicate the anon rmap is a rare case
> +                        * where we see pinned hugetlb pages while they're
> +                        * prone to COW. We need to do the COW earlier during
> +                        * fork.
>                          *
>                          * When pre-allocating the page or copying data, we
>                          * need to be without the pgtable locks since we could
>                          * sleep during the process.
>                          */
> -                       if (unlikely(page_needs_cow_for_dma(vma, ptepage))) {
> +                       if (!PageAnon(ptepage)) {
> +                               page_dup_file_rmap(ptepage, true);
> +                       } else if (page_try_dup_anon_rmap(ptepage, true, vma)) {
>                                 pte_t src_pte_old = entry;
>                                 struct page *new;
>
> @@ -4836,7 +4839,6 @@ int copy_hugetlb_page_range(struct mm_struct *dst, struct mm_struct *src,
>                                 entry = huge_pte_wrprotect(entry);
>                         }
>
> -                       page_dup_rmap(ptepage, true);
>                         set_huge_pte_at(dst, addr, dst_pte, entry);
>                         hugetlb_count_add(npages, dst);
>                 }
> @@ -5514,7 +5516,7 @@ static vm_fault_t hugetlb_no_page(struct mm_struct *mm,
>                 ClearHPageRestoreReserve(page);
>                 hugepage_add_new_anon_rmap(page, vma, haddr);
>         } else
> -               page_dup_rmap(page, true);
> +               page_dup_file_rmap(page, true);
>         new_pte = make_huge_pte(vma, page, ((vma->vm_flags & VM_WRITE)
>                                 && (vma->vm_flags & VM_SHARED)));
>         set_huge_pte_at(mm, haddr, ptep, new_pte);
> @@ -5874,7 +5876,7 @@ int hugetlb_mcopy_atomic_pte(struct mm_struct *dst_mm,
>                 goto out_release_unlock;
>
>         if (vm_shared) {
> -               page_dup_rmap(page, true);
> +               page_dup_file_rmap(page, true);
>         } else {
>                 ClearHPageRestoreReserve(page);
>                 hugepage_add_new_anon_rmap(page, dst_vma, dst_addr);
> diff --git a/mm/memory.c b/mm/memory.c
> index accb72a3343d..b9602d41d907 100644
> --- a/mm/memory.c
> +++ b/mm/memory.c
> @@ -828,7 +828,8 @@ copy_nonpresent_pte(struct mm_struct *dst_mm, struct mm_struct *src_mm,
>                  */
>                 get_page(page);
>                 rss[mm_counter(page)]++;
> -               page_dup_rmap(page, false);
> +               /* Cannot fail as these pages cannot get pinned. */
> +               BUG_ON(page_try_dup_anon_rmap(page, false, src_vma));
>
>                 /*
>                  * We do not preserve soft-dirty information, because so
> @@ -924,18 +925,24 @@ copy_present_pte(struct vm_area_struct *dst_vma, struct vm_area_struct *src_vma,
>         struct page *page;
>
>         page = vm_normal_page(src_vma, addr, pte);
> -       if (page && unlikely(page_needs_cow_for_dma(src_vma, page))) {
> +       if (page && PageAnon(page)) {
>                 /*
>                  * If this page may have been pinned by the parent process,
>                  * copy the page immediately for the child so that we'll always
>                  * guarantee the pinned page won't be randomly replaced in the
>                  * future.
>                  */
> -               return copy_present_page(dst_vma, src_vma, dst_pte, src_pte,
> -                                        addr, rss, prealloc, page);
> +               get_page(page);
> +               if (unlikely(page_try_dup_anon_rmap(page, false, src_vma))) {
> +                       /* Page maybe pinned, we have to copy. */
> +                       put_page(page);
> +                       return copy_present_page(dst_vma, src_vma, dst_pte, src_pte,
> +                                                addr, rss, prealloc, page);
> +               }
> +               rss[mm_counter(page)]++;
>         } else if (page) {
>                 get_page(page);
> -               page_dup_rmap(page, false);
> +               page_dup_file_rmap(page, false);
>                 rss[mm_counter(page)]++;
>         }
>
> diff --git a/mm/migrate.c b/mm/migrate.c
> index c7da064b4781..524c2648ab36 100644
> --- a/mm/migrate.c
> +++ b/mm/migrate.c
> @@ -240,7 +240,7 @@ static bool remove_migration_pte(struct page *page, struct vm_area_struct *vma,
>                         if (PageAnon(new))
>                                 hugepage_add_anon_rmap(new, vma, pvmw.address);
>                         else
> -                               page_dup_rmap(new, true);
> +                               page_dup_file_rmap(new, true);
>                         set_huge_pte_at(vma->vm_mm, pvmw.address, pvmw.pte, pte);
>                 } else
>  #endif
> --
> 2.35.1
>

Re: [PATCH v2 11/15] mm: remember exclusively mapped anonymous pages with PG_anon_exclusive

[Yang Shi]

On Tue, Mar 15, 2022 at 3:52 AM David Hildenbrand <david@redhat.com> wrote:
>
> Let's mark exclusively mapped anonymous pages with PG_anon_exclusive as
> exclusive, and use that information to make GUP pins reliable and stay
> consistent with the page mapped into the page table even if the
> page table entry gets write-protected.
>
> With that information at hand, we can extend our COW logic to always
> reuse anonymous pages that are exclusive. For anonymous pages that
> might be shared, the existing logic applies.
>
> As already documented, PG_anon_exclusive is usually only expressive in
> combination with a page table entry. Especially PTE vs. PMD-mapped
> anonymous pages require more thought, some examples: due to mremap() we
> can easily have a single compound page PTE-mapped into multiple page tables
> exclusively in a single process -- multiple page table locks apply.
> Further, due to MADV_WIPEONFORK we might not necessarily write-protect
> all PTEs, and only some subpages might be pinned. Long story short: once
> PTE-mapped, we have to track information about exclusivity per sub-page,
> but until then, we can just track it for the compound page in the head
> page and not having to update a whole bunch of subpages all of the time
> for a simple PMD mapping of a THP.
>
> For simplicity, this commit mostly talks about "anonymous pages", while
> it's for THP actually "the part of an anonymous folio referenced via
> a page table entry".
>
> To not spill PG_anon_exclusive code all over the mm code-base, we let
> the anon rmap code to handle all PG_anon_exclusive logic it can easily
> handle.
>
> If a writable, present page table entry points at an anonymous (sub)page,
> that (sub)page must be PG_anon_exclusive. If GUP wants to take a reliably
> pin (FOLL_PIN) on an anonymous page references via a present
> page table entry, it must only pin if PG_anon_exclusive is set for the
> mapped (sub)page.
>
> This commit doesn't adjust GUP, so this is only implicitly handled for
> FOLL_WRITE, follow-up commits will teach GUP to also respect it for
> FOLL_PIN without !FOLL_WRITE, to make all GUP pins of anonymous pages
> fully reliable.
>
> Whenever an anonymous page is to be shared (fork(), KSM), or when
> temporarily unmapping an anonymous page (swap, migration), the relevant
> PG_anon_exclusive bit has to be cleared to mark the anonymous page
> possibly shared. Clearing will fail if there are GUP pins on the page:
> * For fork(), this means having to copy the page and not being able to
>   share it. fork() protects against concurrent GUP using the PT lock and
>   the src_mm->write_protect_seq.
> * For KSM, this means sharing will fail. For swap this means, unmapping
>   will fail, For migration this means, migration will fail early. All
>   three cases protect against concurrent GUP using the PT lock and a
>   proper clear/invalidate+flush of the relevant page table entry.
>
> This fixes memory corruptions reported for FOLL_PIN | FOLL_WRITE, when a
> pinned page gets mapped R/O and the successive write fault ends up
> replacing the page instead of reusing it. It improves the situation for
> O_DIRECT/vmsplice/... that still use FOLL_GET instead of FOLL_PIN,
> if fork() is *not* involved, however swapout and fork() are still
> problematic. Properly using FOLL_PIN instead of FOLL_GET for these
> GUP users will fix the issue for them.
>
> I. Details about basic handling
>
> I.1. Fresh anonymous pages
>
> page_add_new_anon_rmap() and hugepage_add_new_anon_rmap() will mark the
> given page exclusive via __page_set_anon_rmap(exclusive=1). As that is
> the mechanism fresh anonymous pages come into life (besides migration
> code where we copy the page->mapping), all fresh anonymous pages will
> start out as exclusive.
>
> I.2. COW reuse handling of anonymous pages
>
> When a COW handler stumbles over a (sub)page that's marked exclusive, it
> simply reuses it. Otherwise, the handler tries harder under page lock to
> detect if the (sub)page is exclusive and can be reused. If exclusive,
> page_move_anon_rmap() will mark the given (sub)page exclusive.
>
> Note that hugetlb code does not yet check for PageAnonExclusive(), as it
> still uses the old COW logic that is prone to the COW security issue
> because hugetlb code cannot really tolerate unnecessary/wrong COW as
> huge pages are a scarce resource.
>
> I.3. Migration handling
>
> try_to_migrate() has to try marking an exclusive anonymous page shared
> via page_try_share_anon_rmap(). If it fails because there are GUP pins
> on the page, unmap fails. migrate_vma_collect_pmd() and
> __split_huge_pmd_locked() are handled similarly.
>
> Writable migration entries implicitly point at shared anonymous pages.
> For readable migration entries that information is stored via a new
> "readable-exclusive" migration entry, specific to anonymous pages.
>
> When restoring a migration entry in remove_migration_pte(), information
> about exlusivity is detected via the migration entry type, and
> RMAP_EXCLUSIVE is set accordingly for
> page_add_anon_rmap()/hugepage_add_anon_rmap() to restore that
> information.
>
> I.4. Swapout handling
>
> try_to_unmap() has to try marking the mapped page possibly shared via
> page_try_share_anon_rmap(). If it fails because there are GUP pins on the
> page, unmap fails. For now, information about exclusivity is lost. In the
> future, we might want to remember that information in the swap entry in
> some cases, however, it requires more thought, care, and a way to store
> that information in swap entries.
>
> I.5. Swapin handling
>
> do_swap_page() will never stumble over exclusive anonymous pages in the
> swap cache, as try_to_migrate() prohibits that. do_swap_page() always has
> to detect manually if an anonymous page is exclusive and has to set
> RMAP_EXCLUSIVE for page_add_anon_rmap() accordingly.
>
> I.6. THP handling
>
> __split_huge_pmd_locked() has to move the information about exclusivity
> from the PMD to the PTEs.
>
> a) In case we have a readable-exclusive PMD migration entry, simply insert
> readable-exclusive PTE migration entries.
>
> b) In case we have a present PMD entry and we don't want to freeze
> ("convert to migration entries"), simply forward PG_anon_exclusive to
> all sub-pages, no need to temporarily clear the bit.
>
> c) In case we have a present PMD entry and want to freeze, handle it
> similar to try_to_migrate(): try marking the page shared first. In case
> we fail, we ignore the "freeze" instruction and simply split ordinarily.
> try_to_migrate() will properly fail because the THP is still mapped via
> PTEs.

How come will try_to_migrate() fail? The afterward pvmw will find
those PTEs then convert them to migration entries anyway IIUC.

>
> When splitting a compound anonymous folio (THP), the information about
> exclusivity is implicitly handled via the migration entries: no need to
> replicate PG_anon_exclusive manually.
>
> I.7. fork() handling
>
> fork() handling is relatively easy, because PG_anon_exclusive is only
> expressive for some page table entry types.
>
> a) Present anonymous pages
>
> page_try_dup_anon_rmap() will mark the given subpage shared -- which
> will fail if the page is pinned. If it failed, we have to copy (or
> PTE-map a PMD to handle it on the PTE level).
>
> Note that device exclusive entries are just a pointer at a PageAnon()
> page. fork() will first convert a device exclusive entry to a present
> page table and handle it just like present anonymous pages.
>
> b) Device private entry
>
> Device private entries point at PageAnon() pages that cannot be mapped
> directly and, therefore, cannot get pinned.
>
> page_try_dup_anon_rmap() will mark the given subpage shared, which
> cannot fail because they cannot get pinned.
>
> c) HW poison entries
>
> PG_anon_exclusive will remain untouched and is stale -- the page table
> entry is just a placeholder after all.
>
> d) Migration entries
>
> Writable and readable-exclusive entries are converted to readable
> entries: possibly shared.
>
> I.8. mprotect() handling
>
> mprotect() only has to properly handle the new readable-exclusive
> migration entry:
>
> When write-protecting a migration entry that points at an anonymous
> page, remember the information about exclusivity via the
> "readable-exclusive" migration entry type.
>
> II. Migration and GUP-fast
>
> Whenever replacing a present page table entry that maps an exclusive
> anonymous page by a migration entry, we have to mark the page possibly
> shared and synchronize against GUP-fast by a proper
> clear/invalidate+flush to make the following scenario impossible:
>
> 1. try_to_migrate() places a migration entry after checking for GUP pins
>    and marks the page possibly shared.
> 2. GUP-fast pins the page due to lack of synchronization
> 3. fork() converts the "writable/readable-exclusive" migration entry into a
>    readable migration entry
> 4. Migration fails due to the GUP pin (failing to freeze the refcount)
> 5. Migration entries are restored. PG_anon_exclusive is lost
>
> -> We have a pinned page that is not marked exclusive anymore.
>
> Note that we move information about exclusivity from the page to the
> migration entry as it otherwise highly overcomplicates fork() and
> PTE-mapping a THP.
>
> III. Swapout and GUP-fast
>
> Whenever replacing a present page table entry that maps an exclusive
> anonymous page by a swap entry, we have to mark the page possibly
> shared and synchronize against GUP-fast by a proper
> clear/invalidate+flush to make the following scenario impossible:
>
> 1. try_to_unmap() places a swap entry after checking for GUP pins and
>    clears exclusivity information on the page.
> 2. GUP-fast pins the page due to lack of synchronization.
>
> -> We have a pinned page that is not marked exclusive anymore.
>
> If we'd ever store information about exclusivity in the swap entry,
> similar to migration handling, the same considerations as in II would
> apply. This is future work.
>
> Signed-off-by: David Hildenbrand <david@redhat.com>
> ---
>  include/linux/rmap.h    | 40 +++++++++++++++++++++
>  include/linux/swap.h    | 15 +++++---
>  include/linux/swapops.h | 25 +++++++++++++
>  mm/huge_memory.c        | 77 +++++++++++++++++++++++++++++++++++++----
>  mm/hugetlb.c            | 15 +++++---
>  mm/ksm.c                | 13 ++++++-
>  mm/memory.c             | 33 +++++++++++++-----
>  mm/migrate.c            | 34 ++++++++++++++++--
>  mm/mprotect.c           |  8 +++--
>  mm/rmap.c               | 59 ++++++++++++++++++++++++++++---
>  10 files changed, 285 insertions(+), 34 deletions(-)
>
> diff --git a/include/linux/rmap.h b/include/linux/rmap.h
> index 51953bace0a3..1aef834e1d60 100644
> --- a/include/linux/rmap.h
> +++ b/include/linux/rmap.h
> @@ -224,6 +224,13 @@ static inline int page_try_dup_anon_rmap(struct page *page, bool compound,
>  {
>         VM_BUG_ON_PAGE(!PageAnon(page), page);
>
> +       /*
> +        * No need to check+clear for already shared pages, including KSM
> +        * pages.
> +        */
> +       if (!PageAnonExclusive(page))
> +               goto dup;
> +
>         /*
>          * If this page may have been pinned by the parent process,
>          * don't allow to duplicate the mapping but instead require to e.g.,
> @@ -235,14 +242,47 @@ static inline int page_try_dup_anon_rmap(struct page *page, bool compound,
>             unlikely(page_needs_cow_for_dma(vma, page))))
>                 return -EBUSY;
>
> +       ClearPageAnonExclusive(page);
>         /*
>          * It's okay to share the anon page between both processes, mapping
>          * the page R/O into both processes.
>          */
> +dup:
>         __page_dup_rmap(page, compound);
>         return 0;
>  }
>
> +/**
> + * page_try_share_anon_rmap - try marking an exclusive anonymous page possibly
> + *                           shared to prepare for KSM or temporary unmapping
> + * @page: the exclusive anonymous page to try marking possibly shared
> + *
> + * The caller needs to hold the PT lock and has to have the page table entry
> + * cleared/invalidated+flushed, to properly sync against GUP-fast.
> + *
> + * This is similar to page_try_dup_anon_rmap(), however, not used during fork()
> + * to duplicate a mapping, but instead to prepare for KSM or temporarily
> + * unmapping a page (swap, migration) via page_remove_rmap().
> + *
> + * Marking the page shared can only fail if the page may be pinned; device
> + * private pages cannot get pinned and consequently this function cannot fail.
> + *
> + * Returns 0 if marking the page possibly shared succeeded. Returns -EBUSY
> + * otherwise.
> + */
> +static inline int page_try_share_anon_rmap(struct page *page)
> +{
> +       VM_BUG_ON_PAGE(!PageAnon(page) || !PageAnonExclusive(page), page);
> +
> +       /* See page_try_dup_anon_rmap(). */
> +       if (likely(!is_device_private_page(page) &&
> +           unlikely(page_maybe_dma_pinned(page))))
> +               return -EBUSY;
> +
> +       ClearPageAnonExclusive(page);
> +       return 0;
> +}
> +
>  /*
>   * Called from mm/vmscan.c to handle paging out
>   */
> diff --git a/include/linux/swap.h b/include/linux/swap.h
> index b546e4bd5c5a..422765d1141c 100644
> --- a/include/linux/swap.h
> +++ b/include/linux/swap.h
> @@ -78,12 +78,19 @@ static inline int current_is_kswapd(void)
>  #endif
>
>  /*
> - * NUMA node memory migration support
> + * Page migration support.
> + *
> + * SWP_MIGRATION_READ_EXCLUSIVE is only applicable to anonymous pages and
> + * indicates that the referenced (part of) an anonymous page is exclusive to
> + * a single process. For SWP_MIGRATION_WRITE, that information is implicit:
> + * (part of) an anonymous page that are mapped writable are exclusive to a
> + * single process.
>   */
>  #ifdef CONFIG_MIGRATION
> -#define SWP_MIGRATION_NUM 2
> -#define SWP_MIGRATION_READ     (MAX_SWAPFILES + SWP_HWPOISON_NUM)
> -#define SWP_MIGRATION_WRITE    (MAX_SWAPFILES + SWP_HWPOISON_NUM + 1)
> +#define SWP_MIGRATION_NUM 3
> +#define SWP_MIGRATION_READ (MAX_SWAPFILES + SWP_HWPOISON_NUM)
> +#define SWP_MIGRATION_READ_EXCLUSIVE (MAX_SWAPFILES + SWP_HWPOISON_NUM + 1)
> +#define SWP_MIGRATION_WRITE (MAX_SWAPFILES + SWP_HWPOISON_NUM + 2)
>  #else
>  #define SWP_MIGRATION_NUM 0
>  #endif
> diff --git a/include/linux/swapops.h b/include/linux/swapops.h
> index d356ab4047f7..06280fc1c99b 100644
> --- a/include/linux/swapops.h
> +++ b/include/linux/swapops.h
> @@ -194,6 +194,7 @@ static inline bool is_writable_device_exclusive_entry(swp_entry_t entry)
>  static inline int is_migration_entry(swp_entry_t entry)
>  {
>         return unlikely(swp_type(entry) == SWP_MIGRATION_READ ||
> +                       swp_type(entry) == SWP_MIGRATION_READ_EXCLUSIVE ||
>                         swp_type(entry) == SWP_MIGRATION_WRITE);
>  }
>
> @@ -202,11 +203,26 @@ static inline int is_writable_migration_entry(swp_entry_t entry)
>         return unlikely(swp_type(entry) == SWP_MIGRATION_WRITE);
>  }
>
> +static inline int is_readable_migration_entry(swp_entry_t entry)
> +{
> +       return unlikely(swp_type(entry) == SWP_MIGRATION_READ);
> +}
> +
> +static inline int is_readable_exclusive_migration_entry(swp_entry_t entry)
> +{
> +       return unlikely(swp_type(entry) == SWP_MIGRATION_READ_EXCLUSIVE);
> +}
> +
>  static inline swp_entry_t make_readable_migration_entry(pgoff_t offset)
>  {
>         return swp_entry(SWP_MIGRATION_READ, offset);
>  }
>
> +static inline swp_entry_t make_readable_exclusive_migration_entry(pgoff_t offset)
> +{
> +       return swp_entry(SWP_MIGRATION_READ_EXCLUSIVE, offset);
> +}
> +
>  static inline swp_entry_t make_writable_migration_entry(pgoff_t offset)
>  {
>         return swp_entry(SWP_MIGRATION_WRITE, offset);
> @@ -224,6 +240,11 @@ static inline swp_entry_t make_readable_migration_entry(pgoff_t offset)
>         return swp_entry(0, 0);
>  }
>
> +static inline swp_entry_t make_readable_exclusive_migration_entry(pgoff_t offset)
> +{
> +       return swp_entry(0, 0);
> +}
> +
>  static inline swp_entry_t make_writable_migration_entry(pgoff_t offset)
>  {
>         return swp_entry(0, 0);
> @@ -244,6 +265,10 @@ static inline int is_writable_migration_entry(swp_entry_t entry)
>  {
>         return 0;
>  }
> +static inline int is_readable_migration_entry(swp_entry_t entry)
> +{
> +       return 0;
> +}
>
>  #endif
>
> diff --git a/mm/huge_memory.c b/mm/huge_memory.c
> index 0b6fb409b9e4..4872e7120ee1 100644
> --- a/mm/huge_memory.c
> +++ b/mm/huge_memory.c
> @@ -1054,7 +1054,7 @@ int copy_huge_pmd(struct mm_struct *dst_mm, struct mm_struct *src_mm,
>                 swp_entry_t entry = pmd_to_swp_entry(pmd);
>
>                 VM_BUG_ON(!is_pmd_migration_entry(pmd));
> -               if (is_writable_migration_entry(entry)) {
> +               if (!is_readable_migration_entry(entry)) {
>                         entry = make_readable_migration_entry(
>                                                         swp_offset(entry));
>                         pmd = swp_entry_to_pmd(entry);
> @@ -1292,6 +1292,10 @@ vm_fault_t do_huge_pmd_wp_page(struct vm_fault *vmf)
>         page = pmd_page(orig_pmd);
>         VM_BUG_ON_PAGE(!PageHead(page), page);
>
> +       /* Early check when only holding the PT lock. */
> +       if (PageAnonExclusive(page))
> +               goto reuse;
> +
>         if (!trylock_page(page)) {
>                 get_page(page);
>                 spin_unlock(vmf->ptl);
> @@ -1306,6 +1310,12 @@ vm_fault_t do_huge_pmd_wp_page(struct vm_fault *vmf)
>                 put_page(page);
>         }
>
> +       /* Recheck after temporarily dropping the PT lock. */
> +       if (PageAnonExclusive(page)) {
> +               unlock_page(page);
> +               goto reuse;
> +       }
> +
>         /*
>          * See do_wp_page(): we can only map the page writable if there are
>          * no additional references. Note that we always drain the LRU
> @@ -1319,11 +1329,12 @@ vm_fault_t do_huge_pmd_wp_page(struct vm_fault *vmf)
>                 pmd_t entry;
>
>                 page_move_anon_rmap(page, vma);
> +               unlock_page(page);
> +reuse:
>                 entry = pmd_mkyoung(orig_pmd);
>                 entry = maybe_pmd_mkwrite(pmd_mkdirty(entry), vma);
>                 if (pmdp_set_access_flags(vma, haddr, vmf->pmd, entry, 1))
>                         update_mmu_cache_pmd(vma, vmf->address, vmf->pmd);
> -               unlock_page(page);
>                 spin_unlock(vmf->ptl);
>                 return VM_FAULT_WRITE;
>         }
> @@ -1741,6 +1752,7 @@ int change_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd,
>  #ifdef CONFIG_ARCH_ENABLE_THP_MIGRATION
>         if (is_swap_pmd(*pmd)) {
>                 swp_entry_t entry = pmd_to_swp_entry(*pmd);
> +               struct page *page = pfn_swap_entry_to_page(entry);
>
>                 VM_BUG_ON(!is_pmd_migration_entry(*pmd));
>                 if (is_writable_migration_entry(entry)) {
> @@ -1749,8 +1761,10 @@ int change_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd,
>                          * A protection check is difficult so
>                          * just be safe and disable write
>                          */
> -                       entry = make_readable_migration_entry(
> -                                                       swp_offset(entry));
> +                       if (PageAnon(page))
> +                               entry = make_readable_exclusive_migration_entry(swp_offset(entry));
> +                       else
> +                               entry = make_readable_migration_entry(swp_offset(entry));
>                         newpmd = swp_entry_to_pmd(entry);
>                         if (pmd_swp_soft_dirty(*pmd))
>                                 newpmd = pmd_swp_mksoft_dirty(newpmd);
> @@ -1959,6 +1973,7 @@ static void __split_huge_pmd_locked(struct vm_area_struct *vma, pmd_t *pmd,
>         pgtable_t pgtable;
>         pmd_t old_pmd, _pmd;
>         bool young, write, soft_dirty, pmd_migration = false, uffd_wp = false;
> +       bool anon_exclusive = false;
>         unsigned long addr;
>         int i;
>
> @@ -2040,6 +2055,8 @@ static void __split_huge_pmd_locked(struct vm_area_struct *vma, pmd_t *pmd,
>                 entry = pmd_to_swp_entry(old_pmd);
>                 page = pfn_swap_entry_to_page(entry);
>                 write = is_writable_migration_entry(entry);
> +               if (PageAnon(page))
> +                       anon_exclusive = is_readable_exclusive_migration_entry(entry);
>                 young = false;
>                 soft_dirty = pmd_swp_soft_dirty(old_pmd);
>                 uffd_wp = pmd_swp_uffd_wp(old_pmd);
> @@ -2051,6 +2068,23 @@ static void __split_huge_pmd_locked(struct vm_area_struct *vma, pmd_t *pmd,
>                 young = pmd_young(old_pmd);
>                 soft_dirty = pmd_soft_dirty(old_pmd);
>                 uffd_wp = pmd_uffd_wp(old_pmd);
> +
> +               /*
> +                * Without "freeze", we'll simply split the PMD, propagating the
> +                * PageAnonExclusive() flag for each PTE by setting it for
> +                * each subpage -- no need to (temporarily) clear.
> +                *
> +                * With "freeze" we want to replace mapped pages by
> +                * migration entries right away. This is only possible if we
> +                * managed to clear PageAnonExclusive() -- see
> +                * set_pmd_migration_entry().
> +                *
> +                * In case we cannot clear PageAnonExclusive(), split the PMD
> +                * only and let try_to_migrate_one() fail later.
> +                */
> +               anon_exclusive = PageAnon(page) && PageAnonExclusive(page);
> +               if (freeze && anon_exclusive && page_try_share_anon_rmap(page))
> +                       freeze = false;
>         }
>         VM_BUG_ON_PAGE(!page_count(page), page);
>         page_ref_add(page, HPAGE_PMD_NR - 1);
> @@ -2074,6 +2108,9 @@ static void __split_huge_pmd_locked(struct vm_area_struct *vma, pmd_t *pmd,
>                         if (write)
>                                 swp_entry = make_writable_migration_entry(
>                                                         page_to_pfn(page + i));
> +                       else if (anon_exclusive)
> +                               swp_entry = make_readable_exclusive_migration_entry(
> +                                                       page_to_pfn(page + i));
>                         else
>                                 swp_entry = make_readable_migration_entry(
>                                                         page_to_pfn(page + i));
> @@ -2085,6 +2122,8 @@ static void __split_huge_pmd_locked(struct vm_area_struct *vma, pmd_t *pmd,
>                 } else {
>                         entry = mk_pte(page + i, READ_ONCE(vma->vm_page_prot));
>                         entry = maybe_mkwrite(entry, vma);
> +                       if (anon_exclusive)
> +                               SetPageAnonExclusive(page + i);
>                         if (!write)
>                                 entry = pte_wrprotect(entry);
>                         if (!young)
> @@ -2315,6 +2354,13 @@ static void __split_huge_page_tail(struct page *head, int tail,
>          *
>          * After successful get_page_unless_zero() might follow flags change,
>          * for example lock_page() which set PG_waiters.
> +        *
> +        * Note that for mapped sub-pages of an anonymous THP,
> +        * PG_anon_exclusive has been cleared in unmap_page() and is stored in
> +        * the migration entry instead from where remap_page() will restore it.
> +        * We can still have PG_anon_exclusive set on effectively unmapped and
> +        * unreferenced sub-pages of an anonymous THP: we can simply drop
> +        * PG_anon_exclusive (-> PG_mappedtodisk) for these here.
>          */
>         page_tail->flags &= ~PAGE_FLAGS_CHECK_AT_PREP;
>         page_tail->flags |= (head->flags &
> @@ -3070,6 +3116,7 @@ void set_pmd_migration_entry(struct page_vma_mapped_walk *pvmw,
>         struct vm_area_struct *vma = pvmw->vma;
>         struct mm_struct *mm = vma->vm_mm;
>         unsigned long address = pvmw->address;
> +       bool anon_exclusive;
>         pmd_t pmdval;
>         swp_entry_t entry;
>         pmd_t pmdswp;
> @@ -3079,10 +3126,19 @@ void set_pmd_migration_entry(struct page_vma_mapped_walk *pvmw,
>
>         flush_cache_range(vma, address, address + HPAGE_PMD_SIZE);
>         pmdval = pmdp_invalidate(vma, address, pvmw->pmd);
> +
> +       anon_exclusive = PageAnon(page) && PageAnonExclusive(page);
> +       if (anon_exclusive && page_try_share_anon_rmap(page)) {
> +               set_pmd_at(mm, address, pvmw->pmd, pmdval);
> +               return;
> +       }
> +
>         if (pmd_dirty(pmdval))
>                 set_page_dirty(page);
>         if (pmd_write(pmdval))
>                 entry = make_writable_migration_entry(page_to_pfn(page));
> +       else if (anon_exclusive)
> +               entry = make_readable_exclusive_migration_entry(page_to_pfn(page));
>         else
>                 entry = make_readable_migration_entry(page_to_pfn(page));
>         pmdswp = swp_entry_to_pmd(entry);
> @@ -3116,10 +3172,17 @@ void remove_migration_pmd(struct page_vma_mapped_walk *pvmw, struct page *new)
>                 pmde = pmd_wrprotect(pmd_mkuffd_wp(pmde));
>
>         flush_cache_range(vma, mmun_start, mmun_start + HPAGE_PMD_SIZE);
> -       if (PageAnon(new))
> -               page_add_anon_rmap(new, vma, mmun_start, RMAP_COMPOUND);
> -       else
> +       if (PageAnon(new)) {
> +               int rmap_flags = RMAP_COMPOUND;
> +
> +               if (!is_readable_migration_entry(entry))
> +                       rmap_flags |= RMAP_EXCLUSIVE;
> +
> +               page_add_anon_rmap(new, vma, mmun_start, rmap_flags);
> +       } else {
>                 page_add_file_rmap(new, true);
> +       }
> +       VM_BUG_ON(pmd_write(pmde) && PageAnon(new) && !PageAnonExclusive(new));
>         set_pmd_at(mm, mmun_start, pvmw->pmd, pmde);
>         if ((vma->vm_flags & VM_LOCKED) && !PageDoubleMap(new))
>                 mlock_vma_page(new);
> diff --git a/mm/hugetlb.c b/mm/hugetlb.c
> index 1ff0b9e1e28e..c0e19ea5ebb5 100644
> --- a/mm/hugetlb.c
> +++ b/mm/hugetlb.c
> @@ -4765,7 +4765,7 @@ int copy_hugetlb_page_range(struct mm_struct *dst, struct mm_struct *src,
>                                     is_hugetlb_entry_hwpoisoned(entry))) {
>                         swp_entry_t swp_entry = pte_to_swp_entry(entry);
>
> -                       if (is_writable_migration_entry(swp_entry) && cow) {
> +                       if (!is_readable_migration_entry(swp_entry) && cow) {
>                                 /*
>                                  * COW mappings require pages in both
>                                  * parent and child to be set to read.
> @@ -5165,6 +5165,8 @@ static vm_fault_t hugetlb_cow(struct mm_struct *mm, struct vm_area_struct *vma,
>                 set_huge_ptep_writable(vma, haddr, ptep);
>                 return 0;
>         }
> +       VM_BUG_ON_PAGE(PageAnon(old_page) && PageAnonExclusive(old_page),
> +                      old_page);
>
>         /*
>          * If the process that created a MAP_PRIVATE mapping is about to
> @@ -6160,12 +6162,17 @@ unsigned long hugetlb_change_protection(struct vm_area_struct *vma,
>                 }
>                 if (unlikely(is_hugetlb_entry_migration(pte))) {
>                         swp_entry_t entry = pte_to_swp_entry(pte);
> +                       struct page *page = pfn_swap_entry_to_page(entry);
>
> -                       if (is_writable_migration_entry(entry)) {
> +                       if (!is_readable_migration_entry(entry)) {
>                                 pte_t newpte;
>
> -                               entry = make_readable_migration_entry(
> -                                                       swp_offset(entry));
> +                               if (PageAnon(page))
> +                                       entry = make_readable_exclusive_migration_entry(
> +                                                               swp_offset(entry));
> +                               else
> +                                       entry = make_readable_migration_entry(
> +                                                               swp_offset(entry));
>                                 newpte = swp_entry_to_pte(entry);
>                                 set_huge_swap_pte_at(mm, address, ptep,
>                                                      newpte, huge_page_size(h));
> diff --git a/mm/ksm.c b/mm/ksm.c
> index 9ff28097bc0a..350b46432d65 100644
> --- a/mm/ksm.c
> +++ b/mm/ksm.c
> @@ -866,6 +866,7 @@ static inline struct stable_node *page_stable_node(struct page *page)
>  static inline void set_page_stable_node(struct page *page,
>                                         struct stable_node *stable_node)
>  {
> +       VM_BUG_ON_PAGE(PageAnon(page) && PageAnonExclusive(page), page);
>         page->mapping = (void *)((unsigned long)stable_node | PAGE_MAPPING_KSM);
>  }
>
> @@ -1041,6 +1042,7 @@ static int write_protect_page(struct vm_area_struct *vma, struct page *page,
>         int swapped;
>         int err = -EFAULT;
>         struct mmu_notifier_range range;
> +       bool anon_exclusive;
>
>         pvmw.address = page_address_in_vma(page, vma);
>         if (pvmw.address == -EFAULT)
> @@ -1058,9 +1060,10 @@ static int write_protect_page(struct vm_area_struct *vma, struct page *page,
>         if (WARN_ONCE(!pvmw.pte, "Unexpected PMD mapping?"))
>                 goto out_unlock;
>
> +       anon_exclusive = PageAnonExclusive(page);
>         if (pte_write(*pvmw.pte) || pte_dirty(*pvmw.pte) ||
>             (pte_protnone(*pvmw.pte) && pte_savedwrite(*pvmw.pte)) ||
> -                                               mm_tlb_flush_pending(mm)) {
> +           anon_exclusive || mm_tlb_flush_pending(mm)) {
>                 pte_t entry;
>
>                 swapped = PageSwapCache(page);
> @@ -1088,6 +1091,12 @@ static int write_protect_page(struct vm_area_struct *vma, struct page *page,
>                         set_pte_at(mm, pvmw.address, pvmw.pte, entry);
>                         goto out_unlock;
>                 }
> +
> +               if (anon_exclusive && page_try_share_anon_rmap(page)) {
> +                       set_pte_at(mm, pvmw.address, pvmw.pte, entry);
> +                       goto out_unlock;
> +               }
> +
>                 if (pte_dirty(entry))
>                         set_page_dirty(page);
>
> @@ -1146,6 +1155,8 @@ static int replace_page(struct vm_area_struct *vma, struct page *page,
>                 pte_unmap_unlock(ptep, ptl);
>                 goto out_mn;
>         }
> +       VM_BUG_ON_PAGE(PageAnonExclusive(page), page);
> +       VM_BUG_ON_PAGE(PageAnon(kpage) && PageAnonExclusive(kpage), kpage);
>
>         /*
>          * No need to check ksm_use_zero_pages here: we can only have a
> diff --git a/mm/memory.c b/mm/memory.c
> index d01fab481134..222aaf277af4 100644
> --- a/mm/memory.c
> +++ b/mm/memory.c
> @@ -720,6 +720,8 @@ static void restore_exclusive_pte(struct vm_area_struct *vma,
>         else if (is_writable_device_exclusive_entry(entry))
>                 pte = maybe_mkwrite(pte_mkdirty(pte), vma);
>
> +       VM_BUG_ON(pte_write(pte) && !(PageAnon(page) && PageAnonExclusive(page)));
> +
>         /*
>          * No need to take a page reference as one was already
>          * created when the swap entry was made.
> @@ -799,11 +801,12 @@ copy_nonpresent_pte(struct mm_struct *dst_mm, struct mm_struct *src_mm,
>
>                 rss[mm_counter(page)]++;
>
> -               if (is_writable_migration_entry(entry) &&
> +               if (!is_readable_migration_entry(entry) &&
>                                 is_cow_mapping(vm_flags)) {
>                         /*
> -                        * COW mappings require pages in both
> -                        * parent and child to be set to read.
> +                        * COW mappings require pages in both parent and child
> +                        * to be set to read. A previously exclusive entry is
> +                        * now shared.
>                          */
>                         entry = make_readable_migration_entry(
>                                                         swp_offset(entry));
> @@ -954,6 +957,7 @@ copy_present_pte(struct vm_area_struct *dst_vma, struct vm_area_struct *src_vma,
>                 ptep_set_wrprotect(src_mm, addr, src_pte);
>                 pte = pte_wrprotect(pte);
>         }
> +       VM_BUG_ON(page && PageAnon(page) && PageAnonExclusive(page));
>
>         /*
>          * If it's a shared mapping, mark it clean in
> @@ -2943,6 +2947,9 @@ static inline void wp_page_reuse(struct vm_fault *vmf)
>         struct vm_area_struct *vma = vmf->vma;
>         struct page *page = vmf->page;
>         pte_t entry;
> +
> +       VM_BUG_ON(PageAnon(page) && !PageAnonExclusive(page));
> +
>         /*
>          * Clear the pages cpupid information as the existing
>          * information potentially belongs to a now completely
> @@ -3277,6 +3284,13 @@ static vm_fault_t do_wp_page(struct vm_fault *vmf)
>         if (PageAnon(vmf->page)) {
>                 struct page *page = vmf->page;
>
> +               /*
> +                * If the page is exclusive to this process we must reuse the
> +                * page without further checks.
> +                */
> +               if (PageAnonExclusive(page))
> +                       goto reuse;
> +
>                 /*
>                  * We have to verify under page lock: these early checks are
>                  * just an optimization to avoid locking the page and freeing
> @@ -3309,6 +3323,7 @@ static vm_fault_t do_wp_page(struct vm_fault *vmf)
>                  */
>                 page_move_anon_rmap(page, vma);
>                 unlock_page(page);
> +reuse:
>                 wp_page_reuse(vmf);
>                 return VM_FAULT_WRITE;
>         } else if (unlikely((vma->vm_flags & (VM_WRITE|VM_SHARED)) ==
> @@ -3700,11 +3715,12 @@ vm_fault_t do_swap_page(struct vm_fault *vmf)
>          * that are certainly not shared because we just allocated them without
>          * exposing them to the swapcache.
>          */
> -       if ((vmf->flags & FAULT_FLAG_WRITE) && !PageKsm(page) &&
> -           (page != swapcache || page_count(page) == 1)) {
> -               pte = maybe_mkwrite(pte_mkdirty(pte), vma);
> -               vmf->flags &= ~FAULT_FLAG_WRITE;
> -               ret |= VM_FAULT_WRITE;
> +       if (!PageKsm(page) && (page != swapcache || page_count(page) == 1)) {
> +               if (vmf->flags & FAULT_FLAG_WRITE) {
> +                       pte = maybe_mkwrite(pte_mkdirty(pte), vma);
> +                       vmf->flags &= ~FAULT_FLAG_WRITE;
> +                       ret |= VM_FAULT_WRITE;
> +               }
>                 rmap_flags |= RMAP_EXCLUSIVE;
>         }
>         flush_icache_page(vma, page);
> @@ -3724,6 +3740,7 @@ vm_fault_t do_swap_page(struct vm_fault *vmf)
>                 page_add_anon_rmap(page, vma, vmf->address, rmap_flags);
>         }
>
> +       VM_BUG_ON(!PageAnon(page) || (pte_write(pte) && !PageAnonExclusive(page)));
>         set_pte_at(vma->vm_mm, vmf->address, vmf->pte, pte);
>         arch_do_swap_page(vma->vm_mm, vma, vmf->address, pte, vmf->orig_pte);
>
> diff --git a/mm/migrate.c b/mm/migrate.c
> index fd9eba33b34a..7f440d2103ce 100644
> --- a/mm/migrate.c
> +++ b/mm/migrate.c
> @@ -188,6 +188,8 @@ static bool remove_migration_pte(struct page *page, struct vm_area_struct *vma,
>
>         VM_BUG_ON_PAGE(PageTail(page), page);
>         while (page_vma_mapped_walk(&pvmw)) {
> +               rmap_t rmap_flags = RMAP_NONE;
> +
>                 if (PageKsm(page))
>                         new = page;
>                 else
> @@ -217,6 +219,9 @@ static bool remove_migration_pte(struct page *page, struct vm_area_struct *vma,
>                 else if (pte_swp_uffd_wp(*pvmw.pte))
>                         pte = pte_mkuffd_wp(pte);
>
> +               if (PageAnon(new) && !is_readable_migration_entry(entry))
> +                       rmap_flags |= RMAP_EXCLUSIVE;
> +
>                 if (unlikely(is_device_private_page(new))) {
>                         if (pte_write(pte))
>                                 entry = make_writable_device_private_entry(
> @@ -239,7 +244,7 @@ static bool remove_migration_pte(struct page *page, struct vm_area_struct *vma,
>                         pte = arch_make_huge_pte(pte, shift, vma->vm_flags);
>                         if (PageAnon(new))
>                                 hugepage_add_anon_rmap(new, vma, pvmw.address,
> -                                                      RMAP_NONE);
> +                                                      rmap_flags);
>                         else
>                                 page_dup_file_rmap(new, true);
>                         set_huge_pte_at(vma->vm_mm, pvmw.address, pvmw.pte, pte);
> @@ -248,7 +253,7 @@ static bool remove_migration_pte(struct page *page, struct vm_area_struct *vma,
>                 {
>                         if (PageAnon(new))
>                                 page_add_anon_rmap(new, vma, pvmw.address,
> -                                                  RMAP_NONE);
> +                                                  rmap_flags);
>                         else
>                                 page_add_file_rmap(new, false);
>                         set_pte_at(vma->vm_mm, pvmw.address, pvmw.pte, pte);
> @@ -379,6 +384,10 @@ int folio_migrate_mapping(struct address_space *mapping,
>                 /* No turning back from here */
>                 newfolio->index = folio->index;
>                 newfolio->mapping = folio->mapping;
> +               /*
> +                * Note: PG_anon_exclusive is always migrated via migration
> +                * entries.
> +                */
>                 if (folio_test_swapbacked(folio))
>                         __folio_set_swapbacked(newfolio);
>
> @@ -2302,15 +2311,34 @@ static int migrate_vma_collect_pmd(pmd_t *pmdp,
>                  * set up a special migration page table entry now.
>                  */
>                 if (trylock_page(page)) {
> +                       bool anon_exclusive;
>                         pte_t swp_pte;
>
> +                       anon_exclusive = PageAnon(page) && PageAnonExclusive(page);
> +                       if (anon_exclusive) {
> +                               flush_cache_page(vma, addr, pte_pfn(*ptep));
> +                               ptep_clear_flush(vma, addr, ptep);
> +
> +                               if (page_try_share_anon_rmap(page)) {
> +                                       set_pte_at(mm, addr, ptep, pte);
> +                                       unlock_page(page);
> +                                       put_page(page);
> +                                       mpfn = 0;
> +                                       goto next;
> +                               }
> +                       } else {
> +                               ptep_get_and_clear(mm, addr, ptep);
> +                       }
> +
>                         migrate->cpages++;
> -                       ptep_get_and_clear(mm, addr, ptep);
>
>                         /* Setup special migration page table entry */
>                         if (mpfn & MIGRATE_PFN_WRITE)
>                                 entry = make_writable_migration_entry(
>                                                         page_to_pfn(page));
> +                       else if (anon_exclusive)
> +                               entry = make_readable_exclusive_migration_entry(
> +                                                       page_to_pfn(page));
>                         else
>                                 entry = make_readable_migration_entry(
>                                                         page_to_pfn(page));
> diff --git a/mm/mprotect.c b/mm/mprotect.c
> index 2887644fd150..9441675e993c 100644
> --- a/mm/mprotect.c
> +++ b/mm/mprotect.c
> @@ -141,6 +141,7 @@ static unsigned long change_pte_range(struct vm_area_struct *vma, pmd_t *pmd,
>                         pages++;
>                 } else if (is_swap_pte(oldpte)) {
>                         swp_entry_t entry = pte_to_swp_entry(oldpte);
> +                       struct page *page = pfn_swap_entry_to_page(entry);
>                         pte_t newpte;
>
>                         if (is_writable_migration_entry(entry)) {
> @@ -148,8 +149,11 @@ static unsigned long change_pte_range(struct vm_area_struct *vma, pmd_t *pmd,
>                                  * A protection check is difficult so
>                                  * just be safe and disable write
>                                  */
> -                               entry = make_readable_migration_entry(
> -                                                       swp_offset(entry));
> +                               if (PageAnon(page))
> +                                       entry = make_readable_exclusive_migration_entry(
> +                                                            swp_offset(entry));
> +                               else
> +                                       entry = make_readable_migration_entry(swp_offset(entry));
>                                 newpte = swp_entry_to_pte(entry);
>                                 if (pte_swp_soft_dirty(oldpte))
>                                         newpte = pte_swp_mksoft_dirty(newpte);
> diff --git a/mm/rmap.c b/mm/rmap.c
> index ebe7140c4493..9d2a7e11e8cc 100644
> --- a/mm/rmap.c
> +++ b/mm/rmap.c
> @@ -1048,6 +1048,7 @@ EXPORT_SYMBOL_GPL(folio_mkclean);
>  void page_move_anon_rmap(struct page *page, struct vm_area_struct *vma)
>  {
>         struct anon_vma *anon_vma = vma->anon_vma;
> +       struct page *subpage = page;
>
>         page = compound_head(page);
>
> @@ -1061,6 +1062,7 @@ void page_move_anon_rmap(struct page *page, struct vm_area_struct *vma)
>          * PageAnon()) will not see one without the other.
>          */
>         WRITE_ONCE(page->mapping, (struct address_space *) anon_vma);
> +       SetPageAnonExclusive(subpage);
>  }
>
>  /**
> @@ -1078,7 +1080,7 @@ static void __page_set_anon_rmap(struct page *page,
>         BUG_ON(!anon_vma);
>
>         if (PageAnon(page))
> -               return;
> +               goto out;
>
>         /*
>          * If the page isn't exclusively mapped into this vma,
> @@ -1097,6 +1099,9 @@ static void __page_set_anon_rmap(struct page *page,
>         anon_vma = (void *) anon_vma + PAGE_MAPPING_ANON;
>         WRITE_ONCE(page->mapping, (struct address_space *) anon_vma);
>         page->index = linear_page_index(vma, address);
> +out:
> +       if (exclusive)
> +               SetPageAnonExclusive(page);
>  }
>
>  /**
> @@ -1156,6 +1161,8 @@ void page_add_anon_rmap(struct page *page,
>         } else {
>                 first = atomic_inc_and_test(&page->_mapcount);
>         }
> +       VM_BUG_ON_PAGE(!first && (flags & RMAP_EXCLUSIVE), page);
> +       VM_BUG_ON_PAGE(!first && PageAnonExclusive(page), page);
>
>         if (first) {
>                 int nr = compound ? thp_nr_pages(page) : 1;
> @@ -1422,7 +1429,7 @@ static bool try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
>         };
>         pte_t pteval;
>         struct page *subpage;
> -       bool ret = true;
> +       bool anon_exclusive, ret = true;
>         struct mmu_notifier_range range;
>         enum ttu_flags flags = (enum ttu_flags)(long)arg;
>
> @@ -1485,6 +1492,7 @@ static bool try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
>
>                 subpage = page - page_to_pfn(page) + pte_pfn(*pvmw.pte);
>                 address = pvmw.address;
> +               anon_exclusive = PageAnon(page) && PageAnonExclusive(subpage);
>
>                 if (PageHuge(page) && !PageAnon(page)) {
>                         /*
> @@ -1520,9 +1528,12 @@ static bool try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
>                         }
>                 }
>
> -               /* Nuke the page table entry. */
> +               /*
> +                * Nuke the page table entry. When having to clear
> +                * PageAnonExclusive(), we always have to flush.
> +                */
>                 flush_cache_page(vma, address, pte_pfn(*pvmw.pte));
> -               if (should_defer_flush(mm, flags)) {
> +               if (should_defer_flush(mm, flags) && !anon_exclusive) {
>                         /*
>                          * We clear the PTE but do not flush so potentially
>                          * a remote CPU could still be writing to the page.
> @@ -1623,6 +1634,24 @@ static bool try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
>                                 page_vma_mapped_walk_done(&pvmw);
>                                 break;
>                         }
> +                       if (anon_exclusive &&
> +                           page_try_share_anon_rmap(subpage)) {
> +                               swap_free(entry);
> +                               set_pte_at(mm, address, pvmw.pte, pteval);
> +                               ret = false;
> +                               page_vma_mapped_walk_done(&pvmw);
> +                               break;
> +                       }
> +                       /*
> +                        * Note: We *don't* remember yet if the page was mapped
> +                        * exclusively in the swap entry, so swapin code has
> +                        * to re-determine that manually and might detect the
> +                        * page as possibly shared, for example, if there are
> +                        * other references on the page or if the page is under
> +                        * writeback. We made sure that there are no GUP pins
> +                        * on the page that would rely on it, so for GUP pins
> +                        * this is fine.
> +                        */
>                         if (list_empty(&mm->mmlist)) {
>                                 spin_lock(&mmlist_lock);
>                                 if (list_empty(&mm->mmlist))
> @@ -1723,7 +1752,7 @@ static bool try_to_migrate_one(struct page *page, struct vm_area_struct *vma,
>         };
>         pte_t pteval;
>         struct page *subpage;
> -       bool ret = true;
> +       bool anon_exclusive, ret = true;
>         struct mmu_notifier_range range;
>         enum ttu_flags flags = (enum ttu_flags)(long)arg;
>
> @@ -1782,6 +1811,7 @@ static bool try_to_migrate_one(struct page *page, struct vm_area_struct *vma,
>
>                 subpage = page - page_to_pfn(page) + pte_pfn(*pvmw.pte);
>                 address = pvmw.address;
> +               anon_exclusive = PageAnon(page) && PageAnonExclusive(subpage);
>
>                 if (PageHuge(page) && !PageAnon(page)) {
>                         /*
> @@ -1833,6 +1863,9 @@ static bool try_to_migrate_one(struct page *page, struct vm_area_struct *vma,
>                         swp_entry_t entry;
>                         pte_t swp_pte;
>
> +                       if (anon_exclusive)
> +                               BUG_ON(page_try_share_anon_rmap(subpage));
> +
>                         /*
>                          * Store the pfn of the page in a special migration
>                          * pte. do_swap_page() will wait until the migration
> @@ -1841,6 +1874,8 @@ static bool try_to_migrate_one(struct page *page, struct vm_area_struct *vma,
>                         entry = pte_to_swp_entry(pteval);
>                         if (is_writable_device_private_entry(entry))
>                                 entry = make_writable_migration_entry(pfn);
> +                       else if (anon_exclusive)
> +                               entry = make_readable_exclusive_migration_entry(pfn);
>                         else
>                                 entry = make_readable_migration_entry(pfn);
>                         swp_pte = swp_entry_to_pte(entry);
> @@ -1903,6 +1938,15 @@ static bool try_to_migrate_one(struct page *page, struct vm_area_struct *vma,
>                                 page_vma_mapped_walk_done(&pvmw);
>                                 break;
>                         }
> +                       VM_BUG_ON_PAGE(pte_write(pteval) && PageAnon(page) &&
> +                                      !anon_exclusive, page);
> +                       if (anon_exclusive &&
> +                           page_try_share_anon_rmap(subpage)) {
> +                               set_pte_at(mm, address, pvmw.pte, pteval);
> +                               ret = false;
> +                               page_vma_mapped_walk_done(&pvmw);
> +                               break;
> +                       }
>
>                         /*
>                          * Store the pfn of the page in a special migration
> @@ -1912,6 +1956,9 @@ static bool try_to_migrate_one(struct page *page, struct vm_area_struct *vma,
>                         if (pte_write(pteval))
>                                 entry = make_writable_migration_entry(
>                                                         page_to_pfn(subpage));
> +                       else if (anon_exclusive)
> +                               entry = make_readable_exclusive_migration_entry(
> +                                                       page_to_pfn(subpage));
>                         else
>                                 entry = make_readable_migration_entry(
>                                                         page_to_pfn(subpage));
> @@ -2425,6 +2472,8 @@ void hugepage_add_anon_rmap(struct page *page, struct vm_area_struct *vma,
>         BUG_ON(!anon_vma);
>         /* address might be in next vma when migration races vma_adjust */
>         first = atomic_inc_and_test(compound_mapcount_ptr(page));
> +       VM_BUG_ON_PAGE(!first && (flags & RMAP_EXCLUSIVE), page);
> +       VM_BUG_ON_PAGE(!first && PageAnonExclusive(page), page);
>         if (first)
>                 __page_set_anon_rmap(page, vma, address,
>                                      flags & RMAP_EXCLUSIVE);
> --
> 2.35.1
>

Re: [PATCH v2 04/15] mm/rmap: split page_dup_rmap() into page_dup_file_rmap() and page_try_dup_anon_rmap()

[David Hildenbrand]

On 16.03.22 21:02, Yang Shi wrote:
> On Tue, Mar 15, 2022 at 3:50 AM David Hildenbrand <david@redhat.com> wrote:
>>
>> ... and move the special check for pinned pages into
>> page_try_dup_anon_rmap() to prepare for tracking exclusive anonymous
>> pages via a new pageflag, clearing it only after making sure that there
>> are no GUP pins on the anonymous page.
>>
>> We really only care about pins on anonymous pages, because they are
>> prone to getting replaced in the COW handler once mapped R/O. For !anon
>> pages in cow-mappings (!VM_SHARED && VM_MAYWRITE) we shouldn't really
>> care about that, at least not that I could come up with an example.
>>
>> Let's drop the is_cow_mapping() check from page_needs_cow_for_dma(), as we
>> know we're dealing with anonymous pages. Also, drop the handling of
>> pinned pages from copy_huge_pud() and add a comment if ever supporting
>> anonymous pages on the PUD level.
>>
>> This is a preparation for tracking exclusivity of anonymous pages in
>> the rmap code, and disallowing marking a page shared (-> failing to
>> duplicate) if there are GUP pins on a page.
>>
>> RFC notes: if I'm missing something important for !anon pages, we could
>>            similarly handle it via page_try_dup_file_rmap().
>>
>> Signed-off-by: David Hildenbrand <david@redhat.com>
>> ---
>>  include/linux/mm.h   |  5 +----
>>  include/linux/rmap.h | 48 +++++++++++++++++++++++++++++++++++++++++++-
>>  mm/huge_memory.c     | 27 ++++++++-----------------
>>  mm/hugetlb.c         | 16 ++++++++-------
>>  mm/memory.c          | 17 +++++++++++-----
>>  mm/migrate.c         |  2 +-
>>  6 files changed, 78 insertions(+), 37 deletions(-)
>>
>> diff --git a/include/linux/mm.h b/include/linux/mm.h
>> index 391b950e919d..63ee06001189 100644
>> --- a/include/linux/mm.h
>> +++ b/include/linux/mm.h
>> @@ -1322,16 +1322,13 @@ static inline bool is_cow_mapping(vm_flags_t flags)
>>
>>  /*
>>   * This should most likely only be called during fork() to see whether we
>> - * should break the cow immediately for a page on the src mm.
>> + * should break the cow immediately for an anon page on the src mm.
>>   *
>>   * The caller has to hold the PT lock and the vma->vm_mm->->write_protect_seq.
>>   */
>>  static inline bool page_needs_cow_for_dma(struct vm_area_struct *vma,
>>                                           struct page *page)
>>  {
>> -       if (!is_cow_mapping(vma->vm_flags))
>> -               return false;
>> -
>>         VM_BUG_ON(!(raw_read_seqcount(&vma->vm_mm->write_protect_seq) & 1));
>>
>>         if (!test_bit(MMF_HAS_PINNED, &vma->vm_mm->flags))
>> diff --git a/include/linux/rmap.h b/include/linux/rmap.h
>> index e704b1a4c06c..92c3585b8c6a 100644
>> --- a/include/linux/rmap.h
>> +++ b/include/linux/rmap.h
>> @@ -180,11 +180,57 @@ void hugepage_add_anon_rmap(struct page *, struct vm_area_struct *,
>>  void hugepage_add_new_anon_rmap(struct page *, struct vm_area_struct *,
>>                                 unsigned long);
>>
>> -static inline void page_dup_rmap(struct page *page, bool compound)
>> +static inline void __page_dup_rmap(struct page *page, bool compound)
>>  {
>>         atomic_inc(compound ? compound_mapcount_ptr(page) : &page->_mapcount);
>>  }
>>
>> +static inline void page_dup_file_rmap(struct page *page, bool compound)
>> +{
>> +       __page_dup_rmap(page, compound);
>> +}
>> +
>> +/**
>> + * page_try_dup_anon_rmap - try duplicating a mapping of an already mapped
>> + *                         anonymous page
>> + * @page: the page to duplicate the mapping for
>> + * @compound: the page is mapped as compound or as a small page
>> + * @vma: the source vma
>> + *
>> + * The caller needs to hold the PT lock and the vma->vma_mm->write_protect_seq.
>> + *
>> + * Duplicating the mapping can only fail if the page may be pinned; device
>> + * private pages cannot get pinned and consequently this function cannot fail.
>> + *
>> + * If duplicating the mapping succeeds, the page has to be mapped R/O into
>> + * the parent and the child. It must *not* get mapped writable after this call.
>> + *
>> + * Returns 0 if duplicating the mapping succeeded. Returns -EBUSY otherwise.
>> + */
>> +static inline int page_try_dup_anon_rmap(struct page *page, bool compound,
>> +                                        struct vm_area_struct *vma)
>> +{
>> +       VM_BUG_ON_PAGE(!PageAnon(page), page);
>> +
>> +       /*
>> +        * If this page may have been pinned by the parent process,
>> +        * don't allow to duplicate the mapping but instead require to e.g.,
>> +        * copy the page immediately for the child so that we'll always
>> +        * guarantee the pinned page won't be randomly replaced in the
>> +        * future on write faults.
>> +        */
>> +       if (likely(!is_device_private_page(page) &&
>> +           unlikely(page_needs_cow_for_dma(vma, page))))
>> +               return -EBUSY;
>> +
>> +       /*
>> +        * It's okay to share the anon page between both processes, mapping
>> +        * the page R/O into both processes.
>> +        */
>> +       __page_dup_rmap(page, compound);
>> +       return 0;
>> +}
>> +
>>  /*
>>   * Called from mm/vmscan.c to handle paging out
>>   */
>> diff --git a/mm/huge_memory.c b/mm/huge_memory.c
>> index cda88d8ac1bd..c126d728b8de 100644
>> --- a/mm/huge_memory.c
>> +++ b/mm/huge_memory.c
>> @@ -1097,23 +1097,16 @@ int copy_huge_pmd(struct mm_struct *dst_mm, struct mm_struct *src_mm,
>>         src_page = pmd_page(pmd);
>>         VM_BUG_ON_PAGE(!PageHead(src_page), src_page);
>>
>> -       /*
>> -        * If this page is a potentially pinned page, split and retry the fault
>> -        * with smaller page size.  Normally this should not happen because the
>> -        * userspace should use MADV_DONTFORK upon pinned regions.  This is a
>> -        * best effort that the pinned pages won't be replaced by another
>> -        * random page during the coming copy-on-write.
>> -        */
>> -       if (unlikely(page_needs_cow_for_dma(src_vma, src_page))) {
>> +       get_page(src_page);
>> +       if (unlikely(page_try_dup_anon_rmap(src_page, true, src_vma))) {
>> +               /* Page maybe pinned: split and retry the fault on PTEs. */
>> +               put_page(src_page);
> 
> Do we have to do the get_page()/put_page() sequence? It seems we don't
> have to get the page before calling page_try_dup_anon_rmap(), right?
> We just need to bump page refcount when dupping rmap successfully. So
> we could do:
> 
> if (unlikely(page_try_dup_anon_rmap(src_page, true, src_vma))) {
>     /* do something */
> }
> 
> get_page(src_page)

I refrained from doing that in this series because I wasn't able to
convince myself that it is completely sane.

Increasing the refcount before the mapcount here results in an
interesting property (when unmap is done similarly, in reverse order):
reading a snapshot of page_count()+mapcount() at a random point in
time guarantees that page_count() >= mapcount.

Now, the issue I see with changing that is the following: We seem
to have some code that tries detecting additional references on a
mapped page. While such checks can deal with false positives ("there
is an additional reference"), false negatives ("these is no
additional reference") could be bad.

One example I stumbled over is KSM code:


		/*
		 * Check that no O_DIRECT or similar I/O is in progress on the
		 * page
		 */
		if (page_mapcount(page) + 1 + swapped != page_count(page)) {
			set_pte_at(mm, pvmw.address, pvmw.pte, entry);
			goto out_unlock;
		}


Imagine there is an additional reference but another process sharing the
page did the mapcount++ but not the refcount++ yet. You'd get a false negative.


Now, I'm not sure if there is anything else protecting us from this,
however, it rather made me be very careful about changing the order
of things here. So in the context of this patch, I won't be messing with
the order.

Thanks!

-- 
Thanks,

David / dhildenb

Re: [PATCH v2 11/15] mm: remember exclusively mapped anonymous pages with PG_anon_exclusive

[David Hildenbrand]

On 16.03.22 22:23, Yang Shi wrote:
> On Tue, Mar 15, 2022 at 3:52 AM David Hildenbrand <david@redhat.com> wrote:
>>
>> Let's mark exclusively mapped anonymous pages with PG_anon_exclusive as
>> exclusive, and use that information to make GUP pins reliable and stay
>> consistent with the page mapped into the page table even if the
>> page table entry gets write-protected.
>>
>> With that information at hand, we can extend our COW logic to always
>> reuse anonymous pages that are exclusive. For anonymous pages that
>> might be shared, the existing logic applies.
>>
>> As already documented, PG_anon_exclusive is usually only expressive in
>> combination with a page table entry. Especially PTE vs. PMD-mapped
>> anonymous pages require more thought, some examples: due to mremap() we
>> can easily have a single compound page PTE-mapped into multiple page tables
>> exclusively in a single process -- multiple page table locks apply.
>> Further, due to MADV_WIPEONFORK we might not necessarily write-protect
>> all PTEs, and only some subpages might be pinned. Long story short: once
>> PTE-mapped, we have to track information about exclusivity per sub-page,
>> but until then, we can just track it for the compound page in the head
>> page and not having to update a whole bunch of subpages all of the time
>> for a simple PMD mapping of a THP.
>>
>> For simplicity, this commit mostly talks about "anonymous pages", while
>> it's for THP actually "the part of an anonymous folio referenced via
>> a page table entry".
>>
>> To not spill PG_anon_exclusive code all over the mm code-base, we let
>> the anon rmap code to handle all PG_anon_exclusive logic it can easily
>> handle.
>>
>> If a writable, present page table entry points at an anonymous (sub)page,
>> that (sub)page must be PG_anon_exclusive. If GUP wants to take a reliably
>> pin (FOLL_PIN) on an anonymous page references via a present
>> page table entry, it must only pin if PG_anon_exclusive is set for the
>> mapped (sub)page.
>>
>> This commit doesn't adjust GUP, so this is only implicitly handled for
>> FOLL_WRITE, follow-up commits will teach GUP to also respect it for
>> FOLL_PIN without !FOLL_WRITE, to make all GUP pins of anonymous pages
>> fully reliable.
>>
>> Whenever an anonymous page is to be shared (fork(), KSM), or when
>> temporarily unmapping an anonymous page (swap, migration), the relevant
>> PG_anon_exclusive bit has to be cleared to mark the anonymous page
>> possibly shared. Clearing will fail if there are GUP pins on the page:
>> * For fork(), this means having to copy the page and not being able to
>>   share it. fork() protects against concurrent GUP using the PT lock and
>>   the src_mm->write_protect_seq.
>> * For KSM, this means sharing will fail. For swap this means, unmapping
>>   will fail, For migration this means, migration will fail early. All
>>   three cases protect against concurrent GUP using the PT lock and a
>>   proper clear/invalidate+flush of the relevant page table entry.
>>
>> This fixes memory corruptions reported for FOLL_PIN | FOLL_WRITE, when a
>> pinned page gets mapped R/O and the successive write fault ends up
>> replacing the page instead of reusing it. It improves the situation for
>> O_DIRECT/vmsplice/... that still use FOLL_GET instead of FOLL_PIN,
>> if fork() is *not* involved, however swapout and fork() are still
>> problematic. Properly using FOLL_PIN instead of FOLL_GET for these
>> GUP users will fix the issue for them.
>>
>> I. Details about basic handling
>>
>> I.1. Fresh anonymous pages
>>
>> page_add_new_anon_rmap() and hugepage_add_new_anon_rmap() will mark the
>> given page exclusive via __page_set_anon_rmap(exclusive=1). As that is
>> the mechanism fresh anonymous pages come into life (besides migration
>> code where we copy the page->mapping), all fresh anonymous pages will
>> start out as exclusive.
>>
>> I.2. COW reuse handling of anonymous pages
>>
>> When a COW handler stumbles over a (sub)page that's marked exclusive, it
>> simply reuses it. Otherwise, the handler tries harder under page lock to
>> detect if the (sub)page is exclusive and can be reused. If exclusive,
>> page_move_anon_rmap() will mark the given (sub)page exclusive.
>>
>> Note that hugetlb code does not yet check for PageAnonExclusive(), as it
>> still uses the old COW logic that is prone to the COW security issue
>> because hugetlb code cannot really tolerate unnecessary/wrong COW as
>> huge pages are a scarce resource.
>>
>> I.3. Migration handling
>>
>> try_to_migrate() has to try marking an exclusive anonymous page shared
>> via page_try_share_anon_rmap(). If it fails because there are GUP pins
>> on the page, unmap fails. migrate_vma_collect_pmd() and
>> __split_huge_pmd_locked() are handled similarly.
>>
>> Writable migration entries implicitly point at shared anonymous pages.
>> For readable migration entries that information is stored via a new
>> "readable-exclusive" migration entry, specific to anonymous pages.
>>
>> When restoring a migration entry in remove_migration_pte(), information
>> about exlusivity is detected via the migration entry type, and
>> RMAP_EXCLUSIVE is set accordingly for
>> page_add_anon_rmap()/hugepage_add_anon_rmap() to restore that
>> information.
>>
>> I.4. Swapout handling
>>
>> try_to_unmap() has to try marking the mapped page possibly shared via
>> page_try_share_anon_rmap(). If it fails because there are GUP pins on the
>> page, unmap fails. For now, information about exclusivity is lost. In the
>> future, we might want to remember that information in the swap entry in
>> some cases, however, it requires more thought, care, and a way to store
>> that information in swap entries.
>>
>> I.5. Swapin handling
>>
>> do_swap_page() will never stumble over exclusive anonymous pages in the
>> swap cache, as try_to_migrate() prohibits that. do_swap_page() always has
>> to detect manually if an anonymous page is exclusive and has to set
>> RMAP_EXCLUSIVE for page_add_anon_rmap() accordingly.
>>
>> I.6. THP handling
>>
>> __split_huge_pmd_locked() has to move the information about exclusivity
>> from the PMD to the PTEs.
>>
>> a) In case we have a readable-exclusive PMD migration entry, simply insert
>> readable-exclusive PTE migration entries.
>>
>> b) In case we have a present PMD entry and we don't want to freeze
>> ("convert to migration entries"), simply forward PG_anon_exclusive to
>> all sub-pages, no need to temporarily clear the bit.
>>
>> c) In case we have a present PMD entry and want to freeze, handle it
>> similar to try_to_migrate(): try marking the page shared first. In case
>> we fail, we ignore the "freeze" instruction and simply split ordinarily.
>> try_to_migrate() will properly fail because the THP is still mapped via
>> PTEs.

Hi,

thanks for the review!

> 
> How come will try_to_migrate() fail? The afterward pvmw will find
> those PTEs then convert them to migration entries anyway IIUC.
> 

It will run into that code:

>> @@ -1903,6 +1938,15 @@ static bool try_to_migrate_one(struct page *page, struct vm_area_struct *vma,
>>                                 page_vma_mapped_walk_done(&pvmw);
>>                                 break;
>>                         }
>> +                       VM_BUG_ON_PAGE(pte_write(pteval) && PageAnon(page) &&
>> +                                      !anon_exclusive, page);
>> +                       if (anon_exclusive &&
>> +                           page_try_share_anon_rmap(subpage)) {
>> +                               set_pte_at(mm, address, pvmw.pte, pteval);
>> +                               ret = false;
>> +                               page_vma_mapped_walk_done(&pvmw);
>> +                               break;
>> +                       }

and similarly fail the page_try_share_anon_rmap(), at which point
try_to_migrate() stops and the caller will still observe a
"page_mapped() == true".

-- 
Thanks,

David / dhildenb

Re: [PATCH v2 11/15] mm: remember exclusively mapped anonymous pages with PG_anon_exclusive

[Yang Shi]

On Thu, Mar 17, 2022 at 2:06 AM David Hildenbrand <david@redhat.com> wrote:
>
> On 16.03.22 22:23, Yang Shi wrote:
> > On Tue, Mar 15, 2022 at 3:52 AM David Hildenbrand <david@redhat.com> wrote:
> >>
> >> Let's mark exclusively mapped anonymous pages with PG_anon_exclusive as
> >> exclusive, and use that information to make GUP pins reliable and stay
> >> consistent with the page mapped into the page table even if the
> >> page table entry gets write-protected.
> >>
> >> With that information at hand, we can extend our COW logic to always
> >> reuse anonymous pages that are exclusive. For anonymous pages that
> >> might be shared, the existing logic applies.
> >>
> >> As already documented, PG_anon_exclusive is usually only expressive in
> >> combination with a page table entry. Especially PTE vs. PMD-mapped
> >> anonymous pages require more thought, some examples: due to mremap() we
> >> can easily have a single compound page PTE-mapped into multiple page tables
> >> exclusively in a single process -- multiple page table locks apply.
> >> Further, due to MADV_WIPEONFORK we might not necessarily write-protect
> >> all PTEs, and only some subpages might be pinned. Long story short: once
> >> PTE-mapped, we have to track information about exclusivity per sub-page,
> >> but until then, we can just track it for the compound page in the head
> >> page and not having to update a whole bunch of subpages all of the time
> >> for a simple PMD mapping of a THP.
> >>
> >> For simplicity, this commit mostly talks about "anonymous pages", while
> >> it's for THP actually "the part of an anonymous folio referenced via
> >> a page table entry".
> >>
> >> To not spill PG_anon_exclusive code all over the mm code-base, we let
> >> the anon rmap code to handle all PG_anon_exclusive logic it can easily
> >> handle.
> >>
> >> If a writable, present page table entry points at an anonymous (sub)page,
> >> that (sub)page must be PG_anon_exclusive. If GUP wants to take a reliably
> >> pin (FOLL_PIN) on an anonymous page references via a present
> >> page table entry, it must only pin if PG_anon_exclusive is set for the
> >> mapped (sub)page.
> >>
> >> This commit doesn't adjust GUP, so this is only implicitly handled for
> >> FOLL_WRITE, follow-up commits will teach GUP to also respect it for
> >> FOLL_PIN without !FOLL_WRITE, to make all GUP pins of anonymous pages
> >> fully reliable.
> >>
> >> Whenever an anonymous page is to be shared (fork(), KSM), or when
> >> temporarily unmapping an anonymous page (swap, migration), the relevant
> >> PG_anon_exclusive bit has to be cleared to mark the anonymous page
> >> possibly shared. Clearing will fail if there are GUP pins on the page:
> >> * For fork(), this means having to copy the page and not being able to
> >>   share it. fork() protects against concurrent GUP using the PT lock and
> >>   the src_mm->write_protect_seq.
> >> * For KSM, this means sharing will fail. For swap this means, unmapping
> >>   will fail, For migration this means, migration will fail early. All
> >>   three cases protect against concurrent GUP using the PT lock and a
> >>   proper clear/invalidate+flush of the relevant page table entry.
> >>
> >> This fixes memory corruptions reported for FOLL_PIN | FOLL_WRITE, when a
> >> pinned page gets mapped R/O and the successive write fault ends up
> >> replacing the page instead of reusing it. It improves the situation for
> >> O_DIRECT/vmsplice/... that still use FOLL_GET instead of FOLL_PIN,
> >> if fork() is *not* involved, however swapout and fork() are still
> >> problematic. Properly using FOLL_PIN instead of FOLL_GET for these
> >> GUP users will fix the issue for them.
> >>
> >> I. Details about basic handling
> >>
> >> I.1. Fresh anonymous pages
> >>
> >> page_add_new_anon_rmap() and hugepage_add_new_anon_rmap() will mark the
> >> given page exclusive via __page_set_anon_rmap(exclusive=1). As that is
> >> the mechanism fresh anonymous pages come into life (besides migration
> >> code where we copy the page->mapping), all fresh anonymous pages will
> >> start out as exclusive.
> >>
> >> I.2. COW reuse handling of anonymous pages
> >>
> >> When a COW handler stumbles over a (sub)page that's marked exclusive, it
> >> simply reuses it. Otherwise, the handler tries harder under page lock to
> >> detect if the (sub)page is exclusive and can be reused. If exclusive,
> >> page_move_anon_rmap() will mark the given (sub)page exclusive.
> >>
> >> Note that hugetlb code does not yet check for PageAnonExclusive(), as it
> >> still uses the old COW logic that is prone to the COW security issue
> >> because hugetlb code cannot really tolerate unnecessary/wrong COW as
> >> huge pages are a scarce resource.
> >>
> >> I.3. Migration handling
> >>
> >> try_to_migrate() has to try marking an exclusive anonymous page shared
> >> via page_try_share_anon_rmap(). If it fails because there are GUP pins
> >> on the page, unmap fails. migrate_vma_collect_pmd() and
> >> __split_huge_pmd_locked() are handled similarly.
> >>
> >> Writable migration entries implicitly point at shared anonymous pages.
> >> For readable migration entries that information is stored via a new
> >> "readable-exclusive" migration entry, specific to anonymous pages.
> >>
> >> When restoring a migration entry in remove_migration_pte(), information
> >> about exlusivity is detected via the migration entry type, and
> >> RMAP_EXCLUSIVE is set accordingly for
> >> page_add_anon_rmap()/hugepage_add_anon_rmap() to restore that
> >> information.
> >>
> >> I.4. Swapout handling
> >>
> >> try_to_unmap() has to try marking the mapped page possibly shared via
> >> page_try_share_anon_rmap(). If it fails because there are GUP pins on the
> >> page, unmap fails. For now, information about exclusivity is lost. In the
> >> future, we might want to remember that information in the swap entry in
> >> some cases, however, it requires more thought, care, and a way to store
> >> that information in swap entries.
> >>
> >> I.5. Swapin handling
> >>
> >> do_swap_page() will never stumble over exclusive anonymous pages in the
> >> swap cache, as try_to_migrate() prohibits that. do_swap_page() always has
> >> to detect manually if an anonymous page is exclusive and has to set
> >> RMAP_EXCLUSIVE for page_add_anon_rmap() accordingly.
> >>
> >> I.6. THP handling
> >>
> >> __split_huge_pmd_locked() has to move the information about exclusivity
> >> from the PMD to the PTEs.
> >>
> >> a) In case we have a readable-exclusive PMD migration entry, simply insert
> >> readable-exclusive PTE migration entries.
> >>
> >> b) In case we have a present PMD entry and we don't want to freeze
> >> ("convert to migration entries"), simply forward PG_anon_exclusive to
> >> all sub-pages, no need to temporarily clear the bit.
> >>
> >> c) In case we have a present PMD entry and want to freeze, handle it
> >> similar to try_to_migrate(): try marking the page shared first. In case
> >> we fail, we ignore the "freeze" instruction and simply split ordinarily.
> >> try_to_migrate() will properly fail because the THP is still mapped via
> >> PTEs.
>
> Hi,
>
> thanks for the review!
>
> >
> > How come will try_to_migrate() fail? The afterward pvmw will find
> > those PTEs then convert them to migration entries anyway IIUC.
> >
>
> It will run into that code:
>
> >> @@ -1903,6 +1938,15 @@ static bool try_to_migrate_one(struct page *page, struct vm_area_struct *vma,
> >>                                 page_vma_mapped_walk_done(&pvmw);
> >>                                 break;
> >>                         }
> >> +                       VM_BUG_ON_PAGE(pte_write(pteval) && PageAnon(page) &&
> >> +                                      !anon_exclusive, page);
> >> +                       if (anon_exclusive &&
> >> +                           page_try_share_anon_rmap(subpage)) {
> >> +                               set_pte_at(mm, address, pvmw.pte, pteval);
> >> +                               ret = false;
> >> +                               page_vma_mapped_walk_done(&pvmw);
> >> +                               break;
> >> +                       }
>
> and similarly fail the page_try_share_anon_rmap(), at which point
> try_to_migrate() stops and the caller will still observe a
> "page_mapped() == true".

Thanks, I missed that. Yes, the page will still be mapped. This should
trigger the VM_WARN_ON_ONCE in unmap_page(), if this change will make
this happen more often, we may consider removing that warning even
though it is "once" since seeing a mapped page may become a normal
case (once DIO is switched to FOLL_PIN, it may be more often). Anyway
we don't have to remove it right now.

>
> --
> Thanks,
>
> David / dhildenb
>

Re: [PATCH v2 13/15] mm: support GUP-triggered unsharing of anonymous pages

[Jason Gunthorpe]

On Tue, Mar 15, 2022 at 11:47:39AM +0100, David Hildenbrand wrote:
> 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.

Given the way this series has developed you might want to call this
FAULT_FLAG_MAKE_ANON_EXCLUSIVE

Which strikes me as more directly connected to what it is trying to
do.

Jason

Re: [PATCH v2 15/15] mm/gup: sanity-check with CONFIG_DEBUG_VM that anonymous pages are exclusive when (un)pinning

[Jason Gunthorpe]

On Tue, Mar 15, 2022 at 11:47:41AM +0100, David Hildenbrand wrote:
> Let's verify when (un)pinning anonymous pages that we always deal with
> exclusive anonymous pages, which guarantees that we'll have a reliable
> PIN, meaning that we cannot end up with the GUP pin being inconsistent
> with he pages mapped into the page tables due to a COW triggered
> by a write fault.
> 
> When pinning pages, after conditionally triggering GUP unsharing of
> possibly shared anonymous pages, we should always only see exclusive
> anonymous pages. Note that anonymous pages that are mapped writable
> must be marked exclusive, otherwise we'd have a BUG.
> 
> When pinning during ordinary GUP, simply add a check after our
> conditional GUP-triggered unsharing checks. As we know exactly how the
> page is mapped, we know exactly in which page we have to check for
> PageAnonExclusive().
> 
> When pinning via GUP-fast we have to be careful, because we can race with
> fork(): verify only after we made sure via the seqcount that we didn't
> race with concurrent fork() that we didn't end up pinning a possibly
> shared anonymous page.
> 
> Similarly, when unpinning, verify that the pages are still marked as
> exclusive: otherwise something turned the pages possibly shared, which
> can result in random memory corruptions, which we really want to catch.
> 
> With only the pinned pages at hand and not the actual page table entries
> we have to be a bit careful: hugetlb pages are always mapped via a
> single logical page table entry referencing the head page and
> PG_anon_exclusive of the head page applies. Anon THP are a bit more
> complicated, because we might have obtained the page reference either via
> a PMD or a PTE -- depending on the mapping type we either have to check
> PageAnonExclusive of the head page (PMD-mapped THP) or the tail page
> (PTE-mapped THP) applies: as we don't know and to make our life easier,
> check that either is set.
> 
> Take care to not verify in case we're unpinning during GUP-fast because
> we detected concurrent fork(): we might stumble over an anonymous page
> that is now shared.
> 
> Signed-off-by: David Hildenbrand <david@redhat.com>
>  mm/gup.c         | 58 +++++++++++++++++++++++++++++++++++++++++++++++-
>  mm/huge_memory.c |  3 +++
>  mm/hugetlb.c     |  3 +++
>  3 files changed, 63 insertions(+), 1 deletion(-)
> 
> diff --git a/mm/gup.c b/mm/gup.c
> index 92dcd92f9d67..72e39b77da10 100644
> +++ b/mm/gup.c
> @@ -45,6 +45,38 @@ static void hpage_pincount_sub(struct page *page, int refs)
>  	atomic_sub(refs, compound_pincount_ptr(page));
>  }
>  
> +static inline void sanity_check_pinned_pages(struct page **pages,
> +					     unsigned long npages)
> +{
> +#ifdef CONFIG_DEBUG_VM

Perhaps:

if (!IS_ENABLED(CONFIG_DEBUG_VM))
   return;

So this gets compilation coverage

Jason

Re: [PATCH v2 00/15] mm: COW fixes part 2: reliable GUP pins of anonymous pages

[Jason Gunthorpe]

On Tue, Mar 15, 2022 at 11:47:26AM +0100, David Hildenbrand wrote:

> This series fixes memory corruptions when a GUP pin (FOLL_PIN) was taken
> on an anonymous page and COW logic fails to detect exclusivity of the page
> to then replacing the anonymous page by a copy in the page table: The
> GUP pin lost synchronicity with the pages mapped into the page tables.

I don't know much about most of this part of the mm, but nothing here
gave me serious pause. We are trying to run this series in our RDMA
testing. Will let you know.

Thanks,
Jason

Re: [PATCH v2 11/15] mm: remember exclusively mapped anonymous pages with PG_anon_exclusive

[David Hildenbrand]

On 18.03.22 21:29, Yang Shi wrote:
> On Thu, Mar 17, 2022 at 2:06 AM David Hildenbrand <david@redhat.com> wrote:
>>
>> On 16.03.22 22:23, Yang Shi wrote:
>>> On Tue, Mar 15, 2022 at 3:52 AM David Hildenbrand <david@redhat.com> wrote:
>>>>
>>>> Let's mark exclusively mapped anonymous pages with PG_anon_exclusive as
>>>> exclusive, and use that information to make GUP pins reliable and stay
>>>> consistent with the page mapped into the page table even if the
>>>> page table entry gets write-protected.
>>>>
>>>> With that information at hand, we can extend our COW logic to always
>>>> reuse anonymous pages that are exclusive. For anonymous pages that
>>>> might be shared, the existing logic applies.
>>>>
>>>> As already documented, PG_anon_exclusive is usually only expressive in
>>>> combination with a page table entry. Especially PTE vs. PMD-mapped
>>>> anonymous pages require more thought, some examples: due to mremap() we
>>>> can easily have a single compound page PTE-mapped into multiple page tables
>>>> exclusively in a single process -- multiple page table locks apply.
>>>> Further, due to MADV_WIPEONFORK we might not necessarily write-protect
>>>> all PTEs, and only some subpages might be pinned. Long story short: once
>>>> PTE-mapped, we have to track information about exclusivity per sub-page,
>>>> but until then, we can just track it for the compound page in the head
>>>> page and not having to update a whole bunch of subpages all of the time
>>>> for a simple PMD mapping of a THP.
>>>>
>>>> For simplicity, this commit mostly talks about "anonymous pages", while
>>>> it's for THP actually "the part of an anonymous folio referenced via
>>>> a page table entry".
>>>>
>>>> To not spill PG_anon_exclusive code all over the mm code-base, we let
>>>> the anon rmap code to handle all PG_anon_exclusive logic it can easily
>>>> handle.
>>>>
>>>> If a writable, present page table entry points at an anonymous (sub)page,
>>>> that (sub)page must be PG_anon_exclusive. If GUP wants to take a reliably
>>>> pin (FOLL_PIN) on an anonymous page references via a present
>>>> page table entry, it must only pin if PG_anon_exclusive is set for the
>>>> mapped (sub)page.
>>>>
>>>> This commit doesn't adjust GUP, so this is only implicitly handled for
>>>> FOLL_WRITE, follow-up commits will teach GUP to also respect it for
>>>> FOLL_PIN without !FOLL_WRITE, to make all GUP pins of anonymous pages
>>>> fully reliable.
>>>>
>>>> Whenever an anonymous page is to be shared (fork(), KSM), or when
>>>> temporarily unmapping an anonymous page (swap, migration), the relevant
>>>> PG_anon_exclusive bit has to be cleared to mark the anonymous page
>>>> possibly shared. Clearing will fail if there are GUP pins on the page:
>>>> * For fork(), this means having to copy the page and not being able to
>>>>   share it. fork() protects against concurrent GUP using the PT lock and
>>>>   the src_mm->write_protect_seq.
>>>> * For KSM, this means sharing will fail. For swap this means, unmapping
>>>>   will fail, For migration this means, migration will fail early. All
>>>>   three cases protect against concurrent GUP using the PT lock and a
>>>>   proper clear/invalidate+flush of the relevant page table entry.
>>>>
>>>> This fixes memory corruptions reported for FOLL_PIN | FOLL_WRITE, when a
>>>> pinned page gets mapped R/O and the successive write fault ends up
>>>> replacing the page instead of reusing it. It improves the situation for
>>>> O_DIRECT/vmsplice/... that still use FOLL_GET instead of FOLL_PIN,
>>>> if fork() is *not* involved, however swapout and fork() are still
>>>> problematic. Properly using FOLL_PIN instead of FOLL_GET for these
>>>> GUP users will fix the issue for them.
>>>>
>>>> I. Details about basic handling
>>>>
>>>> I.1. Fresh anonymous pages
>>>>
>>>> page_add_new_anon_rmap() and hugepage_add_new_anon_rmap() will mark the
>>>> given page exclusive via __page_set_anon_rmap(exclusive=1). As that is
>>>> the mechanism fresh anonymous pages come into life (besides migration
>>>> code where we copy the page->mapping), all fresh anonymous pages will
>>>> start out as exclusive.
>>>>
>>>> I.2. COW reuse handling of anonymous pages
>>>>
>>>> When a COW handler stumbles over a (sub)page that's marked exclusive, it
>>>> simply reuses it. Otherwise, the handler tries harder under page lock to
>>>> detect if the (sub)page is exclusive and can be reused. If exclusive,
>>>> page_move_anon_rmap() will mark the given (sub)page exclusive.
>>>>
>>>> Note that hugetlb code does not yet check for PageAnonExclusive(), as it
>>>> still uses the old COW logic that is prone to the COW security issue
>>>> because hugetlb code cannot really tolerate unnecessary/wrong COW as
>>>> huge pages are a scarce resource.
>>>>
>>>> I.3. Migration handling
>>>>
>>>> try_to_migrate() has to try marking an exclusive anonymous page shared
>>>> via page_try_share_anon_rmap(). If it fails because there are GUP pins
>>>> on the page, unmap fails. migrate_vma_collect_pmd() and
>>>> __split_huge_pmd_locked() are handled similarly.
>>>>
>>>> Writable migration entries implicitly point at shared anonymous pages.
>>>> For readable migration entries that information is stored via a new
>>>> "readable-exclusive" migration entry, specific to anonymous pages.
>>>>
>>>> When restoring a migration entry in remove_migration_pte(), information
>>>> about exlusivity is detected via the migration entry type, and
>>>> RMAP_EXCLUSIVE is set accordingly for
>>>> page_add_anon_rmap()/hugepage_add_anon_rmap() to restore that
>>>> information.
>>>>
>>>> I.4. Swapout handling
>>>>
>>>> try_to_unmap() has to try marking the mapped page possibly shared via
>>>> page_try_share_anon_rmap(). If it fails because there are GUP pins on the
>>>> page, unmap fails. For now, information about exclusivity is lost. In the
>>>> future, we might want to remember that information in the swap entry in
>>>> some cases, however, it requires more thought, care, and a way to store
>>>> that information in swap entries.
>>>>
>>>> I.5. Swapin handling
>>>>
>>>> do_swap_page() will never stumble over exclusive anonymous pages in the
>>>> swap cache, as try_to_migrate() prohibits that. do_swap_page() always has
>>>> to detect manually if an anonymous page is exclusive and has to set
>>>> RMAP_EXCLUSIVE for page_add_anon_rmap() accordingly.
>>>>
>>>> I.6. THP handling
>>>>
>>>> __split_huge_pmd_locked() has to move the information about exclusivity
>>>> from the PMD to the PTEs.
>>>>
>>>> a) In case we have a readable-exclusive PMD migration entry, simply insert
>>>> readable-exclusive PTE migration entries.
>>>>
>>>> b) In case we have a present PMD entry and we don't want to freeze
>>>> ("convert to migration entries"), simply forward PG_anon_exclusive to
>>>> all sub-pages, no need to temporarily clear the bit.
>>>>
>>>> c) In case we have a present PMD entry and want to freeze, handle it
>>>> similar to try_to_migrate(): try marking the page shared first. In case
>>>> we fail, we ignore the "freeze" instruction and simply split ordinarily.
>>>> try_to_migrate() will properly fail because the THP is still mapped via
>>>> PTEs.
>>
>> Hi,
>>
>> thanks for the review!
>>
>>>
>>> How come will try_to_migrate() fail? The afterward pvmw will find
>>> those PTEs then convert them to migration entries anyway IIUC.
>>>
>>
>> It will run into that code:
>>
>>>> @@ -1903,6 +1938,15 @@ static bool try_to_migrate_one(struct page *page, struct vm_area_struct *vma,
>>>>                                 page_vma_mapped_walk_done(&pvmw);
>>>>                                 break;
>>>>                         }
>>>> +                       VM_BUG_ON_PAGE(pte_write(pteval) && PageAnon(page) &&
>>>> +                                      !anon_exclusive, page);
>>>> +                       if (anon_exclusive &&
>>>> +                           page_try_share_anon_rmap(subpage)) {
>>>> +                               set_pte_at(mm, address, pvmw.pte, pteval);
>>>> +                               ret = false;
>>>> +                               page_vma_mapped_walk_done(&pvmw);
>>>> +                               break;
>>>> +                       }
>>
>> and similarly fail the page_try_share_anon_rmap(), at which point
>> try_to_migrate() stops and the caller will still observe a
>> "page_mapped() == true".
> 
> Thanks, I missed that. Yes, the page will still be mapped. This should
> trigger the VM_WARN_ON_ONCE in unmap_page(), if this change will make
> this happen more often, we may consider removing that warning even
> though it is "once" since seeing a mapped page may become a normal
> case (once DIO is switched to FOLL_PIN, it may be more often). Anyway
> we don't have to remove it right now.

Oh, very good catch! I wasn't able to trigger that warning in my testing
so far. Interestingly, arch_unmap_one() could theoretically make this
fail already and trigger the warning.

Apart from that warning, split_huge_page_to_list() should work as
expected: freezing the refcount will fail if still mapped and we'll remap.

I'll include a separate patch to just remove that VM_WARN_ON_ONCE -- thanks!

-- 
Thanks,

David / dhildenb

Re: [PATCH v2 15/15] mm/gup: sanity-check with CONFIG_DEBUG_VM that anonymous pages are exclusive when (un)pinning

[David Hildenbrand]

On 19.03.22 00:35, Jason Gunthorpe wrote:
> On Tue, Mar 15, 2022 at 11:47:41AM +0100, David Hildenbrand wrote:
>> Let's verify when (un)pinning anonymous pages that we always deal with
>> exclusive anonymous pages, which guarantees that we'll have a reliable
>> PIN, meaning that we cannot end up with the GUP pin being inconsistent
>> with he pages mapped into the page tables due to a COW triggered
>> by a write fault.
>>
>> When pinning pages, after conditionally triggering GUP unsharing of
>> possibly shared anonymous pages, we should always only see exclusive
>> anonymous pages. Note that anonymous pages that are mapped writable
>> must be marked exclusive, otherwise we'd have a BUG.
>>
>> When pinning during ordinary GUP, simply add a check after our
>> conditional GUP-triggered unsharing checks. As we know exactly how the
>> page is mapped, we know exactly in which page we have to check for
>> PageAnonExclusive().
>>
>> When pinning via GUP-fast we have to be careful, because we can race with
>> fork(): verify only after we made sure via the seqcount that we didn't
>> race with concurrent fork() that we didn't end up pinning a possibly
>> shared anonymous page.
>>
>> Similarly, when unpinning, verify that the pages are still marked as
>> exclusive: otherwise something turned the pages possibly shared, which
>> can result in random memory corruptions, which we really want to catch.
>>
>> With only the pinned pages at hand and not the actual page table entries
>> we have to be a bit careful: hugetlb pages are always mapped via a
>> single logical page table entry referencing the head page and
>> PG_anon_exclusive of the head page applies. Anon THP are a bit more
>> complicated, because we might have obtained the page reference either via
>> a PMD or a PTE -- depending on the mapping type we either have to check
>> PageAnonExclusive of the head page (PMD-mapped THP) or the tail page
>> (PTE-mapped THP) applies: as we don't know and to make our life easier,
>> check that either is set.
>>
>> Take care to not verify in case we're unpinning during GUP-fast because
>> we detected concurrent fork(): we might stumble over an anonymous page
>> that is now shared.
>>
>> Signed-off-by: David Hildenbrand <david@redhat.com>
>>  mm/gup.c         | 58 +++++++++++++++++++++++++++++++++++++++++++++++-
>>  mm/huge_memory.c |  3 +++
>>  mm/hugetlb.c     |  3 +++
>>  3 files changed, 63 insertions(+), 1 deletion(-)
>>
>> diff --git a/mm/gup.c b/mm/gup.c
>> index 92dcd92f9d67..72e39b77da10 100644
>> +++ b/mm/gup.c
>> @@ -45,6 +45,38 @@ static void hpage_pincount_sub(struct page *page, int refs)
>>  	atomic_sub(refs, compound_pincount_ptr(page));
>>  }
>>  
>> +static inline void sanity_check_pinned_pages(struct page **pages,
>> +					     unsigned long npages)
>> +{
>> +#ifdef CONFIG_DEBUG_VM
> 
> Perhaps:
> 
> if (!IS_ENABLED(CONFIG_DEBUG_VM))
>    return;
> 
> So this gets compilation coverage

Makes sense, that code should compile just fine without CONFIG_DEBUG_VM.
Thanks!

-- 
Thanks,

David / dhildenb

Re: [PATCH v2 11/15] mm: remember exclusively mapped anonymous pages with PG_anon_exclusive

[David Hildenbrand]

On 19.03.22 11:21, David Hildenbrand wrote:
> On 18.03.22 21:29, Yang Shi wrote:
>> On Thu, Mar 17, 2022 at 2:06 AM David Hildenbrand <david@redhat.com> wrote:
>>>
>>> On 16.03.22 22:23, Yang Shi wrote:
>>>> On Tue, Mar 15, 2022 at 3:52 AM David Hildenbrand <david@redhat.com> wrote:
>>>>>
>>>>> Let's mark exclusively mapped anonymous pages with PG_anon_exclusive as
>>>>> exclusive, and use that information to make GUP pins reliable and stay
>>>>> consistent with the page mapped into the page table even if the
>>>>> page table entry gets write-protected.
>>>>>
>>>>> With that information at hand, we can extend our COW logic to always
>>>>> reuse anonymous pages that are exclusive. For anonymous pages that
>>>>> might be shared, the existing logic applies.
>>>>>
>>>>> As already documented, PG_anon_exclusive is usually only expressive in
>>>>> combination with a page table entry. Especially PTE vs. PMD-mapped
>>>>> anonymous pages require more thought, some examples: due to mremap() we
>>>>> can easily have a single compound page PTE-mapped into multiple page tables
>>>>> exclusively in a single process -- multiple page table locks apply.
>>>>> Further, due to MADV_WIPEONFORK we might not necessarily write-protect
>>>>> all PTEs, and only some subpages might be pinned. Long story short: once
>>>>> PTE-mapped, we have to track information about exclusivity per sub-page,
>>>>> but until then, we can just track it for the compound page in the head
>>>>> page and not having to update a whole bunch of subpages all of the time
>>>>> for a simple PMD mapping of a THP.
>>>>>
>>>>> For simplicity, this commit mostly talks about "anonymous pages", while
>>>>> it's for THP actually "the part of an anonymous folio referenced via
>>>>> a page table entry".
>>>>>
>>>>> To not spill PG_anon_exclusive code all over the mm code-base, we let
>>>>> the anon rmap code to handle all PG_anon_exclusive logic it can easily
>>>>> handle.
>>>>>
>>>>> If a writable, present page table entry points at an anonymous (sub)page,
>>>>> that (sub)page must be PG_anon_exclusive. If GUP wants to take a reliably
>>>>> pin (FOLL_PIN) on an anonymous page references via a present
>>>>> page table entry, it must only pin if PG_anon_exclusive is set for the
>>>>> mapped (sub)page.
>>>>>
>>>>> This commit doesn't adjust GUP, so this is only implicitly handled for
>>>>> FOLL_WRITE, follow-up commits will teach GUP to also respect it for
>>>>> FOLL_PIN without !FOLL_WRITE, to make all GUP pins of anonymous pages
>>>>> fully reliable.
>>>>>
>>>>> Whenever an anonymous page is to be shared (fork(), KSM), or when
>>>>> temporarily unmapping an anonymous page (swap, migration), the relevant
>>>>> PG_anon_exclusive bit has to be cleared to mark the anonymous page
>>>>> possibly shared. Clearing will fail if there are GUP pins on the page:
>>>>> * For fork(), this means having to copy the page and not being able to
>>>>>   share it. fork() protects against concurrent GUP using the PT lock and
>>>>>   the src_mm->write_protect_seq.
>>>>> * For KSM, this means sharing will fail. For swap this means, unmapping
>>>>>   will fail, For migration this means, migration will fail early. All
>>>>>   three cases protect against concurrent GUP using the PT lock and a
>>>>>   proper clear/invalidate+flush of the relevant page table entry.
>>>>>
>>>>> This fixes memory corruptions reported for FOLL_PIN | FOLL_WRITE, when a
>>>>> pinned page gets mapped R/O and the successive write fault ends up
>>>>> replacing the page instead of reusing it. It improves the situation for
>>>>> O_DIRECT/vmsplice/... that still use FOLL_GET instead of FOLL_PIN,
>>>>> if fork() is *not* involved, however swapout and fork() are still
>>>>> problematic. Properly using FOLL_PIN instead of FOLL_GET for these
>>>>> GUP users will fix the issue for them.
>>>>>
>>>>> I. Details about basic handling
>>>>>
>>>>> I.1. Fresh anonymous pages
>>>>>
>>>>> page_add_new_anon_rmap() and hugepage_add_new_anon_rmap() will mark the
>>>>> given page exclusive via __page_set_anon_rmap(exclusive=1). As that is
>>>>> the mechanism fresh anonymous pages come into life (besides migration
>>>>> code where we copy the page->mapping), all fresh anonymous pages will
>>>>> start out as exclusive.
>>>>>
>>>>> I.2. COW reuse handling of anonymous pages
>>>>>
>>>>> When a COW handler stumbles over a (sub)page that's marked exclusive, it
>>>>> simply reuses it. Otherwise, the handler tries harder under page lock to
>>>>> detect if the (sub)page is exclusive and can be reused. If exclusive,
>>>>> page_move_anon_rmap() will mark the given (sub)page exclusive.
>>>>>
>>>>> Note that hugetlb code does not yet check for PageAnonExclusive(), as it
>>>>> still uses the old COW logic that is prone to the COW security issue
>>>>> because hugetlb code cannot really tolerate unnecessary/wrong COW as
>>>>> huge pages are a scarce resource.
>>>>>
>>>>> I.3. Migration handling
>>>>>
>>>>> try_to_migrate() has to try marking an exclusive anonymous page shared
>>>>> via page_try_share_anon_rmap(). If it fails because there are GUP pins
>>>>> on the page, unmap fails. migrate_vma_collect_pmd() and
>>>>> __split_huge_pmd_locked() are handled similarly.
>>>>>
>>>>> Writable migration entries implicitly point at shared anonymous pages.
>>>>> For readable migration entries that information is stored via a new
>>>>> "readable-exclusive" migration entry, specific to anonymous pages.
>>>>>
>>>>> When restoring a migration entry in remove_migration_pte(), information
>>>>> about exlusivity is detected via the migration entry type, and
>>>>> RMAP_EXCLUSIVE is set accordingly for
>>>>> page_add_anon_rmap()/hugepage_add_anon_rmap() to restore that
>>>>> information.
>>>>>
>>>>> I.4. Swapout handling
>>>>>
>>>>> try_to_unmap() has to try marking the mapped page possibly shared via
>>>>> page_try_share_anon_rmap(). If it fails because there are GUP pins on the
>>>>> page, unmap fails. For now, information about exclusivity is lost. In the
>>>>> future, we might want to remember that information in the swap entry in
>>>>> some cases, however, it requires more thought, care, and a way to store
>>>>> that information in swap entries.
>>>>>
>>>>> I.5. Swapin handling
>>>>>
>>>>> do_swap_page() will never stumble over exclusive anonymous pages in the
>>>>> swap cache, as try_to_migrate() prohibits that. do_swap_page() always has
>>>>> to detect manually if an anonymous page is exclusive and has to set
>>>>> RMAP_EXCLUSIVE for page_add_anon_rmap() accordingly.
>>>>>
>>>>> I.6. THP handling
>>>>>
>>>>> __split_huge_pmd_locked() has to move the information about exclusivity
>>>>> from the PMD to the PTEs.
>>>>>
>>>>> a) In case we have a readable-exclusive PMD migration entry, simply insert
>>>>> readable-exclusive PTE migration entries.
>>>>>
>>>>> b) In case we have a present PMD entry and we don't want to freeze
>>>>> ("convert to migration entries"), simply forward PG_anon_exclusive to
>>>>> all sub-pages, no need to temporarily clear the bit.
>>>>>
>>>>> c) In case we have a present PMD entry and want to freeze, handle it
>>>>> similar to try_to_migrate(): try marking the page shared first. In case
>>>>> we fail, we ignore the "freeze" instruction and simply split ordinarily.
>>>>> try_to_migrate() will properly fail because the THP is still mapped via
>>>>> PTEs.
>>>
>>> Hi,
>>>
>>> thanks for the review!
>>>
>>>>
>>>> How come will try_to_migrate() fail? The afterward pvmw will find
>>>> those PTEs then convert them to migration entries anyway IIUC.
>>>>
>>>
>>> It will run into that code:
>>>
>>>>> @@ -1903,6 +1938,15 @@ static bool try_to_migrate_one(struct page *page, struct vm_area_struct *vma,
>>>>>                                 page_vma_mapped_walk_done(&pvmw);
>>>>>                                 break;
>>>>>                         }
>>>>> +                       VM_BUG_ON_PAGE(pte_write(pteval) && PageAnon(page) &&
>>>>> +                                      !anon_exclusive, page);
>>>>> +                       if (anon_exclusive &&
>>>>> +                           page_try_share_anon_rmap(subpage)) {
>>>>> +                               set_pte_at(mm, address, pvmw.pte, pteval);
>>>>> +                               ret = false;
>>>>> +                               page_vma_mapped_walk_done(&pvmw);
>>>>> +                               break;
>>>>> +                       }
>>>
>>> and similarly fail the page_try_share_anon_rmap(), at which point
>>> try_to_migrate() stops and the caller will still observe a
>>> "page_mapped() == true".
>>
>> Thanks, I missed that. Yes, the page will still be mapped. This should
>> trigger the VM_WARN_ON_ONCE in unmap_page(), if this change will make
>> this happen more often, we may consider removing that warning even
>> though it is "once" since seeing a mapped page may become a normal
>> case (once DIO is switched to FOLL_PIN, it may be more often). Anyway
>> we don't have to remove it right now.
> 
> Oh, very good catch! I wasn't able to trigger that warning in my testing
> so far. Interestingly, arch_unmap_one() could theoretically make this
> fail already and trigger the warning.
> 
> Apart from that warning, split_huge_page_to_list() should work as
> expected: freezing the refcount will fail if still mapped and we'll remap.
> 
> I'll include a separate patch to just remove that VM_WARN_ON_ONCE -- thanks!
> 

From e6e983d841cd2aa2a9c8dc71779211881cf0d96f Mon Sep 17 00:00:00 2001
From: David Hildenbrand <david@redhat.com>
Date: Sat, 19 Mar 2022 11:49:39 +0100
Subject: [PATCH] mm/huge_memory: remove outdated VM_WARN_ON_ONCE_PAGE from
 unmap_page()

We can already theoretically fail to unmap (still having page_mapped()) in
case arch_unmap_one() fails. Although this applies only to anonymous pages
for now, get rid of the VM_WARN_ON_ONCE_PAGE() completely: the caller --
split_huge_page_to_list() -- will fail to freeze the refcount and
remap the page via remap_page(). So the caller can handle unmap errors
just fine.

This is a preparation for making try_to_migrate() fail on anonymous pages
with GUP pins.

Reported-by: Yang Shi <shy828301@gmail.com>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 mm/huge_memory.c | 2 --
 1 file changed, 2 deletions(-)

diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index 0b6fb409b9e4..0fe0ab3ec3fc 100644
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -2263,8 +2263,6 @@ static void unmap_page(struct page *page)
 		try_to_migrate(page, ttu_flags);
 	else
 		try_to_unmap(page, ttu_flags | TTU_IGNORE_MLOCK);
-
-	VM_WARN_ON_ONCE_PAGE(page_mapped(page), page);
 }
 
 static void remap_page(struct page *page, unsigned int nr)
-- 
2.35.1


-- 
Thanks,

David / dhildenb

Re: [PATCH v2 13/15] mm: support GUP-triggered unsharing of anonymous pages

[David Hildenbrand]

On 19.03.22 00:30, Jason Gunthorpe wrote:
> On Tue, Mar 15, 2022 at 11:47:39AM +0100, David Hildenbrand wrote:
>> 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.
> 
> Given the way this series has developed you might want to call this
> FAULT_FLAG_MAKE_ANON_EXCLUSIVE
> 
> Which strikes me as more directly connected to what it is trying to
> do.

I thought about something similar along those lines, and I think it
would apply even when extending that mechanism to anything !anon inside
a MAP_PRIVATE mapping.

The whole

const bool unshare = vmf->flags & FAULT_FLAG_UNSHARE;

would get a little more verbose, though

const bool make_anon_exclusive = vmf->flags &
				 FAULT_FLAG_MAKE_ANON_EXCLUSIVE;


No strong opinion, any other opinions or alternatives?

-- 
Thanks,

David / dhildenb

Re: [PATCH v2 13/15] mm: support GUP-triggered unsharing of anonymous pages

[Jason Gunthorpe]

On Mon, Mar 21, 2022 at 05:15:06PM +0100, David Hildenbrand wrote:
> On 19.03.22 00:30, Jason Gunthorpe wrote:
> > On Tue, Mar 15, 2022 at 11:47:39AM +0100, David Hildenbrand wrote:
> >> 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.
> > 
> > Given the way this series has developed you might want to call this
> > FAULT_FLAG_MAKE_ANON_EXCLUSIVE
> > 
> > Which strikes me as more directly connected to what it is trying to
> > do.
> 
> I thought about something similar along those lines, and I think it
> would apply even when extending that mechanism to anything !anon inside
> a MAP_PRIVATE mapping.
> 
> The whole
> 
> const bool unshare = vmf->flags & FAULT_FLAG_UNSHARE;

I think the extra words are worthwhile, share makes me think about
MAP_SHARED as we don't really use shared anywhere else FWICT..

Jason

Re: [PATCH v2 13/15] mm: support GUP-triggered unsharing of anonymous pages

[David Hildenbrand]

On 21.03.22 17:18, Jason Gunthorpe wrote:
> On Mon, Mar 21, 2022 at 05:15:06PM +0100, David Hildenbrand wrote:
>> On 19.03.22 00:30, Jason Gunthorpe wrote:
>>> On Tue, Mar 15, 2022 at 11:47:39AM +0100, David Hildenbrand wrote:
>>>> 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.
>>>
>>> Given the way this series has developed you might want to call this
>>> FAULT_FLAG_MAKE_ANON_EXCLUSIVE
>>>
>>> Which strikes me as more directly connected to what it is trying to
>>> do.
>>
>> I thought about something similar along those lines, and I think it
>> would apply even when extending that mechanism to anything !anon inside
>> a MAP_PRIVATE mapping.
>>
>> The whole
>>
>> const bool unshare = vmf->flags & FAULT_FLAG_UNSHARE;
> 
> I think the extra words are worthwhile, share makes me think about
> MAP_SHARED as we don't really use shared anywhere else FWICT..

Yeah, my point would be that you can only "unshare" in MAP_PRIVATE
(!MAP_SHARED) :)

-- 
Thanks,

David / dhildenb

Re: [PATCH v2 11/15] mm: remember exclusively mapped anonymous pages with PG_anon_exclusive

[Yang Shi]

On Sat, Mar 19, 2022 at 3:21 AM David Hildenbrand <david@redhat.com> wrote:
>
> On 18.03.22 21:29, Yang Shi wrote:
> > On Thu, Mar 17, 2022 at 2:06 AM David Hildenbrand <david@redhat.com> wrote:
> >>
> >> On 16.03.22 22:23, Yang Shi wrote:
> >>> On Tue, Mar 15, 2022 at 3:52 AM David Hildenbrand <david@redhat.com> wrote:
> >>>>
> >>>> Let's mark exclusively mapped anonymous pages with PG_anon_exclusive as
> >>>> exclusive, and use that information to make GUP pins reliable and stay
> >>>> consistent with the page mapped into the page table even if the
> >>>> page table entry gets write-protected.
> >>>>
> >>>> With that information at hand, we can extend our COW logic to always
> >>>> reuse anonymous pages that are exclusive. For anonymous pages that
> >>>> might be shared, the existing logic applies.
> >>>>
> >>>> As already documented, PG_anon_exclusive is usually only expressive in
> >>>> combination with a page table entry. Especially PTE vs. PMD-mapped
> >>>> anonymous pages require more thought, some examples: due to mremap() we
> >>>> can easily have a single compound page PTE-mapped into multiple page tables
> >>>> exclusively in a single process -- multiple page table locks apply.
> >>>> Further, due to MADV_WIPEONFORK we might not necessarily write-protect
> >>>> all PTEs, and only some subpages might be pinned. Long story short: once
> >>>> PTE-mapped, we have to track information about exclusivity per sub-page,
> >>>> but until then, we can just track it for the compound page in the head
> >>>> page and not having to update a whole bunch of subpages all of the time
> >>>> for a simple PMD mapping of a THP.
> >>>>
> >>>> For simplicity, this commit mostly talks about "anonymous pages", while
> >>>> it's for THP actually "the part of an anonymous folio referenced via
> >>>> a page table entry".
> >>>>
> >>>> To not spill PG_anon_exclusive code all over the mm code-base, we let
> >>>> the anon rmap code to handle all PG_anon_exclusive logic it can easily
> >>>> handle.
> >>>>
> >>>> If a writable, present page table entry points at an anonymous (sub)page,
> >>>> that (sub)page must be PG_anon_exclusive. If GUP wants to take a reliably
> >>>> pin (FOLL_PIN) on an anonymous page references via a present
> >>>> page table entry, it must only pin if PG_anon_exclusive is set for the
> >>>> mapped (sub)page.
> >>>>
> >>>> This commit doesn't adjust GUP, so this is only implicitly handled for
> >>>> FOLL_WRITE, follow-up commits will teach GUP to also respect it for
> >>>> FOLL_PIN without !FOLL_WRITE, to make all GUP pins of anonymous pages
> >>>> fully reliable.
> >>>>
> >>>> Whenever an anonymous page is to be shared (fork(), KSM), or when
> >>>> temporarily unmapping an anonymous page (swap, migration), the relevant
> >>>> PG_anon_exclusive bit has to be cleared to mark the anonymous page
> >>>> possibly shared. Clearing will fail if there are GUP pins on the page:
> >>>> * For fork(), this means having to copy the page and not being able to
> >>>>   share it. fork() protects against concurrent GUP using the PT lock and
> >>>>   the src_mm->write_protect_seq.
> >>>> * For KSM, this means sharing will fail. For swap this means, unmapping
> >>>>   will fail, For migration this means, migration will fail early. All
> >>>>   three cases protect against concurrent GUP using the PT lock and a
> >>>>   proper clear/invalidate+flush of the relevant page table entry.
> >>>>
> >>>> This fixes memory corruptions reported for FOLL_PIN | FOLL_WRITE, when a
> >>>> pinned page gets mapped R/O and the successive write fault ends up
> >>>> replacing the page instead of reusing it. It improves the situation for
> >>>> O_DIRECT/vmsplice/... that still use FOLL_GET instead of FOLL_PIN,
> >>>> if fork() is *not* involved, however swapout and fork() are still
> >>>> problematic. Properly using FOLL_PIN instead of FOLL_GET for these
> >>>> GUP users will fix the issue for them.
> >>>>
> >>>> I. Details about basic handling
> >>>>
> >>>> I.1. Fresh anonymous pages
> >>>>
> >>>> page_add_new_anon_rmap() and hugepage_add_new_anon_rmap() will mark the
> >>>> given page exclusive via __page_set_anon_rmap(exclusive=1). As that is
> >>>> the mechanism fresh anonymous pages come into life (besides migration
> >>>> code where we copy the page->mapping), all fresh anonymous pages will
> >>>> start out as exclusive.
> >>>>
> >>>> I.2. COW reuse handling of anonymous pages
> >>>>
> >>>> When a COW handler stumbles over a (sub)page that's marked exclusive, it
> >>>> simply reuses it. Otherwise, the handler tries harder under page lock to
> >>>> detect if the (sub)page is exclusive and can be reused. If exclusive,
> >>>> page_move_anon_rmap() will mark the given (sub)page exclusive.
> >>>>
> >>>> Note that hugetlb code does not yet check for PageAnonExclusive(), as it
> >>>> still uses the old COW logic that is prone to the COW security issue
> >>>> because hugetlb code cannot really tolerate unnecessary/wrong COW as
> >>>> huge pages are a scarce resource.
> >>>>
> >>>> I.3. Migration handling
> >>>>
> >>>> try_to_migrate() has to try marking an exclusive anonymous page shared
> >>>> via page_try_share_anon_rmap(). If it fails because there are GUP pins
> >>>> on the page, unmap fails. migrate_vma_collect_pmd() and
> >>>> __split_huge_pmd_locked() are handled similarly.
> >>>>
> >>>> Writable migration entries implicitly point at shared anonymous pages.
> >>>> For readable migration entries that information is stored via a new
> >>>> "readable-exclusive" migration entry, specific to anonymous pages.
> >>>>
> >>>> When restoring a migration entry in remove_migration_pte(), information
> >>>> about exlusivity is detected via the migration entry type, and
> >>>> RMAP_EXCLUSIVE is set accordingly for
> >>>> page_add_anon_rmap()/hugepage_add_anon_rmap() to restore that
> >>>> information.
> >>>>
> >>>> I.4. Swapout handling
> >>>>
> >>>> try_to_unmap() has to try marking the mapped page possibly shared via
> >>>> page_try_share_anon_rmap(). If it fails because there are GUP pins on the
> >>>> page, unmap fails. For now, information about exclusivity is lost. In the
> >>>> future, we might want to remember that information in the swap entry in
> >>>> some cases, however, it requires more thought, care, and a way to store
> >>>> that information in swap entries.
> >>>>
> >>>> I.5. Swapin handling
> >>>>
> >>>> do_swap_page() will never stumble over exclusive anonymous pages in the
> >>>> swap cache, as try_to_migrate() prohibits that. do_swap_page() always has
> >>>> to detect manually if an anonymous page is exclusive and has to set
> >>>> RMAP_EXCLUSIVE for page_add_anon_rmap() accordingly.
> >>>>
> >>>> I.6. THP handling
> >>>>
> >>>> __split_huge_pmd_locked() has to move the information about exclusivity
> >>>> from the PMD to the PTEs.
> >>>>
> >>>> a) In case we have a readable-exclusive PMD migration entry, simply insert
> >>>> readable-exclusive PTE migration entries.
> >>>>
> >>>> b) In case we have a present PMD entry and we don't want to freeze
> >>>> ("convert to migration entries"), simply forward PG_anon_exclusive to
> >>>> all sub-pages, no need to temporarily clear the bit.
> >>>>
> >>>> c) In case we have a present PMD entry and want to freeze, handle it
> >>>> similar to try_to_migrate(): try marking the page shared first. In case
> >>>> we fail, we ignore the "freeze" instruction and simply split ordinarily.
> >>>> try_to_migrate() will properly fail because the THP is still mapped via
> >>>> PTEs.
> >>
> >> Hi,
> >>
> >> thanks for the review!
> >>
> >>>
> >>> How come will try_to_migrate() fail? The afterward pvmw will find
> >>> those PTEs then convert them to migration entries anyway IIUC.
> >>>
> >>
> >> It will run into that code:
> >>
> >>>> @@ -1903,6 +1938,15 @@ static bool try_to_migrate_one(struct page *page, struct vm_area_struct *vma,
> >>>>                                 page_vma_mapped_walk_done(&pvmw);
> >>>>                                 break;
> >>>>                         }
> >>>> +                       VM_BUG_ON_PAGE(pte_write(pteval) && PageAnon(page) &&
> >>>> +                                      !anon_exclusive, page);
> >>>> +                       if (anon_exclusive &&
> >>>> +                           page_try_share_anon_rmap(subpage)) {
> >>>> +                               set_pte_at(mm, address, pvmw.pte, pteval);
> >>>> +                               ret = false;
> >>>> +                               page_vma_mapped_walk_done(&pvmw);
> >>>> +                               break;
> >>>> +                       }
> >>
> >> and similarly fail the page_try_share_anon_rmap(), at which point
> >> try_to_migrate() stops and the caller will still observe a
> >> "page_mapped() == true".
> >
> > Thanks, I missed that. Yes, the page will still be mapped. This should
> > trigger the VM_WARN_ON_ONCE in unmap_page(), if this change will make
> > this happen more often, we may consider removing that warning even
> > though it is "once" since seeing a mapped page may become a normal
> > case (once DIO is switched to FOLL_PIN, it may be more often). Anyway
> > we don't have to remove it right now.
>
> Oh, very good catch! I wasn't able to trigger that warning in my testing
> so far. Interestingly, arch_unmap_one() could theoretically make this
> fail already and trigger the warning.

It should be very rare to trigger that warning. I just saw one report
before. And arch_unmap_one() actually can't fail except for Sparc. So
that warning was intended to catch some unusual issues, but this COW
patchset may make it much more usual than before.

>
> Apart from that warning, split_huge_page_to_list() should work as
> expected: freezing the refcount will fail if still mapped and we'll remap.

Yes, that was why it was changed to a WARN from a BUG, please see
commit 504e070dc08f ("mm: thp: replace DEBUG_VM BUG with VM_WARN when
unmap fails for split")

>
> I'll include a separate patch to just remove that VM_WARN_ON_ONCE -- thanks!

Thanks, I'm fine to remove it.

>
> --
> Thanks,
>
> David / dhildenb
>

Re: [PATCH v2 11/15] mm: remember exclusively mapped anonymous pages with PG_anon_exclusive

[Yang Shi]

On Sat, Mar 19, 2022 at 3:50 AM David Hildenbrand <david@redhat.com> wrote:
>
> On 19.03.22 11:21, David Hildenbrand wrote:
> > On 18.03.22 21:29, Yang Shi wrote:
> >> On Thu, Mar 17, 2022 at 2:06 AM David Hildenbrand <david@redhat.com> wrote:
> >>>
> >>> On 16.03.22 22:23, Yang Shi wrote:
> >>>> On Tue, Mar 15, 2022 at 3:52 AM David Hildenbrand <david@redhat.com> wrote:
> >>>>>
> >>>>> Let's mark exclusively mapped anonymous pages with PG_anon_exclusive as
> >>>>> exclusive, and use that information to make GUP pins reliable and stay
> >>>>> consistent with the page mapped into the page table even if the
> >>>>> page table entry gets write-protected.
> >>>>>
> >>>>> With that information at hand, we can extend our COW logic to always
> >>>>> reuse anonymous pages that are exclusive. For anonymous pages that
> >>>>> might be shared, the existing logic applies.
> >>>>>
> >>>>> As already documented, PG_anon_exclusive is usually only expressive in
> >>>>> combination with a page table entry. Especially PTE vs. PMD-mapped
> >>>>> anonymous pages require more thought, some examples: due to mremap() we
> >>>>> can easily have a single compound page PTE-mapped into multiple page tables
> >>>>> exclusively in a single process -- multiple page table locks apply.
> >>>>> Further, due to MADV_WIPEONFORK we might not necessarily write-protect
> >>>>> all PTEs, and only some subpages might be pinned. Long story short: once
> >>>>> PTE-mapped, we have to track information about exclusivity per sub-page,
> >>>>> but until then, we can just track it for the compound page in the head
> >>>>> page and not having to update a whole bunch of subpages all of the time
> >>>>> for a simple PMD mapping of a THP.
> >>>>>
> >>>>> For simplicity, this commit mostly talks about "anonymous pages", while
> >>>>> it's for THP actually "the part of an anonymous folio referenced via
> >>>>> a page table entry".
> >>>>>
> >>>>> To not spill PG_anon_exclusive code all over the mm code-base, we let
> >>>>> the anon rmap code to handle all PG_anon_exclusive logic it can easily
> >>>>> handle.
> >>>>>
> >>>>> If a writable, present page table entry points at an anonymous (sub)page,
> >>>>> that (sub)page must be PG_anon_exclusive. If GUP wants to take a reliably
> >>>>> pin (FOLL_PIN) on an anonymous page references via a present
> >>>>> page table entry, it must only pin if PG_anon_exclusive is set for the
> >>>>> mapped (sub)page.
> >>>>>
> >>>>> This commit doesn't adjust GUP, so this is only implicitly handled for
> >>>>> FOLL_WRITE, follow-up commits will teach GUP to also respect it for
> >>>>> FOLL_PIN without !FOLL_WRITE, to make all GUP pins of anonymous pages
> >>>>> fully reliable.
> >>>>>
> >>>>> Whenever an anonymous page is to be shared (fork(), KSM), or when
> >>>>> temporarily unmapping an anonymous page (swap, migration), the relevant
> >>>>> PG_anon_exclusive bit has to be cleared to mark the anonymous page
> >>>>> possibly shared. Clearing will fail if there are GUP pins on the page:
> >>>>> * For fork(), this means having to copy the page and not being able to
> >>>>>   share it. fork() protects against concurrent GUP using the PT lock and
> >>>>>   the src_mm->write_protect_seq.
> >>>>> * For KSM, this means sharing will fail. For swap this means, unmapping
> >>>>>   will fail, For migration this means, migration will fail early. All
> >>>>>   three cases protect against concurrent GUP using the PT lock and a
> >>>>>   proper clear/invalidate+flush of the relevant page table entry.
> >>>>>
> >>>>> This fixes memory corruptions reported for FOLL_PIN | FOLL_WRITE, when a
> >>>>> pinned page gets mapped R/O and the successive write fault ends up
> >>>>> replacing the page instead of reusing it. It improves the situation for
> >>>>> O_DIRECT/vmsplice/... that still use FOLL_GET instead of FOLL_PIN,
> >>>>> if fork() is *not* involved, however swapout and fork() are still
> >>>>> problematic. Properly using FOLL_PIN instead of FOLL_GET for these
> >>>>> GUP users will fix the issue for them.
> >>>>>
> >>>>> I. Details about basic handling
> >>>>>
> >>>>> I.1. Fresh anonymous pages
> >>>>>
> >>>>> page_add_new_anon_rmap() and hugepage_add_new_anon_rmap() will mark the
> >>>>> given page exclusive via __page_set_anon_rmap(exclusive=1). As that is
> >>>>> the mechanism fresh anonymous pages come into life (besides migration
> >>>>> code where we copy the page->mapping), all fresh anonymous pages will
> >>>>> start out as exclusive.
> >>>>>
> >>>>> I.2. COW reuse handling of anonymous pages
> >>>>>
> >>>>> When a COW handler stumbles over a (sub)page that's marked exclusive, it
> >>>>> simply reuses it. Otherwise, the handler tries harder under page lock to
> >>>>> detect if the (sub)page is exclusive and can be reused. If exclusive,
> >>>>> page_move_anon_rmap() will mark the given (sub)page exclusive.
> >>>>>
> >>>>> Note that hugetlb code does not yet check for PageAnonExclusive(), as it
> >>>>> still uses the old COW logic that is prone to the COW security issue
> >>>>> because hugetlb code cannot really tolerate unnecessary/wrong COW as
> >>>>> huge pages are a scarce resource.
> >>>>>
> >>>>> I.3. Migration handling
> >>>>>
> >>>>> try_to_migrate() has to try marking an exclusive anonymous page shared
> >>>>> via page_try_share_anon_rmap(). If it fails because there are GUP pins
> >>>>> on the page, unmap fails. migrate_vma_collect_pmd() and
> >>>>> __split_huge_pmd_locked() are handled similarly.
> >>>>>
> >>>>> Writable migration entries implicitly point at shared anonymous pages.
> >>>>> For readable migration entries that information is stored via a new
> >>>>> "readable-exclusive" migration entry, specific to anonymous pages.
> >>>>>
> >>>>> When restoring a migration entry in remove_migration_pte(), information
> >>>>> about exlusivity is detected via the migration entry type, and
> >>>>> RMAP_EXCLUSIVE is set accordingly for
> >>>>> page_add_anon_rmap()/hugepage_add_anon_rmap() to restore that
> >>>>> information.
> >>>>>
> >>>>> I.4. Swapout handling
> >>>>>
> >>>>> try_to_unmap() has to try marking the mapped page possibly shared via
> >>>>> page_try_share_anon_rmap(). If it fails because there are GUP pins on the
> >>>>> page, unmap fails. For now, information about exclusivity is lost. In the
> >>>>> future, we might want to remember that information in the swap entry in
> >>>>> some cases, however, it requires more thought, care, and a way to store
> >>>>> that information in swap entries.
> >>>>>
> >>>>> I.5. Swapin handling
> >>>>>
> >>>>> do_swap_page() will never stumble over exclusive anonymous pages in the
> >>>>> swap cache, as try_to_migrate() prohibits that. do_swap_page() always has
> >>>>> to detect manually if an anonymous page is exclusive and has to set
> >>>>> RMAP_EXCLUSIVE for page_add_anon_rmap() accordingly.
> >>>>>
> >>>>> I.6. THP handling
> >>>>>
> >>>>> __split_huge_pmd_locked() has to move the information about exclusivity
> >>>>> from the PMD to the PTEs.
> >>>>>
> >>>>> a) In case we have a readable-exclusive PMD migration entry, simply insert
> >>>>> readable-exclusive PTE migration entries.
> >>>>>
> >>>>> b) In case we have a present PMD entry and we don't want to freeze
> >>>>> ("convert to migration entries"), simply forward PG_anon_exclusive to
> >>>>> all sub-pages, no need to temporarily clear the bit.
> >>>>>
> >>>>> c) In case we have a present PMD entry and want to freeze, handle it
> >>>>> similar to try_to_migrate(): try marking the page shared first. In case
> >>>>> we fail, we ignore the "freeze" instruction and simply split ordinarily.
> >>>>> try_to_migrate() will properly fail because the THP is still mapped via
> >>>>> PTEs.
> >>>
> >>> Hi,
> >>>
> >>> thanks for the review!
> >>>
> >>>>
> >>>> How come will try_to_migrate() fail? The afterward pvmw will find
> >>>> those PTEs then convert them to migration entries anyway IIUC.
> >>>>
> >>>
> >>> It will run into that code:
> >>>
> >>>>> @@ -1903,6 +1938,15 @@ static bool try_to_migrate_one(struct page *page, struct vm_area_struct *vma,
> >>>>>                                 page_vma_mapped_walk_done(&pvmw);
> >>>>>                                 break;
> >>>>>                         }
> >>>>> +                       VM_BUG_ON_PAGE(pte_write(pteval) && PageAnon(page) &&
> >>>>> +                                      !anon_exclusive, page);
> >>>>> +                       if (anon_exclusive &&
> >>>>> +                           page_try_share_anon_rmap(subpage)) {
> >>>>> +                               set_pte_at(mm, address, pvmw.pte, pteval);
> >>>>> +                               ret = false;
> >>>>> +                               page_vma_mapped_walk_done(&pvmw);
> >>>>> +                               break;
> >>>>> +                       }
> >>>
> >>> and similarly fail the page_try_share_anon_rmap(), at which point
> >>> try_to_migrate() stops and the caller will still observe a
> >>> "page_mapped() == true".
> >>
> >> Thanks, I missed that. Yes, the page will still be mapped. This should
> >> trigger the VM_WARN_ON_ONCE in unmap_page(), if this change will make
> >> this happen more often, we may consider removing that warning even
> >> though it is "once" since seeing a mapped page may become a normal
> >> case (once DIO is switched to FOLL_PIN, it may be more often). Anyway
> >> we don't have to remove it right now.
> >
> > Oh, very good catch! I wasn't able to trigger that warning in my testing
> > so far. Interestingly, arch_unmap_one() could theoretically make this
> > fail already and trigger the warning.
> >
> > Apart from that warning, split_huge_page_to_list() should work as
> > expected: freezing the refcount will fail if still mapped and we'll remap.
> >
> > I'll include a separate patch to just remove that VM_WARN_ON_ONCE -- thanks!
> >
>
> From e6e983d841cd2aa2a9c8dc71779211881cf0d96f Mon Sep 17 00:00:00 2001
> From: David Hildenbrand <david@redhat.com>
> Date: Sat, 19 Mar 2022 11:49:39 +0100
> Subject: [PATCH] mm/huge_memory: remove outdated VM_WARN_ON_ONCE_PAGE from
>  unmap_page()
>
> We can already theoretically fail to unmap (still having page_mapped()) in
> case arch_unmap_one() fails. Although this applies only to anonymous pages
> for now, get rid of the VM_WARN_ON_ONCE_PAGE() completely: the caller --
> split_huge_page_to_list() -- will fail to freeze the refcount and
> remap the page via remap_page(). So the caller can handle unmap errors
> just fine.
>
> This is a preparation for making try_to_migrate() fail on anonymous pages
> with GUP pins.

Better to mention "making try_to_migrate() fail on pinned anonymous
pages may make this happen more usual".

>
> Reported-by: Yang Shi <shy828301@gmail.com>
> Signed-off-by: David Hildenbrand <david@redhat.com>

Fine to me. Reviewed-by: Yang Shi <shy828301@gmail.com>

> ---
>  mm/huge_memory.c | 2 --
>  1 file changed, 2 deletions(-)
>
> diff --git a/mm/huge_memory.c b/mm/huge_memory.c
> index 0b6fb409b9e4..0fe0ab3ec3fc 100644
> --- a/mm/huge_memory.c
> +++ b/mm/huge_memory.c
> @@ -2263,8 +2263,6 @@ static void unmap_page(struct page *page)
>                 try_to_migrate(page, ttu_flags);
>         else
>                 try_to_unmap(page, ttu_flags | TTU_IGNORE_MLOCK);
> -
> -       VM_WARN_ON_ONCE_PAGE(page_mapped(page), page);
>  }
>
>  static void remap_page(struct page *page, unsigned int nr)
> --
> 2.35.1
>
>
> --
> Thanks,
>
> David / dhildenb
>

Re: [PATCH v2 11/15] mm: remember exclusively mapped anonymous pages with PG_anon_exclusive

[David Hildenbrand]

On 21.03.22 21:56, Yang Shi wrote:
> On Sat, Mar 19, 2022 at 3:50 AM David Hildenbrand <david@redhat.com> wrote:
>>
>> On 19.03.22 11:21, David Hildenbrand wrote:
>>> On 18.03.22 21:29, Yang Shi wrote:
>>>> On Thu, Mar 17, 2022 at 2:06 AM David Hildenbrand <david@redhat.com> wrote:
>>>>>
>>>>> On 16.03.22 22:23, Yang Shi wrote:
>>>>>> On Tue, Mar 15, 2022 at 3:52 AM David Hildenbrand <david@redhat.com> wrote:
>>>>>>>
>>>>>>> Let's mark exclusively mapped anonymous pages with PG_anon_exclusive as
>>>>>>> exclusive, and use that information to make GUP pins reliable and stay
>>>>>>> consistent with the page mapped into the page table even if the
>>>>>>> page table entry gets write-protected.
>>>>>>>
>>>>>>> With that information at hand, we can extend our COW logic to always
>>>>>>> reuse anonymous pages that are exclusive. For anonymous pages that
>>>>>>> might be shared, the existing logic applies.
>>>>>>>
>>>>>>> As already documented, PG_anon_exclusive is usually only expressive in
>>>>>>> combination with a page table entry. Especially PTE vs. PMD-mapped
>>>>>>> anonymous pages require more thought, some examples: due to mremap() we
>>>>>>> can easily have a single compound page PTE-mapped into multiple page tables
>>>>>>> exclusively in a single process -- multiple page table locks apply.
>>>>>>> Further, due to MADV_WIPEONFORK we might not necessarily write-protect
>>>>>>> all PTEs, and only some subpages might be pinned. Long story short: once
>>>>>>> PTE-mapped, we have to track information about exclusivity per sub-page,
>>>>>>> but until then, we can just track it for the compound page in the head
>>>>>>> page and not having to update a whole bunch of subpages all of the time
>>>>>>> for a simple PMD mapping of a THP.
>>>>>>>
>>>>>>> For simplicity, this commit mostly talks about "anonymous pages", while
>>>>>>> it's for THP actually "the part of an anonymous folio referenced via
>>>>>>> a page table entry".
>>>>>>>
>>>>>>> To not spill PG_anon_exclusive code all over the mm code-base, we let
>>>>>>> the anon rmap code to handle all PG_anon_exclusive logic it can easily
>>>>>>> handle.
>>>>>>>
>>>>>>> If a writable, present page table entry points at an anonymous (sub)page,
>>>>>>> that (sub)page must be PG_anon_exclusive. If GUP wants to take a reliably
>>>>>>> pin (FOLL_PIN) on an anonymous page references via a present
>>>>>>> page table entry, it must only pin if PG_anon_exclusive is set for the
>>>>>>> mapped (sub)page.
>>>>>>>
>>>>>>> This commit doesn't adjust GUP, so this is only implicitly handled for
>>>>>>> FOLL_WRITE, follow-up commits will teach GUP to also respect it for
>>>>>>> FOLL_PIN without !FOLL_WRITE, to make all GUP pins of anonymous pages
>>>>>>> fully reliable.
>>>>>>>
>>>>>>> Whenever an anonymous page is to be shared (fork(), KSM), or when
>>>>>>> temporarily unmapping an anonymous page (swap, migration), the relevant
>>>>>>> PG_anon_exclusive bit has to be cleared to mark the anonymous page
>>>>>>> possibly shared. Clearing will fail if there are GUP pins on the page:
>>>>>>> * For fork(), this means having to copy the page and not being able to
>>>>>>>   share it. fork() protects against concurrent GUP using the PT lock and
>>>>>>>   the src_mm->write_protect_seq.
>>>>>>> * For KSM, this means sharing will fail. For swap this means, unmapping
>>>>>>>   will fail, For migration this means, migration will fail early. All
>>>>>>>   three cases protect against concurrent GUP using the PT lock and a
>>>>>>>   proper clear/invalidate+flush of the relevant page table entry.
>>>>>>>
>>>>>>> This fixes memory corruptions reported for FOLL_PIN | FOLL_WRITE, when a
>>>>>>> pinned page gets mapped R/O and the successive write fault ends up
>>>>>>> replacing the page instead of reusing it. It improves the situation for
>>>>>>> O_DIRECT/vmsplice/... that still use FOLL_GET instead of FOLL_PIN,
>>>>>>> if fork() is *not* involved, however swapout and fork() are still
>>>>>>> problematic. Properly using FOLL_PIN instead of FOLL_GET for these
>>>>>>> GUP users will fix the issue for them.
>>>>>>>
>>>>>>> I. Details about basic handling
>>>>>>>
>>>>>>> I.1. Fresh anonymous pages
>>>>>>>
>>>>>>> page_add_new_anon_rmap() and hugepage_add_new_anon_rmap() will mark the
>>>>>>> given page exclusive via __page_set_anon_rmap(exclusive=1). As that is
>>>>>>> the mechanism fresh anonymous pages come into life (besides migration
>>>>>>> code where we copy the page->mapping), all fresh anonymous pages will
>>>>>>> start out as exclusive.
>>>>>>>
>>>>>>> I.2. COW reuse handling of anonymous pages
>>>>>>>
>>>>>>> When a COW handler stumbles over a (sub)page that's marked exclusive, it
>>>>>>> simply reuses it. Otherwise, the handler tries harder under page lock to
>>>>>>> detect if the (sub)page is exclusive and can be reused. If exclusive,
>>>>>>> page_move_anon_rmap() will mark the given (sub)page exclusive.
>>>>>>>
>>>>>>> Note that hugetlb code does not yet check for PageAnonExclusive(), as it
>>>>>>> still uses the old COW logic that is prone to the COW security issue
>>>>>>> because hugetlb code cannot really tolerate unnecessary/wrong COW as
>>>>>>> huge pages are a scarce resource.
>>>>>>>
>>>>>>> I.3. Migration handling
>>>>>>>
>>>>>>> try_to_migrate() has to try marking an exclusive anonymous page shared
>>>>>>> via page_try_share_anon_rmap(). If it fails because there are GUP pins
>>>>>>> on the page, unmap fails. migrate_vma_collect_pmd() and
>>>>>>> __split_huge_pmd_locked() are handled similarly.
>>>>>>>
>>>>>>> Writable migration entries implicitly point at shared anonymous pages.
>>>>>>> For readable migration entries that information is stored via a new
>>>>>>> "readable-exclusive" migration entry, specific to anonymous pages.
>>>>>>>
>>>>>>> When restoring a migration entry in remove_migration_pte(), information
>>>>>>> about exlusivity is detected via the migration entry type, and
>>>>>>> RMAP_EXCLUSIVE is set accordingly for
>>>>>>> page_add_anon_rmap()/hugepage_add_anon_rmap() to restore that
>>>>>>> information.
>>>>>>>
>>>>>>> I.4. Swapout handling
>>>>>>>
>>>>>>> try_to_unmap() has to try marking the mapped page possibly shared via
>>>>>>> page_try_share_anon_rmap(). If it fails because there are GUP pins on the
>>>>>>> page, unmap fails. For now, information about exclusivity is lost. In the
>>>>>>> future, we might want to remember that information in the swap entry in
>>>>>>> some cases, however, it requires more thought, care, and a way to store
>>>>>>> that information in swap entries.
>>>>>>>
>>>>>>> I.5. Swapin handling
>>>>>>>
>>>>>>> do_swap_page() will never stumble over exclusive anonymous pages in the
>>>>>>> swap cache, as try_to_migrate() prohibits that. do_swap_page() always has
>>>>>>> to detect manually if an anonymous page is exclusive and has to set
>>>>>>> RMAP_EXCLUSIVE for page_add_anon_rmap() accordingly.
>>>>>>>
>>>>>>> I.6. THP handling
>>>>>>>
>>>>>>> __split_huge_pmd_locked() has to move the information about exclusivity
>>>>>>> from the PMD to the PTEs.
>>>>>>>
>>>>>>> a) In case we have a readable-exclusive PMD migration entry, simply insert
>>>>>>> readable-exclusive PTE migration entries.
>>>>>>>
>>>>>>> b) In case we have a present PMD entry and we don't want to freeze
>>>>>>> ("convert to migration entries"), simply forward PG_anon_exclusive to
>>>>>>> all sub-pages, no need to temporarily clear the bit.
>>>>>>>
>>>>>>> c) In case we have a present PMD entry and want to freeze, handle it
>>>>>>> similar to try_to_migrate(): try marking the page shared first. In case
>>>>>>> we fail, we ignore the "freeze" instruction and simply split ordinarily.
>>>>>>> try_to_migrate() will properly fail because the THP is still mapped via
>>>>>>> PTEs.
>>>>>
>>>>> Hi,
>>>>>
>>>>> thanks for the review!
>>>>>
>>>>>>
>>>>>> How come will try_to_migrate() fail? The afterward pvmw will find
>>>>>> those PTEs then convert them to migration entries anyway IIUC.
>>>>>>
>>>>>
>>>>> It will run into that code:
>>>>>
>>>>>>> @@ -1903,6 +1938,15 @@ static bool try_to_migrate_one(struct page *page, struct vm_area_struct *vma,
>>>>>>>                                 page_vma_mapped_walk_done(&pvmw);
>>>>>>>                                 break;
>>>>>>>                         }
>>>>>>> +                       VM_BUG_ON_PAGE(pte_write(pteval) && PageAnon(page) &&
>>>>>>> +                                      !anon_exclusive, page);
>>>>>>> +                       if (anon_exclusive &&
>>>>>>> +                           page_try_share_anon_rmap(subpage)) {
>>>>>>> +                               set_pte_at(mm, address, pvmw.pte, pteval);
>>>>>>> +                               ret = false;
>>>>>>> +                               page_vma_mapped_walk_done(&pvmw);
>>>>>>> +                               break;
>>>>>>> +                       }
>>>>>
>>>>> and similarly fail the page_try_share_anon_rmap(), at which point
>>>>> try_to_migrate() stops and the caller will still observe a
>>>>> "page_mapped() == true".
>>>>
>>>> Thanks, I missed that. Yes, the page will still be mapped. This should
>>>> trigger the VM_WARN_ON_ONCE in unmap_page(), if this change will make
>>>> this happen more often, we may consider removing that warning even
>>>> though it is "once" since seeing a mapped page may become a normal
>>>> case (once DIO is switched to FOLL_PIN, it may be more often). Anyway
>>>> we don't have to remove it right now.
>>>
>>> Oh, very good catch! I wasn't able to trigger that warning in my testing
>>> so far. Interestingly, arch_unmap_one() could theoretically make this
>>> fail already and trigger the warning.
>>>
>>> Apart from that warning, split_huge_page_to_list() should work as
>>> expected: freezing the refcount will fail if still mapped and we'll remap.
>>>
>>> I'll include a separate patch to just remove that VM_WARN_ON_ONCE -- thanks!
>>>
>>
>> From e6e983d841cd2aa2a9c8dc71779211881cf0d96f Mon Sep 17 00:00:00 2001
>> From: David Hildenbrand <david@redhat.com>
>> Date: Sat, 19 Mar 2022 11:49:39 +0100
>> Subject: [PATCH] mm/huge_memory: remove outdated VM_WARN_ON_ONCE_PAGE from
>>  unmap_page()
>>
>> We can already theoretically fail to unmap (still having page_mapped()) in
>> case arch_unmap_one() fails. Although this applies only to anonymous pages
>> for now, get rid of the VM_WARN_ON_ONCE_PAGE() completely: the caller --
>> split_huge_page_to_list() -- will fail to freeze the refcount and
>> remap the page via remap_page(). So the caller can handle unmap errors
>> just fine.
>>
>> This is a preparation for making try_to_migrate() fail on anonymous pages
>> with GUP pins.
> 
> Better to mention "making try_to_migrate() fail on pinned anonymous
> pages may make this happen more usual".
> 
>>
>> Reported-by: Yang Shi <shy828301@gmail.com>
>> Signed-off-by: David Hildenbrand <david@redhat.com>
> 
> Fine to me. Reviewed-by: Yang Shi <shy828301@gmail.com>

Thanks, updated patch:

From 4f68aa1067e43caa370a62b930094a4d07492f92 Mon Sep 17 00:00:00 2001
From: David Hildenbrand <david@redhat.com>
Date: Sat, 19 Mar 2022 11:49:39 +0100
Subject: [PATCH] mm/huge_memory: remove outdated VM_WARN_ON_ONCE_PAGE from
 unmap_page()

We can already theoretically fail to unmap (still having page_mapped()) in
case arch_unmap_one() fails, which can happen on sparc. Failures to
unmap are handled gracefully, just as if there are other references on
the target page: freezing the refcount in split_huge_page_to_list()
will fail if still mapped and we'll simply remap.

In commit 504e070dc08f ("mm: thp: replace DEBUG_VM BUG with VM_WARN when
unmap fails for split") we already converted to VM_WARN_ON_ONCE_PAGE,
let's get rid of it completely now.

This is a preparation for making try_to_migrate() fail on anonymous pages
with GUP pins, which will make this VM_WARN_ON_ONCE_PAGE trigger more
frequently.

Reported-by: Yang Shi <shy828301@gmail.com>
Reviewed-by: Yang Shi <shy828301@gmail.com>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
 mm/huge_memory.c | 2 --
 1 file changed, 2 deletions(-)

diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index 0b6fb409b9e4..0fe0ab3ec3fc 100644
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -2263,8 +2263,6 @@ static void unmap_page(struct page *page)
 		try_to_migrate(page, ttu_flags);
 	else
 		try_to_unmap(page, ttu_flags | TTU_IGNORE_MLOCK);
-
-	VM_WARN_ON_ONCE_PAGE(page_mapped(page), page);
 }
 
 static void remap_page(struct page *page, unsigned int nr)
-- 
2.35.1



-- 
Thanks,

David / dhildenb

Re: [PATCH v2 01/15] mm/rmap: fix missing swap_free() in try_to_unmap() after arch_unmap_one() failed

[David Hildenbrand]

On 15.03.22 11:47, David Hildenbrand wrote:
> In case arch_unmap_one() fails, we already did a swap_duplicate(). let's
> undo that properly via swap_free().
> 
> Fixes: ca827d55ebaa ("mm, swap: Add infrastructure for saving page metadata on swap")
> Reviewed-by: Khalid Aziz <khalid.aziz@oracle.com>
> Signed-off-by: David Hildenbrand <david@redhat.com>
> ---
>  mm/rmap.c | 1 +
>  1 file changed, 1 insertion(+)
> 
> diff --git a/mm/rmap.c b/mm/rmap.c
> index 6a1e8c7f6213..f825aeef61ca 100644
> --- a/mm/rmap.c
> +++ b/mm/rmap.c
> @@ -1625,6 +1625,7 @@ static bool try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
>  				break;
>  			}
>  			if (arch_unmap_one(mm, vma, address, pteval) < 0) {
> +				swap_free(entry);
>  				set_pte_at(mm, address, pvmw.pte, pteval);
>  				ret = false;
>  				page_vma_mapped_walk_done(&pvmw);

Hi Khalid,

I'm a bit confused about the semantics if arch_unmap_one(), I hope you can clarify.


See patch #11 in this series, were we can fail unmapping after arch_unmap_one() succeeded. E.g., 

@@ -1623,6 +1634,24 @@ static bool try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
 				page_vma_mapped_walk_done(&pvmw);
 				break;
 			}
+			if (anon_exclusive &&
+			    page_try_share_anon_rmap(subpage)) {
+				swap_free(entry);
+				set_pte_at(mm, address, pvmw.pte, pteval);
+				ret = false;
+				page_vma_mapped_walk_done(&pvmw);
+				break;
+			}
+			/*
+			 * Note: We don't remember yet if the page was mapped
+			 * exclusively in the swap entry, so swapin code has
+			 * to re-determine that manually and might detect the
+			 * page as possibly shared, for example, if there are
+			 * other references on the page or if the page is under
+			 * writeback. We made sure that there are no GUP pins
+			 * on the page that would rely on it, so for GUP pins
+			 * this is fine.
+			 */
 			if (list_empty(&mm->mmlist)) {
 				spin_lock(&mmlist_lock);
 				if (list_empty(&mm->mmlist))


For now, I was under the impression that we don't have to undo anything after
arch_unmap_one() succeeded, because we seem to not do anything for two
cases below. But looking into arch_unmap_one() and how it allocates stuff I do
wonder what we would actually want to do here -- I'd assume we'd want to
trigger the del_tag_store() somehow?

arch_unmap_one() calls adi_save_tags(), which allocates memory.
adi_restore_tags()->del_tag_store() reverts that operation and ends up
freeing memory conditionally; However, it's only
called from arch_do_swap_page().


Here is why I have to scratch my head:

a) arch_do_swap_page() is only called from do_swap_page(). We don't do anything similar
for mm/swapfile.c:unuse_pte(), aren't we missing something?

b) try_to_migrate_one() does the arch_unmap_one(), but who will do the
restore+free after migration succeeded or failed, aren't we missing something?


I assume that we won't be properly freeing the tag space in case of a), and won't
be properly restoring/migrating the tags in case of a) and b).


I'll send out v3 of this series today, and I'll keep ignoring arch_unmap_one()
for now, because I have no clue what to do and it looks incomplete already, unless
I am missing something important.

-- 
Thanks,

David / dhildenb

Re: [PATCH v2 01/15] mm/rmap: fix missing swap_free() in try_to_unmap() after arch_unmap_one() failed

[Khalid Aziz]

On 3/29/22 07:59, David Hildenbrand wrote:
> On 15.03.22 11:47, David Hildenbrand wrote:
>> In case arch_unmap_one() fails, we already did a swap_duplicate(). let's
>> undo that properly via swap_free().
>>
>> Fixes: ca827d55ebaa ("mm, swap: Add infrastructure for saving page metadata on swap")
>> Reviewed-by: Khalid Aziz <khalid.aziz@oracle.com>
>> Signed-off-by: David Hildenbrand <david@redhat.com>
>> ---
>>   mm/rmap.c | 1 +
>>   1 file changed, 1 insertion(+)
>>
>> diff --git a/mm/rmap.c b/mm/rmap.c
>> index 6a1e8c7f6213..f825aeef61ca 100644
>> --- a/mm/rmap.c
>> +++ b/mm/rmap.c
>> @@ -1625,6 +1625,7 @@ static bool try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
>>   				break;
>>   			}
>>   			if (arch_unmap_one(mm, vma, address, pteval) < 0) {
>> +				swap_free(entry);
>>   				set_pte_at(mm, address, pvmw.pte, pteval);
>>   				ret = false;
>>   				page_vma_mapped_walk_done(&pvmw);
> 
> Hi Khalid,
> 
> I'm a bit confused about the semantics if arch_unmap_one(), I hope you can clarify.
> 
> 
> See patch #11 in this series, were we can fail unmapping after arch_unmap_one() succeeded. E.g.,
> 
> @@ -1623,6 +1634,24 @@ static bool try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
>   				page_vma_mapped_walk_done(&pvmw);
>   				break;
>   			}
> +			if (anon_exclusive &&
> +			    page_try_share_anon_rmap(subpage)) {
> +				swap_free(entry);
> +				set_pte_at(mm, address, pvmw.pte, pteval);
> +				ret = false;
> +				page_vma_mapped_walk_done(&pvmw);
> +				break;
> +			}
> +			/*
> +			 * Note: We don't remember yet if the page was mapped
> +			 * exclusively in the swap entry, so swapin code has
> +			 * to re-determine that manually and might detect the
> +			 * page as possibly shared, for example, if there are
> +			 * other references on the page or if the page is under
> +			 * writeback. We made sure that there are no GUP pins
> +			 * on the page that would rely on it, so for GUP pins
> +			 * this is fine.
> +			 */
>   			if (list_empty(&mm->mmlist)) {
>   				spin_lock(&mmlist_lock);
>   				if (list_empty(&mm->mmlist))
> 
> 
> For now, I was under the impression that we don't have to undo anything after
> arch_unmap_one() succeeded, because we seem to not do anything for two
> cases below. But looking into arch_unmap_one() and how it allocates stuff I do
> wonder what we would actually want to do here -- I'd assume we'd want to
> trigger the del_tag_store() somehow?

Hi David,

Currently once arch_unmap_one() completes successfully, we are at the point of no return for this pte. It will be 
replaced by swap pte soon thereafter. Patch 11 adds another case where we may return without replacing current pte with 
swap pte. For now could you resolve this by moving the above code block in patch 11 to before the call to 
arch_unmap_one(). That still leaves open the issue having the flexibility of undoing what arch_unmap_one() does for some 
other reason in future. That will require coming up with a properly architected way to do it.

> 
> arch_unmap_one() calls adi_save_tags(), which allocates memory.
> adi_restore_tags()->del_tag_store() reverts that operation and ends up
> freeing memory conditionally; However, it's only
> called from arch_do_swap_page().
> 
> 
> Here is why I have to scratch my head:
> 
> a) arch_do_swap_page() is only called from do_swap_page(). We don't do anything similar
> for mm/swapfile.c:unuse_pte(), aren't we missing something?

My understanding of this code path maybe flawed, so do correct me if this does not sound right. unused_pte() is called 
upon user turning off swap on a device. unused_pte() is called by unused_pte_range() which swaps the page back in from 
swap device before calling unuse_pte(). Once the page is read back in from swap, ultimately access to the va for the 
page will result in call to __handle_mm_fault() which in turn will call handle_pte_fault() to insert a new pte for this 
mapping and handle_pte_fault() will call arch_do_swap_page() which will restore the tags.

> 
> b) try_to_migrate_one() does the arch_unmap_one(), but who will do the
> restore+free after migration succeeded or failed, aren't we missing something?

try_to_migrate_one() replaces the current pte with a migration pte after calling arch_unmap_one(). This causes 
__handle_mm_fault() to be called when a reference to the va covered by migration pte is made. This will in turn finally 
result in a call to arch_do_swap_page() which restores the tags.

> 
> 
> I assume that we won't be properly freeing the tag space in case of a), and won't
> be properly restoring/migrating the tags in case of a) and b).

I think both cases are covered correctly unless I am misunderstand the code.

--
Khalid

Re: [PATCH v2 01/15] mm/rmap: fix missing swap_free() in try_to_unmap() after arch_unmap_one() failed

[David Hildenbrand]

On 29.03.22 22:42, Khalid Aziz wrote:
> On 3/29/22 07:59, David Hildenbrand wrote:
>> On 15.03.22 11:47, David Hildenbrand wrote:
>>> In case arch_unmap_one() fails, we already did a swap_duplicate(). let's
>>> undo that properly via swap_free().
>>>
>>> Fixes: ca827d55ebaa ("mm, swap: Add infrastructure for saving page metadata on swap")
>>> Reviewed-by: Khalid Aziz <khalid.aziz@oracle.com>
>>> Signed-off-by: David Hildenbrand <david@redhat.com>
>>> ---
>>>   mm/rmap.c | 1 +
>>>   1 file changed, 1 insertion(+)
>>>
>>> diff --git a/mm/rmap.c b/mm/rmap.c
>>> index 6a1e8c7f6213..f825aeef61ca 100644
>>> --- a/mm/rmap.c
>>> +++ b/mm/rmap.c
>>> @@ -1625,6 +1625,7 @@ static bool try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
>>>   				break;
>>>   			}
>>>   			if (arch_unmap_one(mm, vma, address, pteval) < 0) {
>>> +				swap_free(entry);
>>>   				set_pte_at(mm, address, pvmw.pte, pteval);
>>>   				ret = false;
>>>   				page_vma_mapped_walk_done(&pvmw);
>>
>> Hi Khalid,
>>
>> I'm a bit confused about the semantics if arch_unmap_one(), I hope you can clarify.
>>
>>
>> See patch #11 in this series, were we can fail unmapping after arch_unmap_one() succeeded. E.g.,
>>
>> @@ -1623,6 +1634,24 @@ static bool try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
>>   				page_vma_mapped_walk_done(&pvmw);
>>   				break;
>>   			}
>> +			if (anon_exclusive &&
>> +			    page_try_share_anon_rmap(subpage)) {
>> +				swap_free(entry);
>> +				set_pte_at(mm, address, pvmw.pte, pteval);
>> +				ret = false;
>> +				page_vma_mapped_walk_done(&pvmw);
>> +				break;
>> +			}
>> +			/*
>> +			 * Note: We don't remember yet if the page was mapped
>> +			 * exclusively in the swap entry, so swapin code has
>> +			 * to re-determine that manually and might detect the
>> +			 * page as possibly shared, for example, if there are
>> +			 * other references on the page or if the page is under
>> +			 * writeback. We made sure that there are no GUP pins
>> +			 * on the page that would rely on it, so for GUP pins
>> +			 * this is fine.
>> +			 */
>>   			if (list_empty(&mm->mmlist)) {
>>   				spin_lock(&mmlist_lock);
>>   				if (list_empty(&mm->mmlist))
>>
>>
>> For now, I was under the impression that we don't have to undo anything after
>> arch_unmap_one() succeeded, because we seem to not do anything for two
>> cases below. But looking into arch_unmap_one() and how it allocates stuff I do
>> wonder what we would actually want to do here -- I'd assume we'd want to
>> trigger the del_tag_store() somehow?
> 
> Hi David,
> 

Hi,

thanks for your fast reply.

> Currently once arch_unmap_one() completes successfully, we are at the point of no return for this pte. It will be 
> replaced by swap pte soon thereafter. Patch 11 adds another case where we may return without replacing current pte with 
> swap pte. For now could you resolve this by moving the above code block in patch 11 to before the call to 
> arch_unmap_one(). That still leaves open the issue having the flexibility of undoing what arch_unmap_one() does for some 
> other reason in future. That will require coming up with a properly architected way to do it.

I really want clearing PG_anon_exclusive be the last action, without
eventually having to set it again and overcomplicating
PG_anon_exclusive/rmap handling. Ideally, we'd have a "arch_remap_one()"
that just reverts what arch_unmap_one() did.

> 
>>
>> arch_unmap_one() calls adi_save_tags(), which allocates memory.
>> adi_restore_tags()->del_tag_store() reverts that operation and ends up
>> freeing memory conditionally; However, it's only
>> called from arch_do_swap_page().
>>
>>
>> Here is why I have to scratch my head:
>>
>> a) arch_do_swap_page() is only called from do_swap_page(). We don't do anything similar
>> for mm/swapfile.c:unuse_pte(), aren't we missing something?
> 
> My understanding of this code path maybe flawed, so do correct me if this does not sound right. unused_pte() is called 
> upon user turning off swap on a device. unused_pte() is called by unused_pte_range() which swaps the page back in from 
> swap device before calling unuse_pte(). Once the page is read back in from swap, ultimately access to the va for the 
> page will result in call to __handle_mm_fault() which in turn will call handle_pte_fault() to insert a new pte for this 
> mapping and handle_pte_fault() will call arch_do_swap_page() which will restore the tags.

unuse_pte() will replace a swap pte directly by a proper, present pte,
just like do_swap_page() would. You won't end up in do_swap_page()
anymore and arch_do_swap_page() won't be called, because there is no
swap PTE anymore.

> 
>>
>> b) try_to_migrate_one() does the arch_unmap_one(), but who will do the
>> restore+free after migration succeeded or failed, aren't we missing something?
> 
> try_to_migrate_one() replaces the current pte with a migration pte after calling arch_unmap_one(). This causes 
> __handle_mm_fault() to be called when a reference to the va covered by migration pte is made. This will in turn finally 
> result in a call to arch_do_swap_page() which restores the tags.

Migration PTEs are restore via mm/migrate.c:remove_migration_ptes().
arch_do_swap_page() won't be called.

What you mention is if someone accesses the migration PTE while
migration is active and the migration PTEs have not been removed yet.
While we'll end up in do_swap_page(), we'll do a migration_entry_wait(),
followed by an effective immediate "return 0;". arch_do_swap_page()
won't get called.


So in essence, I think this doesn't work as expected yet. In the best
case we don't immediately free memory. In the worst case we lose the tags.

-- 
Thanks,

David / dhildenb

Re: [PATCH v2 01/15] mm/rmap: fix missing swap_free() in try_to_unmap() after arch_unmap_one() failed

[Khalid Aziz]

On 3/29/22 14:55, David Hildenbrand wrote:
> On 29.03.22 22:42, Khalid Aziz wrote:
>> On 3/29/22 07:59, David Hildenbrand wrote:
>>> On 15.03.22 11:47, David Hildenbrand wrote:
>>>> In case arch_unmap_one() fails, we already did a swap_duplicate(). let's
>>>> undo that properly via swap_free().
>>>>
>>>> Fixes: ca827d55ebaa ("mm, swap: Add infrastructure for saving page metadata on swap")
>>>> Reviewed-by: Khalid Aziz <khalid.aziz@oracle.com>
>>>> Signed-off-by: David Hildenbrand <david@redhat.com>
>>>> ---
>>>>    mm/rmap.c | 1 +
>>>>    1 file changed, 1 insertion(+)
>>>>
>>>> diff --git a/mm/rmap.c b/mm/rmap.c
>>>> index 6a1e8c7f6213..f825aeef61ca 100644
>>>> --- a/mm/rmap.c
>>>> +++ b/mm/rmap.c
>>>> @@ -1625,6 +1625,7 @@ static bool try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
>>>>    				break;
>>>>    			}
>>>>    			if (arch_unmap_one(mm, vma, address, pteval) < 0) {
>>>> +				swap_free(entry);
>>>>    				set_pte_at(mm, address, pvmw.pte, pteval);
>>>>    				ret = false;
>>>>    				page_vma_mapped_walk_done(&pvmw);
>>>
>>> Hi Khalid,
>>>
>>> I'm a bit confused about the semantics if arch_unmap_one(), I hope you can clarify.
>>>
>>>
>>> See patch #11 in this series, were we can fail unmapping after arch_unmap_one() succeeded. E.g.,
>>>
>>> @@ -1623,6 +1634,24 @@ static bool try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
>>>    				page_vma_mapped_walk_done(&pvmw);
>>>    				break;
>>>    			}
>>> +			if (anon_exclusive &&
>>> +			    page_try_share_anon_rmap(subpage)) {
>>> +				swap_free(entry);
>>> +				set_pte_at(mm, address, pvmw.pte, pteval);
>>> +				ret = false;
>>> +				page_vma_mapped_walk_done(&pvmw);
>>> +				break;
>>> +			}
>>> +			/*
>>> +			 * Note: We don't remember yet if the page was mapped
>>> +			 * exclusively in the swap entry, so swapin code has
>>> +			 * to re-determine that manually and might detect the
>>> +			 * page as possibly shared, for example, if there are
>>> +			 * other references on the page or if the page is under
>>> +			 * writeback. We made sure that there are no GUP pins
>>> +			 * on the page that would rely on it, so for GUP pins
>>> +			 * this is fine.
>>> +			 */
>>>    			if (list_empty(&mm->mmlist)) {
>>>    				spin_lock(&mmlist_lock);
>>>    				if (list_empty(&mm->mmlist))
>>>
>>>
>>> For now, I was under the impression that we don't have to undo anything after
>>> arch_unmap_one() succeeded, because we seem to not do anything for two
>>> cases below. But looking into arch_unmap_one() and how it allocates stuff I do
>>> wonder what we would actually want to do here -- I'd assume we'd want to
>>> trigger the del_tag_store() somehow?
>>
>> Hi David,
>>
> 
> Hi,
> 
> thanks for your fast reply.
> 
>> Currently once arch_unmap_one() completes successfully, we are at the point of no return for this pte. It will be
>> replaced by swap pte soon thereafter. Patch 11 adds another case where we may return without replacing current pte with
>> swap pte. For now could you resolve this by moving the above code block in patch 11 to before the call to
>> arch_unmap_one(). That still leaves open the issue having the flexibility of undoing what arch_unmap_one() does for some
>> other reason in future. That will require coming up with a properly architected way to do it.
> 
> I really want clearing PG_anon_exclusive be the last action, without
> eventually having to set it again and overcomplicating
> PG_anon_exclusive/rmap handling. Ideally, we'd have a "arch_remap_one()"
> that just reverts what arch_unmap_one() did.

Hi David,

arch_remap_one() sounds reasonable. Would you like to add that in your patch series, or would you like me to create a 
separate patch for adding this on top of your patch series?

> 
>>
>>>
>>> arch_unmap_one() calls adi_save_tags(), which allocates memory.
>>> adi_restore_tags()->del_tag_store() reverts that operation and ends up
>>> freeing memory conditionally; However, it's only
>>> called from arch_do_swap_page().
>>>
>>>
>>> Here is why I have to scratch my head:
>>>
>>> a) arch_do_swap_page() is only called from do_swap_page(). We don't do anything similar
>>> for mm/swapfile.c:unuse_pte(), aren't we missing something?
>>
>> My understanding of this code path maybe flawed, so do correct me if this does not sound right. unused_pte() is called
>> upon user turning off swap on a device. unused_pte() is called by unused_pte_range() which swaps the page back in from
>> swap device before calling unuse_pte(). Once the page is read back in from swap, ultimately access to the va for the
>> page will result in call to __handle_mm_fault() which in turn will call handle_pte_fault() to insert a new pte for this
>> mapping and handle_pte_fault() will call arch_do_swap_page() which will restore the tags.
> 
> unuse_pte() will replace a swap pte directly by a proper, present pte,
> just like do_swap_page() would. You won't end up in do_swap_page()
> anymore and arch_do_swap_page() won't be called, because there is no
> swap PTE anymore.
> 
>>
>>>
>>> b) try_to_migrate_one() does the arch_unmap_one(), but who will do the
>>> restore+free after migration succeeded or failed, aren't we missing something?
>>
>> try_to_migrate_one() replaces the current pte with a migration pte after calling arch_unmap_one(). This causes
>> __handle_mm_fault() to be called when a reference to the va covered by migration pte is made. This will in turn finally
>> result in a call to arch_do_swap_page() which restores the tags.
> 
> Migration PTEs are restore via mm/migrate.c:remove_migration_ptes().
> arch_do_swap_page() won't be called.
> 
> What you mention is if someone accesses the migration PTE while
> migration is active and the migration PTEs have not been removed yet.
> While we'll end up in do_swap_page(), we'll do a migration_entry_wait(),
> followed by an effective immediate "return 0;". arch_do_swap_page()
> won't get called.
> 
> 
> So in essence, I think this doesn't work as expected yet. In the best
> case we don't immediately free memory. In the worst case we lose the tags.
> 

I see what you mean. I can work on fixing these issues up.

Thanks,
Khalid

Re: [PATCH v2 01/15] mm/rmap: fix missing swap_free() in try_to_unmap() after arch_unmap_one() failed

[David Hildenbrand]

> Hi David,

Hi,

> 
> arch_remap_one() sounds reasonable. Would you like to add that in your patch series, or would you like me to create a 
> separate patch for adding this on top of your patch series?

Let's handle it separately, because I think there is still a lot to be
clarified. I also feel like the terminology ("arch_unmap_one()") is a
little too generic, if we really only care about anonymous pages (do we?).

> 
>>
>>>
>>>>
>>>> arch_unmap_one() calls adi_save_tags(), which allocates memory.
>>>> adi_restore_tags()->del_tag_store() reverts that operation and ends up
>>>> freeing memory conditionally; However, it's only
>>>> called from arch_do_swap_page().
>>>>
>>>>
>>>> Here is why I have to scratch my head:
>>>>
>>>> a) arch_do_swap_page() is only called from do_swap_page(). We don't do anything similar
>>>> for mm/swapfile.c:unuse_pte(), aren't we missing something?
>>>
>>> My understanding of this code path maybe flawed, so do correct me if this does not sound right. unused_pte() is called
>>> upon user turning off swap on a device. unused_pte() is called by unused_pte_range() which swaps the page back in from
>>> swap device before calling unuse_pte(). Once the page is read back in from swap, ultimately access to the va for the
>>> page will result in call to __handle_mm_fault() which in turn will call handle_pte_fault() to insert a new pte for this
>>> mapping and handle_pte_fault() will call arch_do_swap_page() which will restore the tags.
>>
>> unuse_pte() will replace a swap pte directly by a proper, present pte,
>> just like do_swap_page() would. You won't end up in do_swap_page()
>> anymore and arch_do_swap_page() won't be called, because there is no
>> swap PTE anymore.
>>
>>>
>>>>
>>>> b) try_to_migrate_one() does the arch_unmap_one(), but who will do the
>>>> restore+free after migration succeeded or failed, aren't we missing something?
>>>
>>> try_to_migrate_one() replaces the current pte with a migration pte after calling arch_unmap_one(). This causes
>>> __handle_mm_fault() to be called when a reference to the va covered by migration pte is made. This will in turn finally
>>> result in a call to arch_do_swap_page() which restores the tags.
>>
>> Migration PTEs are restore via mm/migrate.c:remove_migration_ptes().
>> arch_do_swap_page() won't be called.
>>
>> What you mention is if someone accesses the migration PTE while
>> migration is active and the migration PTEs have not been removed yet.
>> While we'll end up in do_swap_page(), we'll do a migration_entry_wait(),
>> followed by an effective immediate "return 0;". arch_do_swap_page()
>> won't get called.
>>
>>
>> So in essence, I think this doesn't work as expected yet. In the best
>> case we don't immediately free memory. In the worst case we lose the tags.
>>
> 
> I see what you mean. I can work on fixing these issues up.

Ideally, I think we'd handle migration differently: migrate the tags
directly instead of temporarily storing them

I also wonder, how to handle migration of THP (which uses migration
PMDs) and THP splitting (which also uses migration PTEs); maybe they
don't apply on sparc?

Further, I wonder if you have to handle zapping of swap/migration PTEs,
and if you'd also have to cleanup+freeup any allcoated tag memory?
E.g., zap_pte_range() can simply zap swap and migration entries, wouldn't

Last but not least, I do wonder if mremap() -- e.g., move_pte() -- and
fork() -- e.g., copy_pte_range() -- are handled properly, where we can
end up moving/copying swap+migration PTEs around.

-- 
Thanks,

David / dhildenb