Skip to contentSkip to conversation

mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types.patch removed from -mm tree

merged mm-stable Andrew Morton 1 participant 1 message Jun 17, 2022

lore
Share & tools
lore

Andrew Morton

author tree notice Applied
#0 lore raw

The quilt patch titled
Subject: mm: avoid unnecessary page fault retires on shared memory types
has been removed from the -mm tree. Its filename was
mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types.patch

This patch was dropped because it was merged into the mm-stable branch of git://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm

------------------------------------------------------
From: Peter Xu <[email protected]>
Subject: mm: avoid unnecessary page fault retires on shared memory types
Date: Mon, 30 May 2022 14:34:50 -0400

I observed that for each of the shared file-backed page faults, we're very likely to retry one more time for the 1st write fault upon no page. It's because we'll need to release the mmap lock for dirty rate limit purpose with balance_dirty_pages_ratelimited() (in fault_dirty_shared_page()).

Then after that throttling we return VM_FAULT_RETRY.

We did that probably because VM_FAULT_RETRY is the only way we can return to the fault handler at that time telling it we've released the mmap lock.

However that's not ideal because it's very likely the fault does not need to be retried at all since the pgtable was well installed before the throttling, so the next continuous fault (including taking mmap read lock, walk the pgtable, etc.) could be in most cases unnecessary.

It's not only slowing down page faults for shared file-backed, but also add more mmap lock contention which is in most cases not needed at all.

To observe this, one could try to write to some shmem page and look at "pgfault" value in /proc/vmstat, then we should expect 2 counts for each shmem write simply because we retried, and vm event "pgfault" will capture that.

To make it more efficient, add a new VM_FAULT_COMPLETED return code just to show that we've completed the whole fault and released the lock. It's also a hint that we should very possibly not need another fault immediately on this page because we've just completed it.

This patch provides a ~12% perf boost on my aarch64 test VM with a simple program sequentially dirtying 400MB shmem file being mmap()ed and these are the time it needs:

Before: 650.980 ms (+-1.94%)
After: 569.396 ms (+-1.38%)

I believe it could help more than that.

We need some special care on GUP and the s390 pgfault handler (for gmap code before returning from pgfault), the rest changes in the page fault handlers should be relatively straightforward.

Another thing to mention is that mm_account_fault() does take this new fault as a generic fault to be accounted, unlike VM_FAULT_RETRY.

I explicitly didn't touch hmm_vma_fault() and break_ksm() because they do not handle VM_FAULT_RETRY even with existing code, so I'm literally keeping them as-is.

Cc Vasily Gorbik <[email protected]>
Cc Stafford Horne <[email protected]>
Cc David S. Miller <[email protected]>
Cc Johannes Berg <[email protected]>
Cc Brian Cain <[email protected]>
Cc Richard Henderson <[email protected]>
Cc Richard Weinberger <[email protected]>
Cc Benjamin Herrenschmidt <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Janosch Frank <[email protected]>
Cc Albert Ou <[email protected]>
Cc Anton Ivanov <[email protected]>
Cc Dave Hansen <[email protected]>
Cc Borislav Petkov <[email protected]>
Cc Sven Schnelle <[email protected]>
Cc Andrea Arcangeli <[email protected]>
Cc James Bottomley <[email protected]>
Cc Al Viro <[email protected]>
Cc Alexander Gordeev <[email protected]>
Cc Jonas Bonn <[email protected]>
Cc Will Deacon <[email protected]>
Cc Vlastimil Babka <[email protected]>
Cc Michal Simek <[email protected]>
Cc Matt Turner <[email protected]>
Cc Paul Mackerras <[email protected]>
Cc David Hildenbrand <[email protected]>
Cc Nicholas Piggin <[email protected]>
Cc Palmer Dabbelt <[email protected]>
Cc Stefan Kristiansson <[email protected]>
Cc Paul Walmsley <[email protected]>
Cc Ivan Kokshaysky <[email protected]>
Cc Chris Zankel <[email protected]>
Cc Hugh Dickins <[email protected]>
Cc Dinh Nguyen <[email protected]>
Cc Rich Felker <[email protected]>
Cc H. Peter Anvin <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Thomas Bogendoerfer <[email protected]>
Cc Helge Deller <[email protected]>
Cc Yoshinori Sato <[email protected]>

---

 arch/alpha/mm/fault.c         |    4 +++
 arch/arc/mm/fault.c           |    4 +++
 arch/arm/mm/fault.c           |    4 +++
 arch/arm64/mm/fault.c         |    4 +++
 arch/csky/mm/fault.c          |    4 +++
 arch/hexagon/mm/vm_fault.c    |    4 +++
 arch/ia64/mm/fault.c          |    4 +++
 arch/m68k/mm/fault.c          |    4 +++
 arch/microblaze/mm/fault.c    |    4 +++
 arch/mips/mm/fault.c          |    4 +++
 arch/nios2/mm/fault.c         |    4 +++
 arch/openrisc/mm/fault.c      |    4 +++
 arch/parisc/mm/fault.c        |    4 +++
 arch/powerpc/mm/copro_fault.c |    5 ++++
 arch/powerpc/mm/fault.c       |    5 ++++
 arch/riscv/mm/fault.c         |    4 +++
 arch/s390/mm/fault.c          |   12 +++++++++++
 arch/sh/mm/fault.c            |    4 +++
 arch/sparc/mm/fault_32.c      |    4 +++
 arch/sparc/mm/fault_64.c      |    5 ++++
 arch/um/kernel/trap.c         |    4 +++
 arch/x86/mm/fault.c           |    4 +++
 arch/xtensa/mm/fault.c        |    4 +++
 include/linux/mm_types.h      |    2 +
 mm/gup.c                      |   34 +++++++++++++++++++++++++++++++-
 mm/memory.c                   |    2 -
 26 files changed, 139 insertions(+), 2 deletions(-)
arch/alpha/mm/fault.c renamed from arch/alpha/mm/fault.c~mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types +4 -0
@@ -155,6 +155,10 @@ retry:
 	if (fault_signal_pending(fault, regs))
 		return;
 
+	/* The fault is fully completed (including releasing mmap lock) */
+	if (fault & VM_FAULT_COMPLETED)
+		return;
+
 	if (unlikely(fault & VM_FAULT_ERROR)) {
 		if (fault & VM_FAULT_OOM)
 			goto out_of_memory;
arch/arc/mm/fault.c renamed from arch/arc/mm/fault.c~mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types +4 -0
@@ -146,6 +146,10 @@ retry:
 		return;
 	}
 
+	/* The fault is fully completed (including releasing mmap lock) */
+	if (fault & VM_FAULT_COMPLETED)
+		return;
+
 	/*
 	 * Fault retry nuances, mmap_lock already relinquished by core mm
 	 */
arch/arm64/mm/fault.c renamed from arch/arm64/mm/fault.c~mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types +4 -0
@@ -608,6 +608,10 @@ retry:
 		return 0;
 	}
 
+	/* The fault is fully completed (including releasing mmap lock) */
+	if (fault & VM_FAULT_COMPLETED)
+		return 0;
+
 	if (fault & VM_FAULT_RETRY) {
 		mm_flags |= FAULT_FLAG_TRIED;
 		goto retry;
arch/arm/mm/fault.c renamed from arch/arm/mm/fault.c~mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types +4 -0
@@ -322,6 +322,10 @@ retry:
 		return 0;
 	}
 
+	/* The fault is fully completed (including releasing mmap lock) */
+	if (fault & VM_FAULT_COMPLETED)
+		return 0;
+
 	if (!(fault & VM_FAULT_ERROR)) {
 		if (fault & VM_FAULT_RETRY) {
 			flags |= FAULT_FLAG_TRIED;
arch/csky/mm/fault.c renamed from arch/csky/mm/fault.c~mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types +4 -0
@@ -285,6 +285,10 @@ good_area:
 		return;
 	}
 
+	/* The fault is fully completed (including releasing mmap lock) */
+	if (fault & VM_FAULT_COMPLETED)
+		return;
+
 	if (unlikely((fault & VM_FAULT_RETRY) && (flags & FAULT_FLAG_ALLOW_RETRY))) {
 		flags |= FAULT_FLAG_TRIED;
 
arch/hexagon/mm/vm_fault.c renamed from arch/hexagon/mm/vm_fault.c~mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types +4 -0
@@ -96,6 +96,10 @@ good_area:
 	if (fault_signal_pending(fault, regs))
 		return;
 
+	/* The fault is fully completed (including releasing mmap lock) */
+	if (fault & VM_FAULT_COMPLETED)
+		return;
+
 	/* The most common case -- we are done. */
 	if (likely(!(fault & VM_FAULT_ERROR))) {
 		if (fault & VM_FAULT_RETRY) {
arch/ia64/mm/fault.c renamed from arch/ia64/mm/fault.c~mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types +4 -0
@@ -139,6 +139,10 @@ retry:
 	if (fault_signal_pending(fault, regs))
 		return;
 
+	/* The fault is fully completed (including releasing mmap lock) */
+	if (fault & VM_FAULT_COMPLETED)
+		return;
+
 	if (unlikely(fault & VM_FAULT_ERROR)) {
 		/*
 		 * We ran out of memory, or some other thing happened
arch/m68k/mm/fault.c renamed from arch/m68k/mm/fault.c~mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types +4 -0
@@ -141,6 +141,10 @@ good_area:
 	if (fault_signal_pending(fault, regs))
 		return 0;
 
+	/* The fault is fully completed (including releasing mmap lock) */
+	if (fault & VM_FAULT_COMPLETED)
+		return 0;
+
 	if (unlikely(fault & VM_FAULT_ERROR)) {
 		if (fault & VM_FAULT_OOM)
 			goto out_of_memory;
arch/microblaze/mm/fault.c renamed from arch/microblaze/mm/fault.c~mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types +4 -0
@@ -222,6 +222,10 @@ good_area:
 	if (fault_signal_pending(fault, regs))
 		return;
 
+	/* The fault is fully completed (including releasing mmap lock) */
+	if (fault & VM_FAULT_COMPLETED)
+		return;
+
 	if (unlikely(fault & VM_FAULT_ERROR)) {
 		if (fault & VM_FAULT_OOM)
 			goto out_of_memory;
arch/mips/mm/fault.c renamed from arch/mips/mm/fault.c~mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types +4 -0
@@ -162,6 +162,10 @@ good_area:
 		return;
 	}
 
+	/* The fault is fully completed (including releasing mmap lock) */
+	if (fault & VM_FAULT_COMPLETED)
+		return;
+
 	if (unlikely(fault & VM_FAULT_ERROR)) {
 		if (fault & VM_FAULT_OOM)
 			goto out_of_memory;
arch/nios2/mm/fault.c renamed from arch/nios2/mm/fault.c~mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types +4 -0
@@ -139,6 +139,10 @@ good_area:
 	if (fault_signal_pending(fault, regs))
 		return;
 
+	/* The fault is fully completed (including releasing mmap lock) */
+	if (fault & VM_FAULT_COMPLETED)
+		return;
+
 	if (unlikely(fault & VM_FAULT_ERROR)) {
 		if (fault & VM_FAULT_OOM)
 			goto out_of_memory;
arch/openrisc/mm/fault.c renamed from arch/openrisc/mm/fault.c~mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types +4 -0
@@ -165,6 +165,10 @@ good_area:
 	if (fault_signal_pending(fault, regs))
 		return;
 
+	/* The fault is fully completed (including releasing mmap lock) */
+	if (fault & VM_FAULT_COMPLETED)
+		return;
+
 	if (unlikely(fault & VM_FAULT_ERROR)) {
 		if (fault & VM_FAULT_OOM)
 			goto out_of_memory;
arch/parisc/mm/fault.c renamed from arch/parisc/mm/fault.c~mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types +4 -0
@@ -311,6 +311,10 @@ good_area:
 	if (fault_signal_pending(fault, regs))
 		return;
 
+	/* The fault is fully completed (including releasing mmap lock) */
+	if (fault & VM_FAULT_COMPLETED)
+		return;
+
 	if (unlikely(fault & VM_FAULT_ERROR)) {
 		/*
 		 * We hit a shared mapping outside of the file, or some
arch/powerpc/mm/copro_fault.c renamed from arch/powerpc/mm/copro_fault.c~mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types +5 -0
@@ -65,6 +65,11 @@ int copro_handle_mm_fault(struct mm_stru
 
 	ret = 0;
 	*flt = handle_mm_fault(vma, ea, is_write ? FAULT_FLAG_WRITE : 0, NULL);
+
+	/* The fault is fully completed (including releasing mmap lock) */
+	if (*flt & VM_FAULT_COMPLETED)
+		return 0;
+
 	if (unlikely(*flt & VM_FAULT_ERROR)) {
 		if (*flt & VM_FAULT_OOM) {
 			ret = -ENOMEM;
arch/powerpc/mm/fault.c renamed from arch/powerpc/mm/fault.c~mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types +5 -0
@@ -511,6 +511,10 @@ retry:
 	if (fault_signal_pending(fault, regs))
 		return user_mode(regs) ? 0 : SIGBUS;
 
+	/* The fault is fully completed (including releasing mmap lock) */
+	if (fault & VM_FAULT_COMPLETED)
+		goto out;
+
 	/*
 	 * Handle the retry right now, the mmap_lock has been released in that
 	 * case.
@@ -525,6 +529,7 @@ retry:
 	if (unlikely(fault & VM_FAULT_ERROR))
 		return mm_fault_error(regs, address, fault);
 
+out:
 	/*
 	 * Major/minor page fault accounting.
 	 */
arch/riscv/mm/fault.c renamed from arch/riscv/mm/fault.c~mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types +4 -0
@@ -326,6 +326,10 @@ good_area:
 	if (fault_signal_pending(fault, regs))
 		return;
 
+	/* The fault is fully completed (including releasing mmap lock) */
+	if (fault & VM_FAULT_COMPLETED)
+		return;
+
 	if (unlikely(fault & VM_FAULT_RETRY)) {
 		flags |= FAULT_FLAG_TRIED;
 
arch/s390/mm/fault.c renamed from arch/s390/mm/fault.c~mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types +12 -0
@@ -433,6 +433,17 @@ retry:
 			goto out_up;
 		goto out;
 	}
+
+	/* The fault is fully completed (including releasing mmap lock) */
+	if (fault & VM_FAULT_COMPLETED) {
+		if (gmap) {
+			mmap_read_lock(mm);
+			goto out_gmap;
+		}
+		fault = 0;
+		goto out;
+	}
+
 	if (unlikely(fault & VM_FAULT_ERROR))
 		goto out_up;
 
@@ -452,6 +463,7 @@ retry:
 		mmap_read_lock(mm);
 		goto retry;
 	}
+out_gmap:
 	if (IS_ENABLED(CONFIG_PGSTE) && gmap) {
 		address =  __gmap_link(gmap, current->thread.gmap_addr,
 				       address);
arch/sh/mm/fault.c renamed from arch/sh/mm/fault.c~mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types +4 -0
@@ -485,6 +485,10 @@ good_area:
 		if (mm_fault_error(regs, error_code, address, fault))
 			return;
 
+	/* The fault is fully completed (including releasing mmap lock) */
+	if (fault & VM_FAULT_COMPLETED)
+		return;
+
 	if (fault & VM_FAULT_RETRY) {
 		flags |= FAULT_FLAG_TRIED;
 
arch/sparc/mm/fault_32.c renamed from arch/sparc/mm/fault_32.c~mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types +4 -0
@@ -190,6 +190,10 @@ good_area:
 	if (fault_signal_pending(fault, regs))
 		return;
 
+	/* The fault is fully completed (including releasing mmap lock) */
+	if (fault & VM_FAULT_COMPLETED)
+		return;
+
 	if (unlikely(fault & VM_FAULT_ERROR)) {
 		if (fault & VM_FAULT_OOM)
 			goto out_of_memory;
arch/sparc/mm/fault_64.c renamed from arch/sparc/mm/fault_64.c~mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types +5 -0
@@ -427,6 +427,10 @@ good_area:
 	if (fault_signal_pending(fault, regs))
 		goto exit_exception;
 
+	/* The fault is fully completed (including releasing mmap lock) */
+	if (fault & VM_FAULT_COMPLETED)
+		goto lock_released;
+
 	if (unlikely(fault & VM_FAULT_ERROR)) {
 		if (fault & VM_FAULT_OOM)
 			goto out_of_memory;
@@ -449,6 +453,7 @@ good_area:
 	}
 	mmap_read_unlock(mm);
 
+lock_released:
 	mm_rss = get_mm_rss(mm);
 #if defined(CONFIG_TRANSPARENT_HUGEPAGE)
 	mm_rss -= (mm->context.thp_pte_count * (HPAGE_SIZE / PAGE_SIZE));
arch/um/kernel/trap.c renamed from arch/um/kernel/trap.c~mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types +4 -0
@@ -76,6 +76,10 @@ good_area:
 		if ((fault & VM_FAULT_RETRY) && fatal_signal_pending(current))
 			goto out_nosemaphore;
 
+		/* The fault is fully completed (including releasing mmap lock) */
+		if (fault & VM_FAULT_COMPLETED)
+			return 0;
+
 		if (unlikely(fault & VM_FAULT_ERROR)) {
 			if (fault & VM_FAULT_OOM) {
 				goto out_of_memory;
arch/x86/mm/fault.c renamed from arch/x86/mm/fault.c~mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types +4 -0
@@ -1408,6 +1408,10 @@ good_area:
 		return;
 	}
 
+	/* The fault is fully completed (including releasing mmap lock) */
+	if (fault & VM_FAULT_COMPLETED)
+		return;
+
 	/*
 	 * If we need to retry the mmap_lock has already been released,
 	 * and if there is a fatal signal pending there is no guarantee
arch/xtensa/mm/fault.c renamed from arch/xtensa/mm/fault.c~mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types +4 -0
@@ -172,6 +172,10 @@ good_area:
 		return;
 	}
 
+	/* The fault is fully completed (including releasing mmap lock) */
+	if (fault & VM_FAULT_COMPLETED)
+		return;
+
 	if (unlikely(fault & VM_FAULT_ERROR)) {
 		if (fault & VM_FAULT_OOM)
 			goto out_of_memory;
include/linux/mm_types.h renamed from include/linux/mm_types.h~mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types +2 -0
@@ -729,6 +729,7 @@ typedef __bitwise unsigned int vm_fault_
  * @VM_FAULT_NEEDDSYNC:		->fault did not modify page tables and needs
  *				fsync() to complete (for synchronous page faults
  *				in DAX)
+ * @VM_FAULT_COMPLETED:		->fault completed, meanwhile mmap lock released
  * @VM_FAULT_HINDEX_MASK:	mask HINDEX value
  *
  */
@@ -746,6 +747,7 @@ enum vm_fault_reason {
 	VM_FAULT_FALLBACK       = (__force vm_fault_t)0x000800,
 	VM_FAULT_DONE_COW       = (__force vm_fault_t)0x001000,
 	VM_FAULT_NEEDDSYNC      = (__force vm_fault_t)0x002000,
+	VM_FAULT_COMPLETED      = (__force vm_fault_t)0x004000,
 	VM_FAULT_HINDEX_MASK    = (__force vm_fault_t)0x0f0000,
 };
 
mm/gup.c renamed from mm/gup.c~mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types +33 -1
@@ -951,6 +951,25 @@ static int faultin_page(struct vm_area_s
 	}
 
 	ret = handle_mm_fault(vma, address, fault_flags, NULL);
+
+	if (ret & VM_FAULT_COMPLETED) {
+		/*
+		 * With FAULT_FLAG_RETRY_NOWAIT we'll never release the
+		 * mmap lock in the page fault handler. Sanity check this.
+		 */
+		WARN_ON_ONCE(fault_flags & FAULT_FLAG_RETRY_NOWAIT);
+		if (locked)
+			*locked = 0;
+		/*
+		 * We should do the same as VM_FAULT_RETRY, but let's not
+		 * return -EBUSY since that's not reflecting the reality of
+		 * what has happened - we've just fully completed a page
+		 * fault, with the mmap lock released.  Use -EAGAIN to show
+		 * that we want to take the mmap lock _again_.
+		 */
+		return -EAGAIN;
+	}
+
 	if (ret & VM_FAULT_ERROR) {
 		int err = vm_fault_to_errno(ret, *flags);
 
@@ -1177,6 +1196,7 @@ retry:
 			case 0:
 				goto retry;
 			case -EBUSY:
+			case -EAGAIN:
 				ret = 0;
 				fallthrough;
 			case -EFAULT:
@@ -1303,6 +1323,18 @@ retry:
 		return -EINTR;
 
 	ret = handle_mm_fault(vma, address, fault_flags, NULL);
+
+	if (ret & VM_FAULT_COMPLETED) {
+		/*
+		 * NOTE: it's a pity that we need to retake the lock here
+		 * to pair with the unlock() in the callers. Ideally we
+		 * could tell the callers so they do not need to unlock.
+		 */
+		mmap_read_lock(mm);
+		*unlocked = true;
+		return 0;
+	}
+
 	if (ret & VM_FAULT_ERROR) {
 		int err = vm_fault_to_errno(ret, 0);
 
@@ -1368,7 +1400,7 @@ static __always_inline long __get_user_p
 			/* VM_FAULT_RETRY couldn't trigger, bypass */
 			return ret;
 
-		/* VM_FAULT_RETRY cannot return errors */
+		/* VM_FAULT_RETRY or VM_FAULT_COMPLETED cannot return errors */
 		if (!*locked) {
 			BUG_ON(ret < 0);
 			BUG_ON(ret >= nr_pages);
mm/memory.c renamed from mm/memory.c~mm-avoid-unnecessary-page-fault-retires-on-shared-memory-types +1 -1
@@ -3020,7 +3020,7 @@ static vm_fault_t fault_dirty_shared_pag
 		balance_dirty_pages_ratelimited(mapping);
 		if (fpin) {
 			fput(fpin);
-			return VM_FAULT_RETRY;
+			return VM_FAULT_COMPLETED;
 		}
 	}
 

_

Patches currently in -mm which might be from [email protected] are