Skip to contentSkip to conversation

khugepaged: mTHP support

PATCH Superseded Nico Pache 12 participants 42 messages Apr 28, 2025 – Jun 7, 2025

Subsystems (5)

v5 of 19 Superseded Latest is v19 →

lore
Share & tools
lore

Nico Pache

author
#0 lore raw

v5 cover khugepaged: mTHP support

The following series provides khugepaged and madvise collapse with the capability to collapse anonymous memory regions to mTHPs.

To achieve this we generalize the khugepaged functions to no longer depend on PMD_ORDER. Then during the PMD scan, we keep track of chunks of pages (defined by KHUGEPAGED_MTHP_MIN_ORDER) that are utilized. This info is tracked using a bitmap. After the PMD scan is done, we do binary recursion on the bitmap to find the optimal mTHP sizes for the PMD range. The restriction on max_ptes_none is removed during the scan, to make sure we account for the whole PMD range. When no mTHP size is enabled, the legacy behavior of khugepaged is maintained. max_ptes_none will be scaled by the attempted collapse order to determine how full a THP must be to be eligible. If a mTHP collapse is attempted, but contains swapped out, or shared pages, we dont perform the collapse.

With the default max_ptes_none=511, the code should keep its most of its original behavior. To exercise mTHP collapse we need to set max_ptes_none<=255. With max_ptes_none > HPAGE_PMD_NR/2 you will experience collapse "creep" and constantly promote mTHPs to the next available size.

Patch 1:     Refactor/rename hpage_collapse
Patch 2:     Some refactoring to combine madvise_collapse and khugepaged
Patch 3-5:   Generalize khugepaged functions for arbitrary orders
Patch 6-9:   The mTHP patches
Patch 10-11: Tracing/stats
Patch 12:    Documentation

---------
Testing
---------
- Built for x86_64, aarch64, ppc64le, and s390x
- selftests mm
- I created a test script that I used to push khugepaged to its limits while monitoring a number of stats and tracepoints. The code is available here[1] (Run in legacy mode for these changes and set mthp sizes to inherit)
The summary from my testings was that there was no significant regression noticed through this test. In some cases my changes had better collapse latencies, and was able to scan more pages in the same amount of time/work, but for the most part the results were consistent.
- redis testing. I tested these changes along with my defer changes (see followup post for more details).
- some basic testing on 64k page size.
- lots of general use.

Changes since V4 [2]:
- switched the order of patches 1 and 2
- fixed some edge cases on the unified madvise_collapse and khugepaged
- Explained the "creep" some more in the docs
- fix EXCEED_SHARED vs EXCEED_SWAP accounting issue
- fix potential highmem issue caused by a early unmap of the PTE

Changes since V3:
- Rebased onto mm-unstable
commit 0e68b850b1d3 ("vmalloc: use atomic_long_add_return_relaxed()")
- small changes to Documentation

Changes since V2:
- corrected legacy behavior for khugepaged and madvise_collapse
- added proper mTHP stat tracking
- Minor changes to prevent a nested lock on non-split-lock arches
- Took Devs version of alloc_charge_folio as it has the proper stats
- Skip cases were trying to collapse to a lower order would still fail
- Fixed cases were the bitmap was not being updated properly
- Moved Documentation update to this series instead of the defer set
- Minor bugs discovered during testing and review
- Minor "nit" cleanup

Changes since V1:
- Minor bug fixes discovered during review and testing
- removed dynamic allocations for bitmaps, and made them stack based
- Adjusted bitmap offset from u8 to u16 to support 64k pagesize.
- Updated trace events to include collapsing order info.
- Scaled max_ptes_none by order rather than scaling to a 0-100 scale.
- No longer require a chunk to be fully utilized before setting the bit. Use the same max_ptes_none scaling principle to achieve this.
- Skip mTHP collapse that requires swapin or shared handling. This helps prevent some of the "creep" that was discovered in v1.

[1] - https://gitlab.com/npache/khugepaged_mthp_test
[2] - https://lore.kernel.org/lkml/[email protected]/

Dev Jain (1):
khugepaged: generalize alloc_charge_folio()

Nico Pache (11):
khugepaged: rename hpage_collapse_* to khugepaged_* introduce khugepaged_collapse_single_pmd to unify khugepaged and
madvise_collapse
khugepaged: generalize hugepage_vma_revalidate for mTHP support
khugepaged: generalize __collapse_huge_page_* for mTHP support
khugepaged: introduce khugepaged_scan_bitmap for mTHP support
khugepaged: add mTHP support
khugepaged: skip collapsing mTHP to smaller orders
khugepaged: avoid unnecessary mTHP collapse attempts
khugepaged: improve tracepoints for mTHP orders
khugepaged: add per-order mTHP khugepaged stats
Documentation: mm: update the admin guide for mTHP collapse

 Documentation/admin-guide/mm/transhuge.rst |  14 +-
 include/linux/huge_mm.h                    |   5 +
 include/linux/khugepaged.h                 |   4 +
 include/trace/events/huge_memory.h         |  34 +-
 mm/huge_memory.c                           |  11 +
 mm/khugepaged.c                            | 464 ++++++++++++++-------
 6 files changed, 376 insertions(+), 156 deletions(-)
Signature · 1 line
2.48.1
author
#1 lore raw

PATCH v5 1/12 khugepaged: rename hpage_collapse_* to khugepaged_*

functions in khugepaged.c use a mix of hpage_collapse and khugepaged as the function prefix.

rename all of them to khugepaged to keep things consistent and slightly shorten the function names.

---
 mm/khugepaged.c | 44 ++++++++++++++++++++++----------------------
 1 file changed, 22 insertions(+), 22 deletions(-)
mm/khugepaged.c +22 -22
index 5cf204ab6af0..8b96274dce07 100644
@@ -402,14 +402,14 @@ void __init khugepaged_destroy(void)
 	kmem_cache_destroy(mm_slot_cache);
 }
 
-static inline int hpage_collapse_test_exit(struct mm_struct *mm)
+static inline int khugepaged_test_exit(struct mm_struct *mm)
 {
 	return atomic_read(&mm->mm_users) == 0;
 }
 
-static inline int hpage_collapse_test_exit_or_disable(struct mm_struct *mm)
+static inline int khugepaged_test_exit_or_disable(struct mm_struct *mm)
 {
-	return hpage_collapse_test_exit(mm) ||
+	return khugepaged_test_exit(mm) ||
 	       test_bit(MMF_DISABLE_THP, &mm->flags);
 }
 
@@ -444,7 +444,7 @@ void __khugepaged_enter(struct mm_struct *mm)
 	int wakeup;
 
 	/* __khugepaged_exit() must not run from under us */
-	VM_BUG_ON_MM(hpage_collapse_test_exit(mm), mm);
+	VM_BUG_ON_MM(khugepaged_test_exit(mm), mm);
 	if (unlikely(test_and_set_bit(MMF_VM_HUGEPAGE, &mm->flags)))
 		return;
 
@@ -503,7 +503,7 @@ void __khugepaged_exit(struct mm_struct *mm)
 	} else if (mm_slot) {
 		/*
 		 * This is required to serialize against
-		 * hpage_collapse_test_exit() (which is guaranteed to run
+		 * khugepaged_test_exit() (which is guaranteed to run
 		 * under mmap sem read mode). Stop here (after we return all
 		 * pagetables will be destroyed) until khugepaged has finished
 		 * working on the pagetables under the mmap_lock.
@@ -851,7 +851,7 @@ struct collapse_control khugepaged_collapse_control = {
 	.is_khugepaged = true,
 };
 
-static bool hpage_collapse_scan_abort(int nid, struct collapse_control *cc)
+static bool khugepaged_scan_abort(int nid, struct collapse_control *cc)
 {
 	int i;
 
@@ -886,7 +886,7 @@ static inline gfp_t alloc_hugepage_khugepaged_gfpmask(void)
 }
 
 #ifdef CONFIG_NUMA
-static int hpage_collapse_find_target_node(struct collapse_control *cc)
+static int khugepaged_find_target_node(struct collapse_control *cc)
 {
 	int nid, target_node = 0, max_value = 0;
 
@@ -905,7 +905,7 @@ static int hpage_collapse_find_target_node(struct collapse_control *cc)
 	return target_node;
 }
 #else
-static int hpage_collapse_find_target_node(struct collapse_control *cc)
+static int khugepaged_find_target_node(struct collapse_control *cc)
 {
 	return 0;
 }
@@ -925,7 +925,7 @@ static int hugepage_vma_revalidate(struct mm_struct *mm, unsigned long address,
 	struct vm_area_struct *vma;
 	unsigned long tva_flags = cc->is_khugepaged ? TVA_ENFORCE_SYSFS : 0;
 
-	if (unlikely(hpage_collapse_test_exit_or_disable(mm)))
+	if (unlikely(khugepaged_test_exit_or_disable(mm)))
 		return SCAN_ANY_PROCESS;
 
 	*vmap = vma = find_vma(mm, address);
@@ -992,7 +992,7 @@ static int check_pmd_still_valid(struct mm_struct *mm,
 
 /*
  * Bring missing pages in from swap, to complete THP collapse.
- * Only done if hpage_collapse_scan_pmd believes it is worthwhile.
+ * Only done if khugepaged_scan_pmd believes it is worthwhile.
  *
  * Called and returns without pte mapped or spinlocks held.
  * Returns result: if not SCAN_SUCCEED, mmap_lock has been released.
@@ -1078,7 +1078,7 @@ static int alloc_charge_folio(struct folio **foliop, struct mm_struct *mm,
 {
 	gfp_t gfp = (cc->is_khugepaged ? alloc_hugepage_khugepaged_gfpmask() :
 		     GFP_TRANSHUGE);
-	int node = hpage_collapse_find_target_node(cc);
+	int node = khugepaged_find_target_node(cc);
 	struct folio *folio;
 
 	folio = __folio_alloc(gfp, HPAGE_PMD_ORDER, node, &cc->alloc_nmask);
@@ -1264,7 +1264,7 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 	return result;
 }
 
-static int hpage_collapse_scan_pmd(struct mm_struct *mm,
+static int khugepaged_scan_pmd(struct mm_struct *mm,
 				   struct vm_area_struct *vma,
 				   unsigned long address, bool *mmap_locked,
 				   struct collapse_control *cc)
@@ -1378,7 +1378,7 @@ static int hpage_collapse_scan_pmd(struct mm_struct *mm,
 		 * hit record.
 		 */
 		node = folio_nid(folio);
-		if (hpage_collapse_scan_abort(node, cc)) {
+		if (khugepaged_scan_abort(node, cc)) {
 			result = SCAN_SCAN_ABORT;
 			goto out_unmap;
 		}
@@ -1447,7 +1447,7 @@ static void collect_mm_slot(struct khugepaged_mm_slot *mm_slot)
 
 	lockdep_assert_held(&khugepaged_mm_lock);
 
-	if (hpage_collapse_test_exit(mm)) {
+	if (khugepaged_test_exit(mm)) {
 		/* free mm_slot */
 		hash_del(&slot->hash);
 		list_del(&slot->mm_node);
@@ -1742,7 +1742,7 @@ static void retract_page_tables(struct address_space *mapping, pgoff_t pgoff)
 		if (find_pmd_or_thp_or_none(mm, addr, &pmd) != SCAN_SUCCEED)
 			continue;
 
-		if (hpage_collapse_test_exit(mm))
+		if (khugepaged_test_exit(mm))
 			continue;
 		/*
 		 * When a vma is registered with uffd-wp, we cannot recycle
@@ -2264,7 +2264,7 @@ static int collapse_file(struct mm_struct *mm, unsigned long addr,
 	return result;
 }
 
-static int hpage_collapse_scan_file(struct mm_struct *mm, unsigned long addr,
+static int khugepaged_scan_file(struct mm_struct *mm, unsigned long addr,
 				    struct file *file, pgoff_t start,
 				    struct collapse_control *cc)
 {
@@ -2309,7 +2309,7 @@ static int hpage_collapse_scan_file(struct mm_struct *mm, unsigned long addr,
 		}
 
 		node = folio_nid(folio);
-		if (hpage_collapse_scan_abort(node, cc)) {
+		if (khugepaged_scan_abort(node, cc)) {
 			result = SCAN_SCAN_ABORT;
 			break;
 		}
@@ -2355,7 +2355,7 @@ static int hpage_collapse_scan_file(struct mm_struct *mm, unsigned long addr,
 	return result;
 }
 #else
-static int hpage_collapse_scan_file(struct mm_struct *mm, unsigned long addr,
+static int khugepaged_scan_file(struct mm_struct *mm, unsigned long addr,
 				    struct file *file, pgoff_t start,
 				    struct collapse_control *cc)
 {
@@ -2401,7 +2401,7 @@ static unsigned int khugepaged_scan_mm_slot(unsigned int pages, int *result,
 		goto breakouterloop_mmap_lock;
 
 	progress++;
-	if (unlikely(hpage_collapse_test_exit_or_disable(mm)))
+	if (unlikely(khugepaged_test_exit_or_disable(mm)))
 		goto breakouterloop;
 
 	vma_iter_init(&vmi, mm, khugepaged_scan.address);
@@ -2409,7 +2409,7 @@ static unsigned int khugepaged_scan_mm_slot(unsigned int pages, int *result,
 		unsigned long hstart, hend;
 
 		cond_resched();
-		if (unlikely(hpage_collapse_test_exit_or_disable(mm))) {
+		if (unlikely(khugepaged_test_exit_or_disable(mm))) {
 			progress++;
 			break;
 		}
@@ -2431,7 +2431,7 @@ static unsigned int khugepaged_scan_mm_slot(unsigned int pages, int *result,
 			bool mmap_locked = true;
 
 			cond_resched();
-			if (unlikely(hpage_collapse_test_exit_or_disable(mm)))
+			if (unlikely(khugepaged_test_exit_or_disable(mm)))
 				goto breakouterloop;
 
 			VM_BUG_ON(khugepaged_scan.address < hstart ||
@@ -2491,7 +2491,7 @@ static unsigned int khugepaged_scan_mm_slot(unsigned int pages, int *result,
 	 * Release the current mm_slot if this mm is about to die, or
 	 * if we scanned all vmas of this mm.
 	 */
-	if (hpage_collapse_test_exit(mm) || !vma) {
+	if (khugepaged_test_exit(mm) || !vma) {
 		/*
 		 * Make sure that if mm_users is reaching zero while
 		 * khugepaged runs here, khugepaged_exit will find
Signature · 1 line
2.48.1
reviewer
#2 lore raw

Re: [PATCH v5 01/12] khugepaged: rename hpage_collapse_* to khugepaged_*

Quoted 11 lines · Nico Pache

functions in khugepaged.c use a mix of hpage_collapse and khugepaged as the function prefix.

rename all of them to khugepaged to keep things consistent and slightly shorten the function names.

---
 mm/khugepaged.c | 44 ++++++++++++++++++++++----------------------
 1 file changed, 22 insertions(+), 22 deletions(-)

LGTM. Reviewed-by: Zi Yan <[email protected]>

Best Regards,
Yan, Zi

author
#4 lore raw

PATCH v5 2/12 introduce khugepaged_collapse_single_pmd to unify khugepaged and madvise_collapse

In reply to Nico Pache

The khugepaged daemon and madvise_collapse have two different implementations that do almost the same thing.

Create khugepaged_collapse_single_pmd to increase code reuse and create an entry point for future khugepaged changes.

Refactor madvise_collapse and khugepaged_scan_mm_slot to use the new khugepaged_collapse_single_pmd function.

---
 mm/khugepaged.c | 96 +++++++++++++++++++++++++------------------------
 1 file changed, 49 insertions(+), 47 deletions(-)
mm/khugepaged.c +49 -47
index 8b96274dce07..3690a6ec5883 100644
@@ -2363,6 +2363,48 @@ static int khugepaged_scan_file(struct mm_struct *mm, unsigned long addr,
 }
 #endif
 
+/*
+ * Try to collapse a single PMD starting at a PMD aligned addr, and return
+ * the results.
+ */
+static int khugepaged_collapse_single_pmd(unsigned long addr,
+				   struct vm_area_struct *vma, bool *mmap_locked,
+				   struct collapse_control *cc)
+{
+	int result = SCAN_FAIL;
+	struct mm_struct *mm = vma->vm_mm;
+
+	if (IS_ENABLED(CONFIG_SHMEM) && !vma_is_anonymous(vma)) {
+		struct file *file = get_file(vma->vm_file);
+		pgoff_t pgoff = linear_page_index(vma, addr);
+
+		mmap_read_unlock(mm);
+		*mmap_locked = false;
+		result = khugepaged_scan_file(mm, addr, file, pgoff, cc);
+		fput(file);
+		if (result == SCAN_PTE_MAPPED_HUGEPAGE) {
+			mmap_read_lock(mm);
+			*mmap_locked = true;
+			if (khugepaged_test_exit_or_disable(mm)) {
+				result = SCAN_ANY_PROCESS;
+				goto end;
+			}
+			result = collapse_pte_mapped_thp(mm, addr,
+							 !cc->is_khugepaged);
+			if (result == SCAN_PMD_MAPPED)
+				result = SCAN_SUCCEED;
+			mmap_read_unlock(mm);
+			*mmap_locked = false;
+		}
+	} else {
+		result = khugepaged_scan_pmd(mm, vma, addr, mmap_locked, cc);
+	}
+	if (cc->is_khugepaged && result == SCAN_SUCCEED)
+		++khugepaged_pages_collapsed;
+end:
+	return result;
+}
+
 static unsigned int khugepaged_scan_mm_slot(unsigned int pages, int *result,
 					    struct collapse_control *cc)
 	__releases(&khugepaged_mm_lock)
@@ -2437,34 +2479,12 @@ static unsigned int khugepaged_scan_mm_slot(unsigned int pages, int *result,
 			VM_BUG_ON(khugepaged_scan.address < hstart ||
 				  khugepaged_scan.address + HPAGE_PMD_SIZE >
 				  hend);
-			if (IS_ENABLED(CONFIG_SHMEM) && !vma_is_anonymous(vma)) {
-				struct file *file = get_file(vma->vm_file);
-				pgoff_t pgoff = linear_page_index(vma,
-						khugepaged_scan.address);
-
-				mmap_read_unlock(mm);
-				mmap_locked = false;
-				*result = hpage_collapse_scan_file(mm,
-					khugepaged_scan.address, file, pgoff, cc);
-				fput(file);
-				if (*result == SCAN_PTE_MAPPED_HUGEPAGE) {
-					mmap_read_lock(mm);
-					if (hpage_collapse_test_exit_or_disable(mm))
-						goto breakouterloop;
-					*result = collapse_pte_mapped_thp(mm,
-						khugepaged_scan.address, false);
-					if (*result == SCAN_PMD_MAPPED)
-						*result = SCAN_SUCCEED;
-					mmap_read_unlock(mm);
-				}
-			} else {
-				*result = hpage_collapse_scan_pmd(mm, vma,
-					khugepaged_scan.address, &mmap_locked, cc);
-			}
-
-			if (*result == SCAN_SUCCEED)
-				++khugepaged_pages_collapsed;
 
+			*result = khugepaged_collapse_single_pmd(khugepaged_scan.address,
+						vma, &mmap_locked, cc);
+			/* If we return SCAN_ANY_PROCESS we are holding the mmap_lock */
+			if (*result == SCAN_ANY_PROCESS)
+				goto breakouterloop;
 			/* move to next address */
 			khugepaged_scan.address += HPAGE_PMD_SIZE;
 			progress += HPAGE_PMD_NR;
@@ -2783,36 +2803,18 @@ int madvise_collapse(struct vm_area_struct *vma, struct vm_area_struct **prev,
 		mmap_assert_locked(mm);
 		memset(cc->node_load, 0, sizeof(cc->node_load));
 		nodes_clear(cc->alloc_nmask);
-		if (IS_ENABLED(CONFIG_SHMEM) && !vma_is_anonymous(vma)) {
-			struct file *file = get_file(vma->vm_file);
-			pgoff_t pgoff = linear_page_index(vma, addr);
 
-			mmap_read_unlock(mm);
-			mmap_locked = false;
-			result = hpage_collapse_scan_file(mm, addr, file, pgoff,
-							  cc);
-			fput(file);
-		} else {
-			result = hpage_collapse_scan_pmd(mm, vma, addr,
-							 &mmap_locked, cc);
-		}
+		result = khugepaged_collapse_single_pmd(addr, vma, &mmap_locked, cc);
+
 		if (!mmap_locked)
 			*prev = NULL;  /* Tell caller we dropped mmap_lock */
 
-handle_result:
 		switch (result) {
 		case SCAN_SUCCEED:
 		case SCAN_PMD_MAPPED:
 			++thps;
 			break;
 		case SCAN_PTE_MAPPED_HUGEPAGE:
-			BUG_ON(mmap_locked);
-			BUG_ON(*prev);
-			mmap_read_lock(mm);
-			result = collapse_pte_mapped_thp(mm, addr, true);
-			mmap_read_unlock(mm);
-			goto handle_result;
-		/* Whitelisted set of results where continuing OK */
 		case SCAN_PMD_NULL:
 		case SCAN_PTE_NON_PRESENT:
 		case SCAN_PTE_UFFD_WP:
Signature · 1 line
2.48.1
reviewer Reviewed-by on v5 2/12
#5 lore raw

Re: [PATCH v5 02/12] introduce khugepaged_collapse_single_pmd to unify khugepaged and madvise_collapse

Quoted 10 lines · Nico Pache

The khugepaged daemon and madvise_collapse have two different implementations that do almost the same thing.

Create khugepaged_collapse_single_pmd to increase code reuse and create an entry point for future khugepaged changes.

Refactor madvise_collapse and khugepaged_scan_mm_slot to use the new khugepaged_collapse_single_pmd function.

LGTM.

author
#6 lore raw

PATCH v5 3/12 khugepaged: generalize hugepage_vma_revalidate for mTHP support

In reply to Nico Pache

For khugepaged to support different mTHP orders, we must generalize this function for arbitrary orders.

No functional change in this patch.

---
 mm/khugepaged.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)
mm/khugepaged.c +6 -6
index 3690a6ec5883..ddb805356e05 100644
@@ -920,7 +920,7 @@ static int khugepaged_find_target_node(struct collapse_control *cc)
 static int hugepage_vma_revalidate(struct mm_struct *mm, unsigned long address,
 				   bool expect_anon,
 				   struct vm_area_struct **vmap,
-				   struct collapse_control *cc)
+				   struct collapse_control *cc, int order)
 {
 	struct vm_area_struct *vma;
 	unsigned long tva_flags = cc->is_khugepaged ? TVA_ENFORCE_SYSFS : 0;
@@ -932,9 +932,9 @@ static int hugepage_vma_revalidate(struct mm_struct *mm, unsigned long address,
 	if (!vma)
 		return SCAN_VMA_NULL;
 
-	if (!thp_vma_suitable_order(vma, address, PMD_ORDER))
+	if (!thp_vma_suitable_order(vma, address, order))
 		return SCAN_ADDRESS_RANGE;
-	if (!thp_vma_allowable_order(vma, vma->vm_flags, tva_flags, PMD_ORDER))
+	if (!thp_vma_allowable_order(vma, vma->vm_flags, tva_flags, order))
 		return SCAN_VMA_CHECK;
 	/*
 	 * Anon VMA expected, the address may be unmapped then
@@ -1130,7 +1130,7 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 		goto out_nolock;
 
 	mmap_read_lock(mm);
-	result = hugepage_vma_revalidate(mm, address, true, &vma, cc);
+	result = hugepage_vma_revalidate(mm, address, true, &vma, cc, HPAGE_PMD_ORDER);
 	if (result != SCAN_SUCCEED) {
 		mmap_read_unlock(mm);
 		goto out_nolock;
@@ -1164,7 +1164,7 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 	 * mmap_lock.
 	 */
 	mmap_write_lock(mm);
-	result = hugepage_vma_revalidate(mm, address, true, &vma, cc);
+	result = hugepage_vma_revalidate(mm, address, true, &vma, cc, HPAGE_PMD_ORDER);
 	if (result != SCAN_SUCCEED)
 		goto out_up_write;
 	/* check if the pmd is still valid */
@@ -2792,7 +2792,7 @@ int madvise_collapse(struct vm_area_struct *vma, struct vm_area_struct **prev,
 			mmap_read_lock(mm);
 			mmap_locked = true;
 			result = hugepage_vma_revalidate(mm, addr, false, &vma,
-							 cc);
+							 cc, HPAGE_PMD_ORDER);
 			if (result  != SCAN_SUCCEED) {
 				last_fail = result;
 				goto out_nolock;
Signature · 1 line
2.48.1
author
#7 lore raw

PATCH v5 4/12 khugepaged: generalize alloc_charge_folio()

In reply to Nico Pache

From: Dev Jain <[email protected]>

Pass order to alloc_charge_folio() and update mTHP statistics.

---
 include/linux/huge_mm.h |  2 ++
 mm/huge_memory.c        |  4 ++++
 mm/khugepaged.c         | 17 +++++++++++------
 3 files changed, 17 insertions(+), 6 deletions(-)
include/linux/huge_mm.h +2 -0
index 2f190c90192d..0bb65bd4e6dd 100644
@@ -123,6 +123,8 @@ enum mthp_stat_item {
 	MTHP_STAT_ANON_FAULT_ALLOC,
 	MTHP_STAT_ANON_FAULT_FALLBACK,
 	MTHP_STAT_ANON_FAULT_FALLBACK_CHARGE,
+	MTHP_STAT_COLLAPSE_ALLOC,
+	MTHP_STAT_COLLAPSE_ALLOC_FAILED,
 	MTHP_STAT_ZSWPOUT,
 	MTHP_STAT_SWPIN,
 	MTHP_STAT_SWPIN_FALLBACK,
mm/huge_memory.c +4 -0
index 2780a12b25f0..670b8b7a6738 100644
@@ -615,6 +615,8 @@ static struct kobj_attribute _name##_attr = __ATTR_RO(_name)
 DEFINE_MTHP_STAT_ATTR(anon_fault_alloc, MTHP_STAT_ANON_FAULT_ALLOC);
 DEFINE_MTHP_STAT_ATTR(anon_fault_fallback, MTHP_STAT_ANON_FAULT_FALLBACK);
 DEFINE_MTHP_STAT_ATTR(anon_fault_fallback_charge, MTHP_STAT_ANON_FAULT_FALLBACK_CHARGE);
+DEFINE_MTHP_STAT_ATTR(collapse_alloc, MTHP_STAT_COLLAPSE_ALLOC);
+DEFINE_MTHP_STAT_ATTR(collapse_alloc_failed, MTHP_STAT_COLLAPSE_ALLOC_FAILED);
 DEFINE_MTHP_STAT_ATTR(zswpout, MTHP_STAT_ZSWPOUT);
 DEFINE_MTHP_STAT_ATTR(swpin, MTHP_STAT_SWPIN);
 DEFINE_MTHP_STAT_ATTR(swpin_fallback, MTHP_STAT_SWPIN_FALLBACK);
@@ -680,6 +682,8 @@ static struct attribute *any_stats_attrs[] = {
 #endif
 	&split_attr.attr,
 	&split_failed_attr.attr,
+	&collapse_alloc_attr.attr,
+	&collapse_alloc_failed_attr.attr,
 	NULL,
 };
 
mm/khugepaged.c +11 -6
index ddb805356e05..16b5b3761f95 100644
@@ -1074,21 +1074,26 @@ static int __collapse_huge_page_swapin(struct mm_struct *mm,
 }
 
 static int alloc_charge_folio(struct folio **foliop, struct mm_struct *mm,
-			      struct collapse_control *cc)
+			      struct collapse_control *cc, u8 order)
 {
 	gfp_t gfp = (cc->is_khugepaged ? alloc_hugepage_khugepaged_gfpmask() :
 		     GFP_TRANSHUGE);
 	int node = khugepaged_find_target_node(cc);
 	struct folio *folio;
 
-	folio = __folio_alloc(gfp, HPAGE_PMD_ORDER, node, &cc->alloc_nmask);
+	folio = __folio_alloc(gfp, order, node, &cc->alloc_nmask);
 	if (!folio) {
 		*foliop = NULL;
-		count_vm_event(THP_COLLAPSE_ALLOC_FAILED);
+		if (order == HPAGE_PMD_ORDER)
+			count_vm_event(THP_COLLAPSE_ALLOC_FAILED);
+		count_mthp_stat(order, MTHP_STAT_COLLAPSE_ALLOC_FAILED);
 		return SCAN_ALLOC_HUGE_PAGE_FAIL;
 	}
 
-	count_vm_event(THP_COLLAPSE_ALLOC);
+	if (order == HPAGE_PMD_ORDER)
+		count_vm_event(THP_COLLAPSE_ALLOC);
+	count_mthp_stat(order, MTHP_STAT_COLLAPSE_ALLOC);
+
 	if (unlikely(mem_cgroup_charge(folio, mm, gfp))) {
 		folio_put(folio);
 		*foliop = NULL;
@@ -1125,7 +1130,7 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 	 */
 	mmap_read_unlock(mm);
 
-	result = alloc_charge_folio(&folio, mm, cc);
+	result = alloc_charge_folio(&folio, mm, cc, HPAGE_PMD_ORDER);
 	if (result != SCAN_SUCCEED)
 		goto out_nolock;
 
@@ -1849,7 +1854,7 @@ static int collapse_file(struct mm_struct *mm, unsigned long addr,
 	VM_BUG_ON(!IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) && !is_shmem);
 	VM_BUG_ON(start & (HPAGE_PMD_NR - 1));
 
-	result = alloc_charge_folio(&new_folio, mm, cc);
+	result = alloc_charge_folio(&new_folio, mm, cc, HPAGE_PMD_ORDER);
 	if (result != SCAN_SUCCEED)
 		goto out;
 
Signature · 1 line
2.48.1
author
#8 lore raw

PATCH v5 5/12 khugepaged: generalize __collapse_huge_page_* for mTHP support

In reply to Nico Pache

generalize the order of the __collapse_huge_page_* functions to support future mTHP collapse.

mTHP collapse can suffer from incosistant behavior, and memory waste "creep". disable swapin and shared support for mTHP collapse.

No functional changes in this patch.

---
 mm/khugepaged.c | 46 ++++++++++++++++++++++++++++------------------
 1 file changed, 28 insertions(+), 18 deletions(-)
mm/khugepaged.c +28 -18
index 16b5b3761f95..e21998a06253 100644
@@ -565,15 +565,17 @@ static int __collapse_huge_page_isolate(struct vm_area_struct *vma,
 					unsigned long address,
 					pte_t *pte,
 					struct collapse_control *cc,
-					struct list_head *compound_pagelist)
+					struct list_head *compound_pagelist,
+					u8 order)
 {
 	struct page *page = NULL;
 	struct folio *folio = NULL;
 	pte_t *_pte;
 	int none_or_zero = 0, shared = 0, result = SCAN_FAIL, referenced = 0;
 	bool writable = false;
+	int scaled_none = khugepaged_max_ptes_none >> (HPAGE_PMD_ORDER - order);
 
-	for (_pte = pte; _pte < pte + HPAGE_PMD_NR;
+	for (_pte = pte; _pte < pte + (1 << order);
 	     _pte++, address += PAGE_SIZE) {
 		pte_t pteval = ptep_get(_pte);
 		if (pte_none(pteval) || (pte_present(pteval) &&
@@ -581,7 +583,7 @@ static int __collapse_huge_page_isolate(struct vm_area_struct *vma,
 			++none_or_zero;
 			if (!userfaultfd_armed(vma) &&
 			    (!cc->is_khugepaged ||
-			     none_or_zero <= khugepaged_max_ptes_none)) {
+			     none_or_zero <= scaled_none)) {
 				continue;
 			} else {
 				result = SCAN_EXCEED_NONE_PTE;
@@ -609,8 +611,8 @@ static int __collapse_huge_page_isolate(struct vm_area_struct *vma,
 		/* See hpage_collapse_scan_pmd(). */
 		if (folio_maybe_mapped_shared(folio)) {
 			++shared;
-			if (cc->is_khugepaged &&
-			    shared > khugepaged_max_ptes_shared) {
+			if (order != HPAGE_PMD_ORDER || (cc->is_khugepaged &&
+			    shared > khugepaged_max_ptes_shared)) {
 				result = SCAN_EXCEED_SHARED_PTE;
 				count_vm_event(THP_SCAN_EXCEED_SHARED_PTE);
 				goto out;
@@ -711,13 +713,14 @@ static void __collapse_huge_page_copy_succeeded(pte_t *pte,
 						struct vm_area_struct *vma,
 						unsigned long address,
 						spinlock_t *ptl,
-						struct list_head *compound_pagelist)
+						struct list_head *compound_pagelist,
+						u8 order)
 {
 	struct folio *src, *tmp;
 	pte_t *_pte;
 	pte_t pteval;
 
-	for (_pte = pte; _pte < pte + HPAGE_PMD_NR;
+	for (_pte = pte; _pte < pte + (1 << order);
 	     _pte++, address += PAGE_SIZE) {
 		pteval = ptep_get(_pte);
 		if (pte_none(pteval) || is_zero_pfn(pte_pfn(pteval))) {
@@ -764,7 +767,8 @@ static void __collapse_huge_page_copy_failed(pte_t *pte,
 					     pmd_t *pmd,
 					     pmd_t orig_pmd,
 					     struct vm_area_struct *vma,
-					     struct list_head *compound_pagelist)
+					     struct list_head *compound_pagelist,
+					     u8 order)
 {
 	spinlock_t *pmd_ptl;
 
@@ -781,7 +785,7 @@ static void __collapse_huge_page_copy_failed(pte_t *pte,
 	 * Release both raw and compound pages isolated
 	 * in __collapse_huge_page_isolate.
 	 */
-	release_pte_pages(pte, pte + HPAGE_PMD_NR, compound_pagelist);
+	release_pte_pages(pte, pte + (1 << order), compound_pagelist);
 }
 
 /*
@@ -802,7 +806,7 @@ static void __collapse_huge_page_copy_failed(pte_t *pte,
 static int __collapse_huge_page_copy(pte_t *pte, struct folio *folio,
 		pmd_t *pmd, pmd_t orig_pmd, struct vm_area_struct *vma,
 		unsigned long address, spinlock_t *ptl,
-		struct list_head *compound_pagelist)
+		struct list_head *compound_pagelist, u8 order)
 {
 	unsigned int i;
 	int result = SCAN_SUCCEED;
@@ -810,7 +814,7 @@ static int __collapse_huge_page_copy(pte_t *pte, struct folio *folio,
 	/*
 	 * Copying pages' contents is subject to memory poison at any iteration.
 	 */
-	for (i = 0; i < HPAGE_PMD_NR; i++) {
+	for (i = 0; i < (1 << order); i++) {
 		pte_t pteval = ptep_get(pte + i);
 		struct page *page = folio_page(folio, i);
 		unsigned long src_addr = address + i * PAGE_SIZE;
@@ -829,10 +833,10 @@ static int __collapse_huge_page_copy(pte_t *pte, struct folio *folio,
 
 	if (likely(result == SCAN_SUCCEED))
 		__collapse_huge_page_copy_succeeded(pte, vma, address, ptl,
-						    compound_pagelist);
+						    compound_pagelist, order);
 	else
 		__collapse_huge_page_copy_failed(pte, pmd, orig_pmd, vma,
-						 compound_pagelist);
+						 compound_pagelist, order);
 
 	return result;
 }
@@ -1000,11 +1004,11 @@ static int check_pmd_still_valid(struct mm_struct *mm,
 static int __collapse_huge_page_swapin(struct mm_struct *mm,
 				       struct vm_area_struct *vma,
 				       unsigned long haddr, pmd_t *pmd,
-				       int referenced)
+				       int referenced, u8 order)
 {
 	int swapped_in = 0;
 	vm_fault_t ret = 0;
-	unsigned long address, end = haddr + (HPAGE_PMD_NR * PAGE_SIZE);
+	unsigned long address, end = haddr + (PAGE_SIZE << order);
 	int result;
 	pte_t *pte = NULL;
 	spinlock_t *ptl;
@@ -1035,6 +1039,12 @@ static int __collapse_huge_page_swapin(struct mm_struct *mm,
 		if (!is_swap_pte(vmf.orig_pte))
 			continue;
 
+		/* Dont swapin for mTHP collapse */
+		if (order != HPAGE_PMD_ORDER) {
+			result = SCAN_EXCEED_SWAP_PTE;
+			goto out;
+		}
+
 		vmf.pte = pte;
 		vmf.ptl = ptl;
 		ret = do_swap_page(&vmf);
@@ -1154,7 +1164,7 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 		 * that case.  Continuing to collapse causes inconsistency.
 		 */
 		result = __collapse_huge_page_swapin(mm, vma, address, pmd,
-						     referenced);
+				referenced, HPAGE_PMD_ORDER);
 		if (result != SCAN_SUCCEED)
 			goto out_nolock;
 	}
@@ -1201,7 +1211,7 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 	pte = pte_offset_map_lock(mm, &_pmd, address, &pte_ptl);
 	if (pte) {
 		result = __collapse_huge_page_isolate(vma, address, pte, cc,
-						      &compound_pagelist);
+					&compound_pagelist, HPAGE_PMD_ORDER);
 		spin_unlock(pte_ptl);
 	} else {
 		result = SCAN_PMD_NULL;
@@ -1231,7 +1241,7 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 
 	result = __collapse_huge_page_copy(pte, folio, pmd, _pmd,
 					   vma, address, pte_ptl,
-					   &compound_pagelist);
+					   &compound_pagelist, HPAGE_PMD_ORDER);
 	pte_unmap(pte);
 	if (unlikely(result != SCAN_SUCCEED))
 		goto out_up_write;
Signature · 1 line
2.48.1
author
#9 lore raw

PATCH v5 6/12 khugepaged: introduce khugepaged_scan_bitmap for mTHP support

In reply to Nico Pache

khugepaged scans anons PMD ranges for potential collapse to a hugepage. To add mTHP support we use this scan to instead record chunks of utilized sections of the PMD.

khugepaged_scan_bitmap uses a stack struct to recursively scan a bitmap that represents chunks of utilized regions. We can then determine what mTHP size fits best and in the following patch, we set this bitmap while scanning the anon PMD.

max_ptes_none is used as a scale to determine how "full" an order must be before being considered for collapse.

When attempting to collapse an order that has its order set to "always" lets always collapse to that order in a greedy manner without considering the number of bits set.

---
 include/linux/khugepaged.h |  4 ++
 mm/khugepaged.c            | 94 ++++++++++++++++++++++++++++++++++----
 2 files changed, 89 insertions(+), 9 deletions(-)
include/linux/khugepaged.h +4 -0
index 1f46046080f5..18fe6eb5051d 100644
@@ -1,6 +1,10 @@
 /* SPDX-License-Identifier: GPL-2.0 */
 #ifndef _LINUX_KHUGEPAGED_H
 #define _LINUX_KHUGEPAGED_H
+#define KHUGEPAGED_MIN_MTHP_ORDER	2
+#define KHUGEPAGED_MIN_MTHP_NR	(1<<KHUGEPAGED_MIN_MTHP_ORDER)
+#define MAX_MTHP_BITMAP_SIZE  (1 << (ilog2(MAX_PTRS_PER_PTE) - KHUGEPAGED_MIN_MTHP_ORDER))
+#define MTHP_BITMAP_SIZE  (1 << (HPAGE_PMD_ORDER - KHUGEPAGED_MIN_MTHP_ORDER))
 
 extern unsigned int khugepaged_max_ptes_none __read_mostly;
 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
mm/khugepaged.c +85 -9

143 lines not on this page · raw message

Signature · 1 line
2.48.1
reviewer
#10 lore raw

Re: [PATCH v5 06/12] khugepaged: introduce khugepaged_scan_bitmap for mTHP support

Quoted 27 lines · Nico Pache

khugepaged scans anons PMD ranges for potential collapse to a hugepage. To add mTHP support we use this scan to instead record chunks of utilized sections of the PMD.

khugepaged_scan_bitmap uses a stack struct to recursively scan a bitmap that represents chunks of utilized regions. We can then determine what mTHP size fits best and in the following patch, we set this bitmap while scanning the anon PMD.

max_ptes_none is used as a scale to determine how "full" an order must be before being considered for collapse.

When attempting to collapse an order that has its order set to "always" lets always collapse to that order in a greedy manner without considering the number of bits set.

---
  include/linux/khugepaged.h |  4 ++
  mm/khugepaged.c            | 94 ++++++++++++++++++++++++++++++++++----
  2 files changed, 89 insertions(+), 9 deletions(-)
include/linux/khugepaged.h +0 -0
index 1f46046080f5..18fe6eb5051d 100644

include/linux/khugepaged.h line 4

Quoted 4 lines
include/linux/khugepaged.h +1 -0
@@ -1,6 +1,10 @@
  /* SPDX-License-Identifier: GPL-2.0 */
  #ifndef _LINUX_KHUGEPAGED_H
  #define _LINUX_KHUGEPAGED_H
+#define KHUGEPAGED_MIN_MTHP_ORDER	2

Still better to add some comments to explain explicitly why choose 2 as the MIN_MTHP_ORDER.

Quoted 78 lines
include/linux/khugepaged.h +3 -0
+#define KHUGEPAGED_MIN_MTHP_NR	(1<<KHUGEPAGED_MIN_MTHP_ORDER)
+#define MAX_MTHP_BITMAP_SIZE  (1 << (ilog2(MAX_PTRS_PER_PTE) - KHUGEPAGED_MIN_MTHP_ORDER))
+#define MTHP_BITMAP_SIZE  (1 << (HPAGE_PMD_ORDER - KHUGEPAGED_MIN_MTHP_ORDER))
 
  extern unsigned int khugepaged_max_ptes_none __read_mostly;
  #ifdef CONFIG_TRANSPARENT_HUGEPAGE
mm/khugepaged.c +24 -6
index e21998a06253..6e67db86409a 100644
@@ -94,6 +94,11 @@ static DEFINE_READ_MOSTLY_HASHTABLE(mm_slots_hash, MM_SLOTS_HASH_BITS);
 
  static struct kmem_cache *mm_slot_cache __ro_after_init;
 
+struct scan_bit_state {
+	u8 order;
+	u16 offset;
+};
+
  struct collapse_control {
  	bool is_khugepaged;
 
@@ -102,6 +107,18 @@ struct collapse_control {
 
  	/* nodemask for allocation fallback */
  	nodemask_t alloc_nmask;
+
+	/*
+	 * bitmap used to collapse mTHP sizes.
+	 * 1bit = order KHUGEPAGED_MIN_MTHP_ORDER mTHP
+	 */
+	DECLARE_BITMAP(mthp_bitmap, MAX_MTHP_BITMAP_SIZE);
+	DECLARE_BITMAP(mthp_bitmap_temp, MAX_MTHP_BITMAP_SIZE);
+	struct scan_bit_state mthp_bitmap_stack[MAX_MTHP_BITMAP_SIZE];
+};
+
+struct collapse_control khugepaged_collapse_control = {
+	.is_khugepaged = true,
  };
 
  /**
@@ -851,10 +868,6 @@ static void khugepaged_alloc_sleep(void)
  	remove_wait_queue(&khugepaged_wait, &wait);
  }
 
-struct collapse_control khugepaged_collapse_control = {
-	.is_khugepaged = true,
-};
-
  static bool khugepaged_scan_abort(int nid, struct collapse_control *cc)
  {
  	int i;
@@ -1118,7 +1131,8 @@ static int alloc_charge_folio(struct folio **foliop, struct mm_struct *mm,
 
  static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
  			      int referenced, int unmapped,
-			      struct collapse_control *cc)
+			      struct collapse_control *cc, bool *mmap_locked,
+				  u8 order, u16 offset)
  {
  	LIST_HEAD(compound_pagelist);
  	pmd_t *pmd, _pmd;
@@ -1137,8 +1151,12 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
  	 * The allocation can take potentially a long time if it involves
  	 * sync compaction, and we do not need to hold the mmap_lock during
  	 * that. We will recheck the vma after taking it again in write mode.
+	 * If collapsing mTHPs we may have already released the read_lock.
  	 */
-	mmap_read_unlock(mm);
+	if (*mmap_locked) {
+		mmap_read_unlock(mm);
+		*mmap_locked = false;
+	}
 
  	result = alloc_charge_folio(&folio, mm, cc, HPAGE_PMD_ORDER);
  	if (result != SCAN_SUCCEED)
@@ -1273,12 +1291,72 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
  out_up_write:

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1301

Quoted 10 lines
mm/khugepaged.c +2 -0
  	mmap_write_unlock(mm);
  out_nolock:
+	*mmap_locked = false;
  	if (folio)
  		folio_put(folio);
  	trace_mm_collapse_huge_page(mm, result == SCAN_SUCCEED, result);
  	return result;
  }
 
+// Recursive function to consume the bitmap

Nit: please use '/* Xxxx */' for comments in this patch.

Quoted 27 lines
mm/khugepaged.c +27 -0
+static int khugepaged_scan_bitmap(struct mm_struct *mm, unsigned long address,
+			int referenced, int unmapped, struct collapse_control *cc,
+			bool *mmap_locked, unsigned long enabled_orders)
+{
+	u8 order, next_order;
+	u16 offset, mid_offset;
+	int num_chunks;
+	int bits_set, threshold_bits;
+	int top = -1;
+	int collapsed = 0;
+	int ret;
+	struct scan_bit_state state;
+	bool is_pmd_only = (enabled_orders == (1 << HPAGE_PMD_ORDER));
+
+	cc->mthp_bitmap_stack[++top] = (struct scan_bit_state)
+		{ HPAGE_PMD_ORDER - KHUGEPAGED_MIN_MTHP_ORDER, 0 };
+
+	while (top >= 0) {
+		state = cc->mthp_bitmap_stack[top--];
+		order = state.order + KHUGEPAGED_MIN_MTHP_ORDER;
+		offset = state.offset;
+		num_chunks = 1 << (state.order);
+		// Skip mTHP orders that are not enabled
+		if (!test_bit(order, &enabled_orders))
+			goto next;
+
+		// copy the relavant section to a new bitmap

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1338

Quoted 10 lines
mm/khugepaged.c +10 -0
+		bitmap_shift_right(cc->mthp_bitmap_temp, cc->mthp_bitmap, offset,
+				  MTHP_BITMAP_SIZE);
+
+		bits_set = bitmap_weight(cc->mthp_bitmap_temp, num_chunks);
+		threshold_bits = (HPAGE_PMD_NR - khugepaged_max_ptes_none - 1)
+				>> (HPAGE_PMD_ORDER - state.order);
+
+		//Check if the region is "almost full" based on the threshold
+		if (bits_set > threshold_bits || is_pmd_only
+			|| test_bit(order, &huge_anon_orders_always)) {

When testing this patch, I disabled the PMD-sized THP and enabled 64K-sized mTHP, but it still attempts to collapse into a PMD-sized THP (since bits_set > threshold_bits is ture). This doesn't seem reasonable?

Quoted 35 lines
mm/khugepaged.c +22 -3
+			ret = collapse_huge_page(mm, address, referenced, unmapped, cc,
+					mmap_locked, order, offset * KHUGEPAGED_MIN_MTHP_NR);
+			if (ret == SCAN_SUCCEED) {
+				collapsed += (1 << order);
+				continue;
+			}
+		}
+
+next:
+		if (state.order > 0) {
+			next_order = state.order - 1;
+			mid_offset = offset + (num_chunks / 2);
+			cc->mthp_bitmap_stack[++top] = (struct scan_bit_state)
+				{ next_order, mid_offset };
+			cc->mthp_bitmap_stack[++top] = (struct scan_bit_state)
+				{ next_order, offset };
+			}
+	}
+	return collapsed;
+}
+
  static int khugepaged_scan_pmd(struct mm_struct *mm,
  				   struct vm_area_struct *vma,
  				   unsigned long address, bool *mmap_locked,
@@ -1445,9 +1523,7 @@ static int khugepaged_scan_pmd(struct mm_struct *mm,
  	pte_unmap_unlock(pte, ptl);
  	if (result == SCAN_SUCCEED) {
  		result = collapse_huge_page(mm, address, referenced,
-					    unmapped, cc);
-		/* collapse_huge_page will return with the mmap_lock released */
-		*mmap_locked = false;
+					    unmapped, cc, mmap_locked, HPAGE_PMD_ORDER, 0);
  	}
  out:
  	trace_mm_khugepaged_scan_pmd(mm, &folio->page, writable, referenced,
author
#11 lore raw

Re: [PATCH v5 06/12] khugepaged: introduce khugepaged_scan_bitmap for mTHP support

Quoted 26 lines · Baolin Wang
Quoted 22 lines · Nico Pache

khugepaged scans anons PMD ranges for potential collapse to a hugepage. To add mTHP support we use this scan to instead record chunks of utilized sections of the PMD.

khugepaged_scan_bitmap uses a stack struct to recursively scan a bitmap that represents chunks of utilized regions. We can then determine what mTHP size fits best and in the following patch, we set this bitmap while scanning the anon PMD.

max_ptes_none is used as a scale to determine how "full" an order must be before being considered for collapse.

When attempting to collapse an order that has its order set to "always" lets always collapse to that order in a greedy manner without considering the number of bits set.

---
  include/linux/khugepaged.h |  4 ++
  mm/khugepaged.c            | 94 ++++++++++++++++++++++++++++++++++----
  2 files changed, 89 insertions(+), 9 deletions(-)
Quoted 12 lines

include/linux/khugepaged.h line 4

Quoted 9 lines
include/linux/khugepaged.h +1 -0
index 1f46046080f5..18fe6eb5051d 100644
@@ -1,6 +1,10 @@
  /* SPDX-License-Identifier: GPL-2.0 */
  #ifndef _LINUX_KHUGEPAGED_H
  #define _LINUX_KHUGEPAGED_H
+#define KHUGEPAGED_MIN_MTHP_ORDER    2

Still better to add some comments to explain explicitly why choose 2 as the MIN_MTHP_ORDER.

Ok i'll add a note that explicitly states that the min order of anon mTHPs is 2

Quoted 125 lines
Quoted 79 lines
include/linux/khugepaged.h +3 -0
+#define KHUGEPAGED_MIN_MTHP_NR       (1<<KHUGEPAGED_MIN_MTHP_ORDER)
+#define MAX_MTHP_BITMAP_SIZE  (1 << (ilog2(MAX_PTRS_PER_PTE) - KHUGEPAGED_MIN_MTHP_ORDER))
+#define MTHP_BITMAP_SIZE  (1 << (HPAGE_PMD_ORDER - KHUGEPAGED_MIN_MTHP_ORDER))
 
  extern unsigned int khugepaged_max_ptes_none __read_mostly;
  #ifdef CONFIG_TRANSPARENT_HUGEPAGE
mm/khugepaged.c +24 -6
index e21998a06253..6e67db86409a 100644
@@ -94,6 +94,11 @@ static DEFINE_READ_MOSTLY_HASHTABLE(mm_slots_hash, MM_SLOTS_HASH_BITS);
 
  static struct kmem_cache *mm_slot_cache __ro_after_init;
 
+struct scan_bit_state {
+     u8 order;
+     u16 offset;
+};
+
  struct collapse_control {
      bool is_khugepaged;
 
@@ -102,6 +107,18 @@ struct collapse_control {
 
      /* nodemask for allocation fallback */
      nodemask_t alloc_nmask;
+
+     /*
+      * bitmap used to collapse mTHP sizes.
+      * 1bit = order KHUGEPAGED_MIN_MTHP_ORDER mTHP
+      */
+     DECLARE_BITMAP(mthp_bitmap, MAX_MTHP_BITMAP_SIZE);
+     DECLARE_BITMAP(mthp_bitmap_temp, MAX_MTHP_BITMAP_SIZE);
+     struct scan_bit_state mthp_bitmap_stack[MAX_MTHP_BITMAP_SIZE];
+};
+
+struct collapse_control khugepaged_collapse_control = {
+     .is_khugepaged = true,
  };
 
  /**
@@ -851,10 +868,6 @@ static void khugepaged_alloc_sleep(void)
      remove_wait_queue(&khugepaged_wait, &wait);
  }
 
-struct collapse_control khugepaged_collapse_control = {
-     .is_khugepaged = true,
-};
-
  static bool khugepaged_scan_abort(int nid, struct collapse_control *cc)
  {
      int i;
@@ -1118,7 +1131,8 @@ static int alloc_charge_folio(struct folio **foliop, struct mm_struct *mm,
 
  static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
                            int referenced, int unmapped,
-                           struct collapse_control *cc)
+                           struct collapse_control *cc, bool *mmap_locked,
+                               u8 order, u16 offset)
  {
      LIST_HEAD(compound_pagelist);
      pmd_t *pmd, _pmd;
@@ -1137,8 +1151,12 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
       * The allocation can take potentially a long time if it involves
       * sync compaction, and we do not need to hold the mmap_lock during
       * that. We will recheck the vma after taking it again in write mode.
+      * If collapsing mTHPs we may have already released the read_lock.
       */
-     mmap_read_unlock(mm);
+     if (*mmap_locked) {
+             mmap_read_unlock(mm);
+             *mmap_locked = false;
+     }
 
      result = alloc_charge_folio(&folio, mm, cc, HPAGE_PMD_ORDER);
      if (result != SCAN_SUCCEED)
@@ -1273,12 +1291,72 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
  out_up_write:

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1301

Quoted 10 lines
mm/khugepaged.c +2 -0
      mmap_write_unlock(mm);
  out_nolock:
+     *mmap_locked = false;
      if (folio)
              folio_put(folio);
      trace_mm_collapse_huge_page(mm, result == SCAN_SUCCEED, result);
      return result;
  }
 
+// Recursive function to consume the bitmap

Nit: please use '/* Xxxx */' for comments in this patch.

Quoted 33 lines
mm/khugepaged.c +33 -0
+static int khugepaged_scan_bitmap(struct mm_struct *mm, unsigned long address,
+                     int referenced, int unmapped, struct collapse_control *cc,
+                     bool *mmap_locked, unsigned long enabled_orders)
+{
+     u8 order, next_order;
+     u16 offset, mid_offset;
+     int num_chunks;
+     int bits_set, threshold_bits;
+     int top = -1;
+     int collapsed = 0;
+     int ret;
+     struct scan_bit_state state;
+     bool is_pmd_only = (enabled_orders == (1 << HPAGE_PMD_ORDER));
+
+     cc->mthp_bitmap_stack[++top] = (struct scan_bit_state)
+             { HPAGE_PMD_ORDER - KHUGEPAGED_MIN_MTHP_ORDER, 0 };
+
+     while (top >= 0) {
+             state = cc->mthp_bitmap_stack[top--];
+             order = state.order + KHUGEPAGED_MIN_MTHP_ORDER;
+             offset = state.offset;
+             num_chunks = 1 << (state.order);
+             // Skip mTHP orders that are not enabled
+             if (!test_bit(order, &enabled_orders))
+                     goto next;
+
+             // copy the relavant section to a new bitmap
+             bitmap_shift_right(cc->mthp_bitmap_temp, cc->mthp_bitmap, offset,
+                               MTHP_BITMAP_SIZE);
+
+             bits_set = bitmap_weight(cc->mthp_bitmap_temp, num_chunks);
+             threshold_bits = (HPAGE_PMD_NR - khugepaged_max_ptes_none - 1)
+                             >> (HPAGE_PMD_ORDER - state.order);
Quoted 8 lines

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1338

Quoted 4 lines
mm/khugepaged.c +4 -0
+
+             //Check if the region is "almost full" based on the threshold
+             if (bits_set > threshold_bits || is_pmd_only
+                     || test_bit(order, &huge_anon_orders_always)) {

When testing this patch, I disabled the PMD-sized THP and enabled 64K-sized mTHP, but it still attempts to collapse into a PMD-sized THP (since bits_set > threshold_bits is ture). This doesn't seem reasonable?

We are still required to have PMD enabled for mTHP collapse to work. It's a limitation of the current khugepaged code (it currently only adds mm_slots when PMD is enabled).
We've discussed this in the past and are looking for a proper way forward, but the solution becomes tricky.

However I'm surprised that it still collapses due to the code below. I'll test this out later today.
+ if (!test_bit(order, &enabled_orders))
+ goto next;

Quoted 37 lines
Quoted 36 lines
mm/khugepaged.c +22 -3
+                     ret = collapse_huge_page(mm, address, referenced, unmapped, cc,
+                                     mmap_locked, order, offset * KHUGEPAGED_MIN_MTHP_NR);
+                     if (ret == SCAN_SUCCEED) {
+                             collapsed += (1 << order);
+                             continue;
+                     }
+             }
+
+next:
+             if (state.order > 0) {
+                     next_order = state.order - 1;
+                     mid_offset = offset + (num_chunks / 2);
+                     cc->mthp_bitmap_stack[++top] = (struct scan_bit_state)
+                             { next_order, mid_offset };
+                     cc->mthp_bitmap_stack[++top] = (struct scan_bit_state)
+                             { next_order, offset };
+                     }
+     }
+     return collapsed;
+}
+
  static int khugepaged_scan_pmd(struct mm_struct *mm,
                                 struct vm_area_struct *vma,
                                 unsigned long address, bool *mmap_locked,
@@ -1445,9 +1523,7 @@ static int khugepaged_scan_pmd(struct mm_struct *mm,
      pte_unmap_unlock(pte, ptl);
      if (result == SCAN_SUCCEED) {
              result = collapse_huge_page(mm, address, referenced,
-                                         unmapped, cc);
-             /* collapse_huge_page will return with the mmap_lock released */
-             *mmap_locked = false;
+                                         unmapped, cc, mmap_locked, HPAGE_PMD_ORDER, 0);
      }
  out:
      trace_mm_khugepaged_scan_pmd(mm, &folio->page, writable, referenced,
author
#12 lore raw

Re: [PATCH v5 06/12] khugepaged: introduce khugepaged_scan_bitmap for mTHP support

Quoted 175 lines · Nico Pache
Quoted 26 lines · Baolin Wang
Quoted 22 lines · Nico Pache

khugepaged scans anons PMD ranges for potential collapse to a hugepage. To add mTHP support we use this scan to instead record chunks of utilized sections of the PMD.

khugepaged_scan_bitmap uses a stack struct to recursively scan a bitmap that represents chunks of utilized regions. We can then determine what mTHP size fits best and in the following patch, we set this bitmap while scanning the anon PMD.

max_ptes_none is used as a scale to determine how "full" an order must be before being considered for collapse.

When attempting to collapse an order that has its order set to "always" lets always collapse to that order in a greedy manner without considering the number of bits set.

---
  include/linux/khugepaged.h |  4 ++
  mm/khugepaged.c            | 94 ++++++++++++++++++++++++++++++++++----
  2 files changed, 89 insertions(+), 9 deletions(-)
Quoted 12 lines

include/linux/khugepaged.h line 4

Quoted 9 lines
include/linux/khugepaged.h +1 -0
index 1f46046080f5..18fe6eb5051d 100644
@@ -1,6 +1,10 @@
  /* SPDX-License-Identifier: GPL-2.0 */
  #ifndef _LINUX_KHUGEPAGED_H
  #define _LINUX_KHUGEPAGED_H
+#define KHUGEPAGED_MIN_MTHP_ORDER    2

Still better to add some comments to explain explicitly why choose 2 as the MIN_MTHP_ORDER.

Ok i'll add a note that explicitly states that the min order of anon mTHPs is 2

Quoted 125 lines
Quoted 79 lines
include/linux/khugepaged.h +3 -0
+#define KHUGEPAGED_MIN_MTHP_NR       (1<<KHUGEPAGED_MIN_MTHP_ORDER)
+#define MAX_MTHP_BITMAP_SIZE  (1 << (ilog2(MAX_PTRS_PER_PTE) - KHUGEPAGED_MIN_MTHP_ORDER))
+#define MTHP_BITMAP_SIZE  (1 << (HPAGE_PMD_ORDER - KHUGEPAGED_MIN_MTHP_ORDER))
 
  extern unsigned int khugepaged_max_ptes_none __read_mostly;
  #ifdef CONFIG_TRANSPARENT_HUGEPAGE
mm/khugepaged.c +24 -6
index e21998a06253..6e67db86409a 100644
@@ -94,6 +94,11 @@ static DEFINE_READ_MOSTLY_HASHTABLE(mm_slots_hash, MM_SLOTS_HASH_BITS);
 
  static struct kmem_cache *mm_slot_cache __ro_after_init;
 
+struct scan_bit_state {
+     u8 order;
+     u16 offset;
+};
+
  struct collapse_control {
      bool is_khugepaged;
 
@@ -102,6 +107,18 @@ struct collapse_control {
 
      /* nodemask for allocation fallback */
      nodemask_t alloc_nmask;
+
+     /*
+      * bitmap used to collapse mTHP sizes.
+      * 1bit = order KHUGEPAGED_MIN_MTHP_ORDER mTHP
+      */
+     DECLARE_BITMAP(mthp_bitmap, MAX_MTHP_BITMAP_SIZE);
+     DECLARE_BITMAP(mthp_bitmap_temp, MAX_MTHP_BITMAP_SIZE);
+     struct scan_bit_state mthp_bitmap_stack[MAX_MTHP_BITMAP_SIZE];
+};
+
+struct collapse_control khugepaged_collapse_control = {
+     .is_khugepaged = true,
  };
 
  /**
@@ -851,10 +868,6 @@ static void khugepaged_alloc_sleep(void)
      remove_wait_queue(&khugepaged_wait, &wait);
  }
 
-struct collapse_control khugepaged_collapse_control = {
-     .is_khugepaged = true,
-};
-
  static bool khugepaged_scan_abort(int nid, struct collapse_control *cc)
  {
      int i;
@@ -1118,7 +1131,8 @@ static int alloc_charge_folio(struct folio **foliop, struct mm_struct *mm,
 
  static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
                            int referenced, int unmapped,
-                           struct collapse_control *cc)
+                           struct collapse_control *cc, bool *mmap_locked,
+                               u8 order, u16 offset)
  {
      LIST_HEAD(compound_pagelist);
      pmd_t *pmd, _pmd;
@@ -1137,8 +1151,12 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
       * The allocation can take potentially a long time if it involves
       * sync compaction, and we do not need to hold the mmap_lock during
       * that. We will recheck the vma after taking it again in write mode.
+      * If collapsing mTHPs we may have already released the read_lock.
       */
-     mmap_read_unlock(mm);
+     if (*mmap_locked) {
+             mmap_read_unlock(mm);
+             *mmap_locked = false;
+     }
 
      result = alloc_charge_folio(&folio, mm, cc, HPAGE_PMD_ORDER);
      if (result != SCAN_SUCCEED)
@@ -1273,12 +1291,72 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
  out_up_write:

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1301

Quoted 10 lines
mm/khugepaged.c +2 -0
      mmap_write_unlock(mm);
  out_nolock:
+     *mmap_locked = false;
      if (folio)
              folio_put(folio);
      trace_mm_collapse_huge_page(mm, result == SCAN_SUCCEED, result);
      return result;
  }
 
+// Recursive function to consume the bitmap

Nit: please use '/* Xxxx */' for comments in this patch.

Quoted 33 lines
mm/khugepaged.c +33 -0
+static int khugepaged_scan_bitmap(struct mm_struct *mm, unsigned long address,
+                     int referenced, int unmapped, struct collapse_control *cc,
+                     bool *mmap_locked, unsigned long enabled_orders)
+{
+     u8 order, next_order;
+     u16 offset, mid_offset;
+     int num_chunks;
+     int bits_set, threshold_bits;
+     int top = -1;
+     int collapsed = 0;
+     int ret;
+     struct scan_bit_state state;
+     bool is_pmd_only = (enabled_orders == (1 << HPAGE_PMD_ORDER));
+
+     cc->mthp_bitmap_stack[++top] = (struct scan_bit_state)
+             { HPAGE_PMD_ORDER - KHUGEPAGED_MIN_MTHP_ORDER, 0 };
+
+     while (top >= 0) {
+             state = cc->mthp_bitmap_stack[top--];
+             order = state.order + KHUGEPAGED_MIN_MTHP_ORDER;
+             offset = state.offset;
+             num_chunks = 1 << (state.order);
+             // Skip mTHP orders that are not enabled
+             if (!test_bit(order, &enabled_orders))
+                     goto next;
+
+             // copy the relavant section to a new bitmap
+             bitmap_shift_right(cc->mthp_bitmap_temp, cc->mthp_bitmap, offset,
+                               MTHP_BITMAP_SIZE);
+
+             bits_set = bitmap_weight(cc->mthp_bitmap_temp, num_chunks);
+             threshold_bits = (HPAGE_PMD_NR - khugepaged_max_ptes_none - 1)
+                             >> (HPAGE_PMD_ORDER - state.order);
Quoted 8 lines

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1338

Quoted 4 lines
mm/khugepaged.c +4 -0
+
+             //Check if the region is "almost full" based on the threshold
+             if (bits_set > threshold_bits || is_pmd_only
+                     || test_bit(order, &huge_anon_orders_always)) {

When testing this patch, I disabled the PMD-sized THP and enabled 64K-sized mTHP, but it still attempts to collapse into a PMD-sized THP (since bits_set > threshold_bits is ture). This doesn't seem reasonable?

Quoted 8 lines

We are still required to have PMD enabled for mTHP collapse to work. It's a limitation of the current khugepaged code (it currently only adds mm_slots when PMD is enabled).
We've discussed this in the past and are looking for a proper way forward, but the solution becomes tricky.

However I'm surprised that it still collapses due to the code below. I'll test this out later today.

Following up, you are correct, if I disable the PMD size within the mTHP enabled settings (echo never > /sys/kernel/mm/transparent_hugepage/hugepages-2048kB/enabled) it still collapses to PMDs. I believe the global variable takes precedent. I'm not sure what the correct behavior is... I will look into it further

Quoted 39 lines

+ if (!test_bit(order, &enabled_orders))
+ goto next;

Quoted 37 lines
Quoted 36 lines
mm/khugepaged.c +22 -3
+                     ret = collapse_huge_page(mm, address, referenced, unmapped, cc,
+                                     mmap_locked, order, offset * KHUGEPAGED_MIN_MTHP_NR);
+                     if (ret == SCAN_SUCCEED) {
+                             collapsed += (1 << order);
+                             continue;
+                     }
+             }
+
+next:
+             if (state.order > 0) {
+                     next_order = state.order - 1;
+                     mid_offset = offset + (num_chunks / 2);
+                     cc->mthp_bitmap_stack[++top] = (struct scan_bit_state)
+                             { next_order, mid_offset };
+                     cc->mthp_bitmap_stack[++top] = (struct scan_bit_state)
+                             { next_order, offset };
+                     }
+     }
+     return collapsed;
+}
+
  static int khugepaged_scan_pmd(struct mm_struct *mm,
                                 struct vm_area_struct *vma,
                                 unsigned long address, bool *mmap_locked,
@@ -1445,9 +1523,7 @@ static int khugepaged_scan_pmd(struct mm_struct *mm,
      pte_unmap_unlock(pte, ptl);
      if (result == SCAN_SUCCEED) {
              result = collapse_huge_page(mm, address, referenced,
-                                         unmapped, cc);
-             /* collapse_huge_page will return with the mmap_lock released */
-             *mmap_locked = false;
+                                         unmapped, cc, mmap_locked, HPAGE_PMD_ORDER, 0);
      }
  out:
      trace_mm_khugepaged_scan_pmd(mm, &folio->page, writable, referenced,
reviewer
#13 lore raw

Re: [PATCH v5 06/12] khugepaged: introduce khugepaged_scan_bitmap for mTHP support

Quoted 182 lines · Nico Pache
Quoted 181 lines · Nico Pache
Quoted 26 lines · Baolin Wang
Quoted 22 lines · Nico Pache

khugepaged scans anons PMD ranges for potential collapse to a hugepage. To add mTHP support we use this scan to instead record chunks of utilized sections of the PMD.

khugepaged_scan_bitmap uses a stack struct to recursively scan a bitmap that represents chunks of utilized regions. We can then determine what mTHP size fits best and in the following patch, we set this bitmap while scanning the anon PMD.

max_ptes_none is used as a scale to determine how "full" an order must be before being considered for collapse.

When attempting to collapse an order that has its order set to "always" lets always collapse to that order in a greedy manner without considering the number of bits set.

---
   include/linux/khugepaged.h |  4 ++
   mm/khugepaged.c            | 94 ++++++++++++++++++++++++++++++++++----
   2 files changed, 89 insertions(+), 9 deletions(-)
Quoted 12 lines

include/linux/khugepaged.h line 4

Quoted 9 lines
include/linux/khugepaged.h +1 -0
index 1f46046080f5..18fe6eb5051d 100644
@@ -1,6 +1,10 @@
   /* SPDX-License-Identifier: GPL-2.0 */
   #ifndef _LINUX_KHUGEPAGED_H
   #define _LINUX_KHUGEPAGED_H
+#define KHUGEPAGED_MIN_MTHP_ORDER    2

Still better to add some comments to explain explicitly why choose 2 as the MIN_MTHP_ORDER.

Ok i'll add a note that explicitly states that the min order of anon mTHPs is 2

Quoted 125 lines
Quoted 79 lines
include/linux/khugepaged.h +3 -0
+#define KHUGEPAGED_MIN_MTHP_NR       (1<<KHUGEPAGED_MIN_MTHP_ORDER)
+#define MAX_MTHP_BITMAP_SIZE  (1 << (ilog2(MAX_PTRS_PER_PTE) - KHUGEPAGED_MIN_MTHP_ORDER))
+#define MTHP_BITMAP_SIZE  (1 << (HPAGE_PMD_ORDER - KHUGEPAGED_MIN_MTHP_ORDER))
 
   extern unsigned int khugepaged_max_ptes_none __read_mostly;
   #ifdef CONFIG_TRANSPARENT_HUGEPAGE
mm/khugepaged.c +24 -6
index e21998a06253..6e67db86409a 100644
@@ -94,6 +94,11 @@ static DEFINE_READ_MOSTLY_HASHTABLE(mm_slots_hash, MM_SLOTS_HASH_BITS);
 
   static struct kmem_cache *mm_slot_cache __ro_after_init;
 
+struct scan_bit_state {
+     u8 order;
+     u16 offset;
+};
+
   struct collapse_control {
       bool is_khugepaged;
 
@@ -102,6 +107,18 @@ struct collapse_control {
 
       /* nodemask for allocation fallback */
       nodemask_t alloc_nmask;
+
+     /*
+      * bitmap used to collapse mTHP sizes.
+      * 1bit = order KHUGEPAGED_MIN_MTHP_ORDER mTHP
+      */
+     DECLARE_BITMAP(mthp_bitmap, MAX_MTHP_BITMAP_SIZE);
+     DECLARE_BITMAP(mthp_bitmap_temp, MAX_MTHP_BITMAP_SIZE);
+     struct scan_bit_state mthp_bitmap_stack[MAX_MTHP_BITMAP_SIZE];
+};
+
+struct collapse_control khugepaged_collapse_control = {
+     .is_khugepaged = true,
   };
 
   /**
@@ -851,10 +868,6 @@ static void khugepaged_alloc_sleep(void)
       remove_wait_queue(&khugepaged_wait, &wait);
   }
 
-struct collapse_control khugepaged_collapse_control = {
-     .is_khugepaged = true,
-};
-
   static bool khugepaged_scan_abort(int nid, struct collapse_control *cc)
   {
       int i;
@@ -1118,7 +1131,8 @@ static int alloc_charge_folio(struct folio **foliop, struct mm_struct *mm,
 
   static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
                             int referenced, int unmapped,
-                           struct collapse_control *cc)
+                           struct collapse_control *cc, bool *mmap_locked,
+                               u8 order, u16 offset)
   {
       LIST_HEAD(compound_pagelist);
       pmd_t *pmd, _pmd;
@@ -1137,8 +1151,12 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
        * The allocation can take potentially a long time if it involves
        * sync compaction, and we do not need to hold the mmap_lock during
        * that. We will recheck the vma after taking it again in write mode.
+      * If collapsing mTHPs we may have already released the read_lock.
        */
-     mmap_read_unlock(mm);
+     if (*mmap_locked) {
+             mmap_read_unlock(mm);
+             *mmap_locked = false;
+     }
 
       result = alloc_charge_folio(&folio, mm, cc, HPAGE_PMD_ORDER);
       if (result != SCAN_SUCCEED)
@@ -1273,12 +1291,72 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
   out_up_write:

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1301

Quoted 10 lines
mm/khugepaged.c +2 -0
       mmap_write_unlock(mm);
   out_nolock:
+     *mmap_locked = false;
       if (folio)
               folio_put(folio);
       trace_mm_collapse_huge_page(mm, result == SCAN_SUCCEED, result);
       return result;
   }
 
+// Recursive function to consume the bitmap

Nit: please use '/* Xxxx */' for comments in this patch.

Quoted 33 lines
mm/khugepaged.c +33 -0
+static int khugepaged_scan_bitmap(struct mm_struct *mm, unsigned long address,
+                     int referenced, int unmapped, struct collapse_control *cc,
+                     bool *mmap_locked, unsigned long enabled_orders)
+{
+     u8 order, next_order;
+     u16 offset, mid_offset;
+     int num_chunks;
+     int bits_set, threshold_bits;
+     int top = -1;
+     int collapsed = 0;
+     int ret;
+     struct scan_bit_state state;
+     bool is_pmd_only = (enabled_orders == (1 << HPAGE_PMD_ORDER));
+
+     cc->mthp_bitmap_stack[++top] = (struct scan_bit_state)
+             { HPAGE_PMD_ORDER - KHUGEPAGED_MIN_MTHP_ORDER, 0 };
+
+     while (top >= 0) {
+             state = cc->mthp_bitmap_stack[top--];
+             order = state.order + KHUGEPAGED_MIN_MTHP_ORDER;
+             offset = state.offset;
+             num_chunks = 1 << (state.order);
+             // Skip mTHP orders that are not enabled
+             if (!test_bit(order, &enabled_orders))
+                     goto next;
+
+             // copy the relavant section to a new bitmap
+             bitmap_shift_right(cc->mthp_bitmap_temp, cc->mthp_bitmap, offset,
+                               MTHP_BITMAP_SIZE);
+
+             bits_set = bitmap_weight(cc->mthp_bitmap_temp, num_chunks);
+             threshold_bits = (HPAGE_PMD_NR - khugepaged_max_ptes_none - 1)
+                             >> (HPAGE_PMD_ORDER - state.order);
Quoted 8 lines

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1338

Quoted 4 lines
mm/khugepaged.c +4 -0
+
+             //Check if the region is "almost full" based on the threshold
+             if (bits_set > threshold_bits || is_pmd_only
+                     || test_bit(order, &huge_anon_orders_always)) {

When testing this patch, I disabled the PMD-sized THP and enabled 64K-sized mTHP, but it still attempts to collapse into a PMD-sized THP (since bits_set > threshold_bits is ture). This doesn't seem reasonable?

We are still required to have PMD enabled for mTHP collapse to work. It's a limitation of the current khugepaged code (it currently only adds mm_slots when PMD is enabled).
We've discussed this in the past and are looking for a proper way forward, but the solution becomes tricky.

Quoted 11 lines
Quoted 2 lines

However I'm surprised that it still collapses due to the code below. I'll test this out later today.

Following up, you are correct, if I disable the PMD size within the mTHP enabled settings (echo never > /sys/kernel/mm/transparent_hugepage/hugepages-2048kB/enabled) it still collapses to PMDs. I believe the global variable takes precedent. I'm not sure what the correct behavior is... I will look into it further

Quoted 2 lines

+ if (!test_bit(order, &enabled_orders))
+ goto next;

IMO, we should respect the mTHP sysfs control interfaces and use the 'TVA_ENFORCE_SYSFS' flag when determining allowable orders through thp_vma_allowable_orders().

reviewer
#14 lore raw

Re: [PATCH v5 06/12] khugepaged: introduce khugepaged_scan_bitmap for mTHP support

In reply to Nico Pache
Quoted 169 lines · Nico Pache
Quoted 25 lines · Baolin Wang
Quoted 22 lines · Nico Pache

khugepaged scans anons PMD ranges for potential collapse to a hugepage. To add mTHP support we use this scan to instead record chunks of utilized sections of the PMD.

khugepaged_scan_bitmap uses a stack struct to recursively scan a bitmap that represents chunks of utilized regions. We can then determine what mTHP size fits best and in the following patch, we set this bitmap while scanning the anon PMD.

max_ptes_none is used as a scale to determine how "full" an order must be before being considered for collapse.

When attempting to collapse an order that has its order set to "always" lets always collapse to that order in a greedy manner without considering the number of bits set.

---
   include/linux/khugepaged.h |  4 ++
   mm/khugepaged.c            | 94 ++++++++++++++++++++++++++++++++++----
   2 files changed, 89 insertions(+), 9 deletions(-)
Quoted 11 lines

include/linux/khugepaged.h line 4

Quoted 9 lines
include/linux/khugepaged.h +1 -0
index 1f46046080f5..18fe6eb5051d 100644
@@ -1,6 +1,10 @@
   /* SPDX-License-Identifier: GPL-2.0 */
   #ifndef _LINUX_KHUGEPAGED_H
   #define _LINUX_KHUGEPAGED_H
+#define KHUGEPAGED_MIN_MTHP_ORDER    2

Still better to add some comments to explain explicitly why choose 2 as the MIN_MTHP_ORDER.

Ok i'll add a note that explicitly states that the min order of anon mTHPs is 2

Quoted 122 lines
Quoted 78 lines
include/linux/khugepaged.h +3 -0
+#define KHUGEPAGED_MIN_MTHP_NR       (1<<KHUGEPAGED_MIN_MTHP_ORDER)
+#define MAX_MTHP_BITMAP_SIZE  (1 << (ilog2(MAX_PTRS_PER_PTE) - KHUGEPAGED_MIN_MTHP_ORDER))
+#define MTHP_BITMAP_SIZE  (1 << (HPAGE_PMD_ORDER - KHUGEPAGED_MIN_MTHP_ORDER))
 
   extern unsigned int khugepaged_max_ptes_none __read_mostly;
   #ifdef CONFIG_TRANSPARENT_HUGEPAGE
mm/khugepaged.c +24 -6
index e21998a06253..6e67db86409a 100644
@@ -94,6 +94,11 @@ static DEFINE_READ_MOSTLY_HASHTABLE(mm_slots_hash, MM_SLOTS_HASH_BITS);
 
   static struct kmem_cache *mm_slot_cache __ro_after_init;
 
+struct scan_bit_state {
+     u8 order;
+     u16 offset;
+};
+
   struct collapse_control {
       bool is_khugepaged;
 
@@ -102,6 +107,18 @@ struct collapse_control {
 
       /* nodemask for allocation fallback */
       nodemask_t alloc_nmask;
+
+     /*
+      * bitmap used to collapse mTHP sizes.
+      * 1bit = order KHUGEPAGED_MIN_MTHP_ORDER mTHP
+      */
+     DECLARE_BITMAP(mthp_bitmap, MAX_MTHP_BITMAP_SIZE);
+     DECLARE_BITMAP(mthp_bitmap_temp, MAX_MTHP_BITMAP_SIZE);
+     struct scan_bit_state mthp_bitmap_stack[MAX_MTHP_BITMAP_SIZE];
+};
+
+struct collapse_control khugepaged_collapse_control = {
+     .is_khugepaged = true,
   };
 
   /**
@@ -851,10 +868,6 @@ static void khugepaged_alloc_sleep(void)
       remove_wait_queue(&khugepaged_wait, &wait);
   }
 
-struct collapse_control khugepaged_collapse_control = {
-     .is_khugepaged = true,
-};
-
   static bool khugepaged_scan_abort(int nid, struct collapse_control *cc)
   {
       int i;
@@ -1118,7 +1131,8 @@ static int alloc_charge_folio(struct folio **foliop, struct mm_struct *mm,
 
   static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
                             int referenced, int unmapped,
-                           struct collapse_control *cc)
+                           struct collapse_control *cc, bool *mmap_locked,
+                               u8 order, u16 offset)
   {
       LIST_HEAD(compound_pagelist);
       pmd_t *pmd, _pmd;
@@ -1137,8 +1151,12 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
        * The allocation can take potentially a long time if it involves
        * sync compaction, and we do not need to hold the mmap_lock during
        * that. We will recheck the vma after taking it again in write mode.
+      * If collapsing mTHPs we may have already released the read_lock.
        */
-     mmap_read_unlock(mm);
+     if (*mmap_locked) {
+             mmap_read_unlock(mm);
+             *mmap_locked = false;
+     }
 
       result = alloc_charge_folio(&folio, mm, cc, HPAGE_PMD_ORDER);
       if (result != SCAN_SUCCEED)
@@ -1273,12 +1291,72 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
   out_up_write:

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1301

Quoted 10 lines
mm/khugepaged.c +2 -0
       mmap_write_unlock(mm);
   out_nolock:
+     *mmap_locked = false;
       if (folio)
               folio_put(folio);
       trace_mm_collapse_huge_page(mm, result == SCAN_SUCCEED, result);
       return result;
   }
 
+// Recursive function to consume the bitmap

Nit: please use '/* Xxxx */' for comments in this patch.

Quoted 32 lines
mm/khugepaged.c +32 -0
+static int khugepaged_scan_bitmap(struct mm_struct *mm, unsigned long address,
+                     int referenced, int unmapped, struct collapse_control *cc,
+                     bool *mmap_locked, unsigned long enabled_orders)
+{
+     u8 order, next_order;
+     u16 offset, mid_offset;
+     int num_chunks;
+     int bits_set, threshold_bits;
+     int top = -1;
+     int collapsed = 0;
+     int ret;
+     struct scan_bit_state state;
+     bool is_pmd_only = (enabled_orders == (1 << HPAGE_PMD_ORDER));
+
+     cc->mthp_bitmap_stack[++top] = (struct scan_bit_state)
+             { HPAGE_PMD_ORDER - KHUGEPAGED_MIN_MTHP_ORDER, 0 };
+
+     while (top >= 0) {
+             state = cc->mthp_bitmap_stack[top--];
+             order = state.order + KHUGEPAGED_MIN_MTHP_ORDER;
+             offset = state.offset;
+             num_chunks = 1 << (state.order);
+             // Skip mTHP orders that are not enabled
+             if (!test_bit(order, &enabled_orders))
+                     goto next;
+
+             // copy the relavant section to a new bitmap
+             bitmap_shift_right(cc->mthp_bitmap_temp, cc->mthp_bitmap, offset,
+                               MTHP_BITMAP_SIZE);
+
+             bits_set = bitmap_weight(cc->mthp_bitmap_temp, num_chunks);
+             threshold_bits = (HPAGE_PMD_NR - khugepaged_max_ptes_none - 1)
Quoted 8 lines

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1338

Quoted 5 lines
mm/khugepaged.c +5 -0
+                             >> (HPAGE_PMD_ORDER - state.order);
+
+             //Check if the region is "almost full" based on the threshold
+             if (bits_set > threshold_bits || is_pmd_only
+                     || test_bit(order, &huge_anon_orders_always)) {

When testing this patch, I disabled the PMD-sized THP and enabled 64K-sized mTHP, but it still attempts to collapse into a PMD-sized THP (since bits_set > threshold_bits is ture). This doesn't seem reasonable?

Quoted 5 lines

We are still required to have PMD enabled for mTHP collapse to work. It's a limitation of the current khugepaged code (it currently only adds mm_slots when PMD is enabled).
We've discussed this in the past and are looking for a proper way forward, but the solution becomes tricky.

Not sure if this is still a problem, but does this patch solve it?

https://lore.kernel.org/all/[email protected]/

Quoted 40 lines

However I'm surprised that it still collapses due to the code below. I'll test this out later today.
+ if (!test_bit(order, &enabled_orders))
+ goto next;

Quoted 35 lines
Quoted 35 lines
mm/khugepaged.c +22 -3
+                     ret = collapse_huge_page(mm, address, referenced, unmapped, cc,
+                                     mmap_locked, order, offset * KHUGEPAGED_MIN_MTHP_NR);
+                     if (ret == SCAN_SUCCEED) {
+                             collapsed += (1 << order);
+                             continue;
+                     }
+             }
+
+next:
+             if (state.order > 0) {
+                     next_order = state.order - 1;
+                     mid_offset = offset + (num_chunks / 2);
+                     cc->mthp_bitmap_stack[++top] = (struct scan_bit_state)
+                             { next_order, mid_offset };
+                     cc->mthp_bitmap_stack[++top] = (struct scan_bit_state)
+                             { next_order, offset };
+                     }
+     }
+     return collapsed;
+}
+
   static int khugepaged_scan_pmd(struct mm_struct *mm,
                                  struct vm_area_struct *vma,
                                  unsigned long address, bool *mmap_locked,
@@ -1445,9 +1523,7 @@ static int khugepaged_scan_pmd(struct mm_struct *mm,
       pte_unmap_unlock(pte, ptl);
       if (result == SCAN_SUCCEED) {
               result = collapse_huge_page(mm, address, referenced,
-                                         unmapped, cc);
-             /* collapse_huge_page will return with the mmap_lock released */
-             *mmap_locked = false;
+                                         unmapped, cc, mmap_locked, HPAGE_PMD_ORDER, 0);
       }
   out:
       trace_mm_khugepaged_scan_pmd(mm, &folio->page, writable, referenced,
author
#15 lore raw

Re: [PATCH v5 06/12] khugepaged: introduce khugepaged_scan_bitmap for mTHP support

Quoted 178 lines · Dev Jain
Quoted 169 lines · Nico Pache
Quoted 25 lines · Baolin Wang
Quoted 22 lines · Nico Pache

khugepaged scans anons PMD ranges for potential collapse to a hugepage. To add mTHP support we use this scan to instead record chunks of utilized sections of the PMD.

khugepaged_scan_bitmap uses a stack struct to recursively scan a bitmap that represents chunks of utilized regions. We can then determine what mTHP size fits best and in the following patch, we set this bitmap while scanning the anon PMD.

max_ptes_none is used as a scale to determine how "full" an order must be before being considered for collapse.

When attempting to collapse an order that has its order set to "always" lets always collapse to that order in a greedy manner without considering the number of bits set.

---
   include/linux/khugepaged.h |  4 ++
   mm/khugepaged.c            | 94 ++++++++++++++++++++++++++++++++++----
   2 files changed, 89 insertions(+), 9 deletions(-)
Quoted 11 lines

include/linux/khugepaged.h line 4

Quoted 9 lines
include/linux/khugepaged.h +1 -0
index 1f46046080f5..18fe6eb5051d 100644
@@ -1,6 +1,10 @@
   /* SPDX-License-Identifier: GPL-2.0 */
   #ifndef _LINUX_KHUGEPAGED_H
   #define _LINUX_KHUGEPAGED_H
+#define KHUGEPAGED_MIN_MTHP_ORDER    2

Still better to add some comments to explain explicitly why choose 2 as the MIN_MTHP_ORDER.

Ok i'll add a note that explicitly states that the min order of anon mTHPs is 2

Quoted 122 lines
Quoted 78 lines
include/linux/khugepaged.h +3 -0
+#define KHUGEPAGED_MIN_MTHP_NR       (1<<KHUGEPAGED_MIN_MTHP_ORDER)
+#define MAX_MTHP_BITMAP_SIZE  (1 << (ilog2(MAX_PTRS_PER_PTE) - KHUGEPAGED_MIN_MTHP_ORDER))
+#define MTHP_BITMAP_SIZE  (1 << (HPAGE_PMD_ORDER - KHUGEPAGED_MIN_MTHP_ORDER))
 
   extern unsigned int khugepaged_max_ptes_none __read_mostly;
   #ifdef CONFIG_TRANSPARENT_HUGEPAGE
mm/khugepaged.c +24 -6
index e21998a06253..6e67db86409a 100644
@@ -94,6 +94,11 @@ static DEFINE_READ_MOSTLY_HASHTABLE(mm_slots_hash, MM_SLOTS_HASH_BITS);
 
   static struct kmem_cache *mm_slot_cache __ro_after_init;
 
+struct scan_bit_state {
+     u8 order;
+     u16 offset;
+};
+
   struct collapse_control {
       bool is_khugepaged;
 
@@ -102,6 +107,18 @@ struct collapse_control {
 
       /* nodemask for allocation fallback */
       nodemask_t alloc_nmask;
+
+     /*
+      * bitmap used to collapse mTHP sizes.
+      * 1bit = order KHUGEPAGED_MIN_MTHP_ORDER mTHP
+      */
+     DECLARE_BITMAP(mthp_bitmap, MAX_MTHP_BITMAP_SIZE);
+     DECLARE_BITMAP(mthp_bitmap_temp, MAX_MTHP_BITMAP_SIZE);
+     struct scan_bit_state mthp_bitmap_stack[MAX_MTHP_BITMAP_SIZE];
+};
+
+struct collapse_control khugepaged_collapse_control = {
+     .is_khugepaged = true,
   };
 
   /**
@@ -851,10 +868,6 @@ static void khugepaged_alloc_sleep(void)
       remove_wait_queue(&khugepaged_wait, &wait);
   }
 
-struct collapse_control khugepaged_collapse_control = {
-     .is_khugepaged = true,
-};
-
   static bool khugepaged_scan_abort(int nid, struct collapse_control *cc)
   {
       int i;
@@ -1118,7 +1131,8 @@ static int alloc_charge_folio(struct folio **foliop, struct mm_struct *mm,
 
   static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
                             int referenced, int unmapped,
-                           struct collapse_control *cc)
+                           struct collapse_control *cc, bool *mmap_locked,
+                               u8 order, u16 offset)
   {
       LIST_HEAD(compound_pagelist);
       pmd_t *pmd, _pmd;
@@ -1137,8 +1151,12 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
        * The allocation can take potentially a long time if it involves
        * sync compaction, and we do not need to hold the mmap_lock during
        * that. We will recheck the vma after taking it again in write mode.
+      * If collapsing mTHPs we may have already released the read_lock.
        */
-     mmap_read_unlock(mm);
+     if (*mmap_locked) {
+             mmap_read_unlock(mm);
+             *mmap_locked = false;
+     }
 
       result = alloc_charge_folio(&folio, mm, cc, HPAGE_PMD_ORDER);
       if (result != SCAN_SUCCEED)
@@ -1273,12 +1291,72 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
   out_up_write:

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1301

Quoted 10 lines
mm/khugepaged.c +2 -0
       mmap_write_unlock(mm);
   out_nolock:
+     *mmap_locked = false;
       if (folio)
               folio_put(folio);
       trace_mm_collapse_huge_page(mm, result == SCAN_SUCCEED, result);
       return result;
   }
 
+// Recursive function to consume the bitmap

Nit: please use '/* Xxxx */' for comments in this patch.

Quoted 32 lines
mm/khugepaged.c +32 -0
+static int khugepaged_scan_bitmap(struct mm_struct *mm, unsigned long address,
+                     int referenced, int unmapped, struct collapse_control *cc,
+                     bool *mmap_locked, unsigned long enabled_orders)
+{
+     u8 order, next_order;
+     u16 offset, mid_offset;
+     int num_chunks;
+     int bits_set, threshold_bits;
+     int top = -1;
+     int collapsed = 0;
+     int ret;
+     struct scan_bit_state state;
+     bool is_pmd_only = (enabled_orders == (1 << HPAGE_PMD_ORDER));
+
+     cc->mthp_bitmap_stack[++top] = (struct scan_bit_state)
+             { HPAGE_PMD_ORDER - KHUGEPAGED_MIN_MTHP_ORDER, 0 };
+
+     while (top >= 0) {
+             state = cc->mthp_bitmap_stack[top--];
+             order = state.order + KHUGEPAGED_MIN_MTHP_ORDER;
+             offset = state.offset;
+             num_chunks = 1 << (state.order);
+             // Skip mTHP orders that are not enabled
+             if (!test_bit(order, &enabled_orders))
+                     goto next;
+
+             // copy the relavant section to a new bitmap
+             bitmap_shift_right(cc->mthp_bitmap_temp, cc->mthp_bitmap, offset,
+                               MTHP_BITMAP_SIZE);
+
+             bits_set = bitmap_weight(cc->mthp_bitmap_temp, num_chunks);
+             threshold_bits = (HPAGE_PMD_NR - khugepaged_max_ptes_none - 1)
Quoted 8 lines

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1338

Quoted 5 lines
mm/khugepaged.c +5 -0
+                             >> (HPAGE_PMD_ORDER - state.order);
+
+             //Check if the region is "almost full" based on the threshold
+             if (bits_set > threshold_bits || is_pmd_only
+                     || test_bit(order, &huge_anon_orders_always)) {

When testing this patch, I disabled the PMD-sized THP and enabled 64K-sized mTHP, but it still attempts to collapse into a PMD-sized THP (since bits_set > threshold_bits is ture). This doesn't seem reasonable?

Quoted 5 lines

We are still required to have PMD enabled for mTHP collapse to work. It's a limitation of the current khugepaged code (it currently only adds mm_slots when PMD is enabled).
We've discussed this in the past and are looking for a proper way forward, but the solution becomes tricky.

Quoted 4 lines

Not sure if this is still a problem, but does this patch solve it?

https://lore.kernel.org/all/[email protected]/

Hi Dev,

Baolin sent out a patch to do something similar to what you did here based on my changes. I was going to keep the original behavior of activating khugepaged only if the PMD size is enabled, and make that change separately (outside this series), but I've gone ahead and applied/tested Baolin's patch.

Sorry I had forgotten you already had a solution for this.

Cheers,
-- Nico

Quoted 42 lines
Quoted 41 lines

However I'm surprised that it still collapses due to the code below. I'll test this out later today.
+ if (!test_bit(order, &enabled_orders))
+ goto next;

Quoted 35 lines
Quoted 35 lines
mm/khugepaged.c +22 -3
+                     ret = collapse_huge_page(mm, address, referenced, unmapped, cc,
+                                     mmap_locked, order, offset * KHUGEPAGED_MIN_MTHP_NR);
+                     if (ret == SCAN_SUCCEED) {
+                             collapsed += (1 << order);
+                             continue;
+                     }
+             }
+
+next:
+             if (state.order > 0) {
+                     next_order = state.order - 1;
+                     mid_offset = offset + (num_chunks / 2);
+                     cc->mthp_bitmap_stack[++top] = (struct scan_bit_state)
+                             { next_order, mid_offset };
+                     cc->mthp_bitmap_stack[++top] = (struct scan_bit_state)
+                             { next_order, offset };
+                     }
+     }
+     return collapsed;
+}
+
   static int khugepaged_scan_pmd(struct mm_struct *mm,
                                  struct vm_area_struct *vma,
                                  unsigned long address, bool *mmap_locked,
@@ -1445,9 +1523,7 @@ static int khugepaged_scan_pmd(struct mm_struct *mm,
       pte_unmap_unlock(pte, ptl);
       if (result == SCAN_SUCCEED) {
               result = collapse_huge_page(mm, address, referenced,
-                                         unmapped, cc);
-             /* collapse_huge_page will return with the mmap_lock released */
-             *mmap_locked = false;
+                                         unmapped, cc, mmap_locked, HPAGE_PMD_ORDER, 0);
       }
   out:
       trace_mm_khugepaged_scan_pmd(mm, &folio->page, writable, referenced,
author
#16 lore raw

PATCH v5 7/12 khugepaged: add mTHP support

In reply to Nico Pache

Introduce the ability for khugepaged to collapse to different mTHP sizes. While scanning PMD ranges for potential collapse candidates, keep track of pages in KHUGEPAGED_MIN_MTHP_ORDER chunks via a bitmap. Each bit represents a utilized region of order KHUGEPAGED_MIN_MTHP_ORDER ptes. If mTHPs are enabled we remove the restriction of max_ptes_none during the scan phase so we dont bailout early and miss potential mTHP candidates.

After the scan is complete we will perform binary recursion on the bitmap to determine which mTHP size would be most efficient to collapse to. max_ptes_none will be scaled by the attempted collapse order to determine how full a THP must be to be eligible.

If a mTHP collapse is attempted, but contains swapped out, or shared pages, we dont perform the collapse.

---
 mm/khugepaged.c | 125 ++++++++++++++++++++++++++++++++++--------------
 1 file changed, 88 insertions(+), 37 deletions(-)
mm/khugepaged.c +88 -37
index 6e67db86409a..3a846cd70c66 100644
@@ -1136,13 +1136,14 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 {
 	LIST_HEAD(compound_pagelist);
 	pmd_t *pmd, _pmd;
-	pte_t *pte;
+	pte_t *pte, mthp_pte;
 	pgtable_t pgtable;
 	struct folio *folio;
 	spinlock_t *pmd_ptl, *pte_ptl;
 	int result = SCAN_FAIL;
 	struct vm_area_struct *vma;
 	struct mmu_notifier_range range;
+	unsigned long _address = address + offset * PAGE_SIZE;
 
 	VM_BUG_ON(address & ~HPAGE_PMD_MASK);
 
@@ -1158,12 +1159,13 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 		*mmap_locked = false;
 	}
 
-	result = alloc_charge_folio(&folio, mm, cc, HPAGE_PMD_ORDER);
+	result = alloc_charge_folio(&folio, mm, cc, order);
 	if (result != SCAN_SUCCEED)
 		goto out_nolock;
 
 	mmap_read_lock(mm);
-	result = hugepage_vma_revalidate(mm, address, true, &vma, cc, HPAGE_PMD_ORDER);
+	*mmap_locked = true;
+	result = hugepage_vma_revalidate(mm, address, true, &vma, cc, order);
 	if (result != SCAN_SUCCEED) {
 		mmap_read_unlock(mm);
 		goto out_nolock;
@@ -1181,13 +1183,14 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 		 * released when it fails. So we jump out_nolock directly in
 		 * that case.  Continuing to collapse causes inconsistency.
 		 */
-		result = __collapse_huge_page_swapin(mm, vma, address, pmd,
-				referenced, HPAGE_PMD_ORDER);
+		result = __collapse_huge_page_swapin(mm, vma, _address, pmd,
+				referenced, order);
 		if (result != SCAN_SUCCEED)
 			goto out_nolock;
 	}
 
 	mmap_read_unlock(mm);
+	*mmap_locked = false;
 	/*
 	 * Prevent all access to pagetables with the exception of
 	 * gup_fast later handled by the ptep_clear_flush and the VM
@@ -1197,7 +1200,7 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 	 * mmap_lock.
 	 */
 	mmap_write_lock(mm);
-	result = hugepage_vma_revalidate(mm, address, true, &vma, cc, HPAGE_PMD_ORDER);
+	result = hugepage_vma_revalidate(mm, address, true, &vma, cc, order);
 	if (result != SCAN_SUCCEED)
 		goto out_up_write;
 	/* check if the pmd is still valid */
@@ -1208,11 +1211,12 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 	vma_start_write(vma);
 	anon_vma_lock_write(vma->anon_vma);
 
-	mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, address,
-				address + HPAGE_PMD_SIZE);
+	mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, _address,
+				_address + (PAGE_SIZE << order));
 	mmu_notifier_invalidate_range_start(&range);
 
 	pmd_ptl = pmd_lock(mm, pmd); /* probably unnecessary */
+
 	/*
 	 * This removes any huge TLB entry from the CPU so we won't allow
 	 * huge and small TLB entries for the same virtual address to
@@ -1226,18 +1230,16 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 	mmu_notifier_invalidate_range_end(&range);
 	tlb_remove_table_sync_one();
 
-	pte = pte_offset_map_lock(mm, &_pmd, address, &pte_ptl);
+	pte = pte_offset_map_lock(mm, &_pmd, _address, &pte_ptl);
 	if (pte) {
-		result = __collapse_huge_page_isolate(vma, address, pte, cc,
-					&compound_pagelist, HPAGE_PMD_ORDER);
+		result = __collapse_huge_page_isolate(vma, _address, pte, cc,
+					&compound_pagelist, order);
 		spin_unlock(pte_ptl);
 	} else {
 		result = SCAN_PMD_NULL;
 	}
 
 	if (unlikely(result != SCAN_SUCCEED)) {
-		if (pte)
-			pte_unmap(pte);
 		spin_lock(pmd_ptl);
 		BUG_ON(!pmd_none(*pmd));
 		/*
@@ -1258,9 +1260,8 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 	anon_vma_unlock_write(vma->anon_vma);
 
 	result = __collapse_huge_page_copy(pte, folio, pmd, _pmd,
-					   vma, address, pte_ptl,
-					   &compound_pagelist, HPAGE_PMD_ORDER);
-	pte_unmap(pte);
+					   vma, _address, pte_ptl,
+					   &compound_pagelist, order);
 	if (unlikely(result != SCAN_SUCCEED))
 		goto out_up_write;
 
@@ -1270,25 +1271,42 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 	 * write.
 	 */
 	__folio_mark_uptodate(folio);
-	pgtable = pmd_pgtable(_pmd);
-
-	_pmd = folio_mk_pmd(folio, vma->vm_page_prot);
-	_pmd = maybe_pmd_mkwrite(pmd_mkdirty(_pmd), vma);
-
-	spin_lock(pmd_ptl);
-	BUG_ON(!pmd_none(*pmd));
-	folio_add_new_anon_rmap(folio, vma, address, RMAP_EXCLUSIVE);
-	folio_add_lru_vma(folio, vma);
-	pgtable_trans_huge_deposit(mm, pmd, pgtable);
-	set_pmd_at(mm, address, pmd, _pmd);
-	update_mmu_cache_pmd(vma, address, pmd);
-	deferred_split_folio(folio, false);
-	spin_unlock(pmd_ptl);
+	if (order == HPAGE_PMD_ORDER) {
+		pgtable = pmd_pgtable(_pmd);
+		_pmd = folio_mk_pmd(folio, vma->vm_page_prot);
+		_pmd = maybe_pmd_mkwrite(pmd_mkdirty(_pmd), vma);
+
+		spin_lock(pmd_ptl);
+		BUG_ON(!pmd_none(*pmd));
+		folio_add_new_anon_rmap(folio, vma, _address, RMAP_EXCLUSIVE);
+		folio_add_lru_vma(folio, vma);
+		pgtable_trans_huge_deposit(mm, pmd, pgtable);
+		set_pmd_at(mm, address, pmd, _pmd);
+		update_mmu_cache_pmd(vma, address, pmd);
+		deferred_split_folio(folio, false);
+		spin_unlock(pmd_ptl);
+	} else { /* mTHP collapse */
+		mthp_pte = mk_pte(&folio->page, vma->vm_page_prot);
+		mthp_pte = maybe_mkwrite(pte_mkdirty(mthp_pte), vma);
+
+		spin_lock(pmd_ptl);
+		folio_ref_add(folio, (1 << order) - 1);
+		folio_add_new_anon_rmap(folio, vma, _address, RMAP_EXCLUSIVE);
+		folio_add_lru_vma(folio, vma);
+		set_ptes(vma->vm_mm, _address, pte, mthp_pte, (1 << order));
+		update_mmu_cache_range(NULL, vma, _address, pte, (1 << order));
+
+		smp_wmb(); /* make pte visible before pmd */
+		pmd_populate(mm, pmd, pmd_pgtable(_pmd));
+		spin_unlock(pmd_ptl);
+	}
 
 	folio = NULL;
 
 	result = SCAN_SUCCEED;
 out_up_write:
+	if (pte)
+		pte_unmap(pte);
 	mmap_write_unlock(mm);
 out_nolock:
 	*mmap_locked = false;
@@ -1364,31 +1382,58 @@ static int khugepaged_scan_pmd(struct mm_struct *mm,
 {
 	pmd_t *pmd;
 	pte_t *pte, *_pte;
+	int i;
 	int result = SCAN_FAIL, referenced = 0;
 	int none_or_zero = 0, shared = 0;
 	struct page *page = NULL;
 	struct folio *folio = NULL;
 	unsigned long _address;
+	unsigned long enabled_orders;
 	spinlock_t *ptl;
 	int node = NUMA_NO_NODE, unmapped = 0;
+	bool is_pmd_only;
 	bool writable = false;
-
+	int chunk_none_count = 0;
+	int scaled_none = khugepaged_max_ptes_none >> (HPAGE_PMD_ORDER - KHUGEPAGED_MIN_MTHP_ORDER);
+	unsigned long tva_flags = cc->is_khugepaged ? TVA_ENFORCE_SYSFS : 0;
 	VM_BUG_ON(address & ~HPAGE_PMD_MASK);
 
 	result = find_pmd_or_thp_or_none(mm, address, &pmd);
 	if (result != SCAN_SUCCEED)
 		goto out;
 
+	bitmap_zero(cc->mthp_bitmap, MAX_MTHP_BITMAP_SIZE);
+	bitmap_zero(cc->mthp_bitmap_temp, MAX_MTHP_BITMAP_SIZE);
 	memset(cc->node_load, 0, sizeof(cc->node_load));
 	nodes_clear(cc->alloc_nmask);
+
+	enabled_orders = thp_vma_allowable_orders(vma, vma->vm_flags,
+		tva_flags, THP_ORDERS_ALL_ANON);
+
+	is_pmd_only = (enabled_orders == (1 << HPAGE_PMD_ORDER));
+
 	pte = pte_offset_map_lock(mm, pmd, address, &ptl);
 	if (!pte) {
 		result = SCAN_PMD_NULL;
 		goto out;
 	}
 
-	for (_address = address, _pte = pte; _pte < pte + HPAGE_PMD_NR;
-	     _pte++, _address += PAGE_SIZE) {
+	for (i = 0; i < HPAGE_PMD_NR; i++) {
+		/*
+		 * we are reading in KHUGEPAGED_MIN_MTHP_NR page chunks. if
+		 * there are pages in this chunk keep track of it in the bitmap
+		 * for mTHP collapsing.
+		 */
+		if (i % KHUGEPAGED_MIN_MTHP_NR == 0) {
+			if (chunk_none_count <= scaled_none)
+				bitmap_set(cc->mthp_bitmap,
+					   i / KHUGEPAGED_MIN_MTHP_NR, 1);
+
+			chunk_none_count = 0;
+		}
+
+		_pte = pte + i;
+		_address = address + i * PAGE_SIZE;
 		pte_t pteval = ptep_get(_pte);
 		if (is_swap_pte(pteval)) {
 			++unmapped;
@@ -1411,10 +1456,11 @@ static int khugepaged_scan_pmd(struct mm_struct *mm,
 			}
 		}
 		if (pte_none(pteval) || is_zero_pfn(pte_pfn(pteval))) {
+			++chunk_none_count;
 			++none_or_zero;
 			if (!userfaultfd_armed(vma) &&
-			    (!cc->is_khugepaged ||
-			     none_or_zero <= khugepaged_max_ptes_none)) {
+			    (!cc->is_khugepaged || !is_pmd_only ||
+				none_or_zero <= khugepaged_max_ptes_none)) {
 				continue;
 			} else {
 				result = SCAN_EXCEED_NONE_PTE;
@@ -1510,6 +1556,7 @@ static int khugepaged_scan_pmd(struct mm_struct *mm,
 								     address)))
 			referenced++;
 	}
+
 	if (!writable) {
 		result = SCAN_PAGE_RO;
 	} else if (cc->is_khugepaged &&
@@ -1522,8 +1569,12 @@ static int khugepaged_scan_pmd(struct mm_struct *mm,
 out_unmap:
 	pte_unmap_unlock(pte, ptl);
 	if (result == SCAN_SUCCEED) {
-		result = collapse_huge_page(mm, address, referenced,
-					    unmapped, cc, mmap_locked, HPAGE_PMD_ORDER, 0);
+		result = khugepaged_scan_bitmap(mm, address, referenced, unmapped, cc,
+			       mmap_locked, enabled_orders);
+		if (result > 0)
+			result = SCAN_SUCCEED;
+		else
+			result = SCAN_FAIL;
 	}
 out:
 	trace_mm_khugepaged_scan_pmd(mm, &folio->page, writable, referenced,
Signature · 1 line
2.48.1
#17 lore raw

Re: [PATCH v5 07/12] khugepaged: add mTHP support

Quoted 14 lines · Nico Pache

Introduce the ability for khugepaged to collapse to different mTHP sizes. While scanning PMD ranges for potential collapse candidates, keep track of pages in KHUGEPAGED_MIN_MTHP_ORDER chunks via a bitmap. Each bit represents a utilized region of order KHUGEPAGED_MIN_MTHP_ORDER ptes. If mTHPs are enabled we remove the restriction of max_ptes_none during the scan phase so we dont bailout early and miss potential mTHP candidates.

After the scan is complete we will perform binary recursion on the bitmap to determine which mTHP size would be most efficient to collapse to. max_ptes_none will be scaled by the attempted collapse order to determine how full a THP must be to be eligible.

If a mTHP collapse is attempted, but contains swapped out, or shared pages, we dont perform the collapse.

[...]

Quoted 5 lines
mm/khugepaged.c +0 -1
@@ -1208,11 +1211,12 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
        vma_start_write(vma);
        anon_vma_lock_write(vma->anon_vma);
 
-       mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, address,

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1222

Quoted 10 lines
mm/khugepaged.c +3 -1
-                               address + HPAGE_PMD_SIZE);
+       mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, _address,
+                               _address + (PAGE_SIZE << order));
        mmu_notifier_invalidate_range_start(&range);
 
        pmd_ptl = pmd_lock(mm, pmd); /* probably unnecessary */
+
        /*
         * This removes any huge TLB entry from the CPU so we won't allow
         * huge and small TLB entries for the same virtual address to

It's not visible in this diff, but we're about to do a pmdp_collapse_flush() here. pmdp_collapse_flush() tears down the entire page table, meaning it tears down 2MiB of address space; and it assumes that the entire page table exclusively corresponds to the current VMA.

I think you'll need to ensure that the pmdp_collapse_flush() only happens for full-size THP, and that mTHP only tears down individual PTEs in the relevant range. (That code might get a bit messy, since the existing THP code tears down PTEs in a detached page table, while mTHP would have to do it in a still-attached page table.)

author
#18 lore raw

Re: [PATCH v5 07/12] khugepaged: add mTHP support

Quoted 39 lines · Jann Horn
Quoted 14 lines · Nico Pache

Introduce the ability for khugepaged to collapse to different mTHP sizes. While scanning PMD ranges for potential collapse candidates, keep track of pages in KHUGEPAGED_MIN_MTHP_ORDER chunks via a bitmap. Each bit represents a utilized region of order KHUGEPAGED_MIN_MTHP_ORDER ptes. If mTHPs are enabled we remove the restriction of max_ptes_none during the scan phase so we dont bailout early and miss potential mTHP candidates.

After the scan is complete we will perform binary recursion on the bitmap to determine which mTHP size would be most efficient to collapse to. max_ptes_none will be scaled by the attempted collapse order to determine how full a THP must be to be eligible.

If a mTHP collapse is attempted, but contains swapped out, or shared pages, we dont perform the collapse.

[...]

Quoted 5 lines
mm/khugepaged.c +0 -1
@@ -1208,11 +1211,12 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
        vma_start_write(vma);
        anon_vma_lock_write(vma->anon_vma);
 
-       mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, address,

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1222

Quoted 10 lines
mm/khugepaged.c +3 -1
-                               address + HPAGE_PMD_SIZE);
+       mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, _address,
+                               _address + (PAGE_SIZE << order));
        mmu_notifier_invalidate_range_start(&range);
 
        pmd_ptl = pmd_lock(mm, pmd); /* probably unnecessary */
+
        /*
         * This removes any huge TLB entry from the CPU so we won't allow
         * huge and small TLB entries for the same virtual address to

It's not visible in this diff, but we're about to do a pmdp_collapse_flush() here. pmdp_collapse_flush() tears down the entire page table, meaning it tears down 2MiB of address space; and it assumes that the entire page table exclusively corresponds to the current VMA.

Quoted 5 lines

I think you'll need to ensure that the pmdp_collapse_flush() only happens for full-size THP, and that mTHP only tears down individual PTEs in the relevant range. (That code might get a bit messy, since the existing THP code tears down PTEs in a detached page table, while mTHP would have to do it in a still-attached page table.)

Hi Jann!

I was under the impression that this is needed to prevent GUP-fast races (and potentially others).
As you state here, conceptually the PMD case is, detach the PMD, do the collapse, then reinstall the PMD (similarly to how the system recovers from a failed PMD collapse). I tried to keep the current locking behavior as it seemed the easiest way to get it right (and not break anything). So I keep the PMD detaching and reinstalling for the mTHP case too. As Hugh points out I am releasing the anon lock too early. I will comment further on his response.

As I familiarize myself with the code more, I do see potential code improvements/cleanups and locking improvements, but I was going to leave those to a later series.

Thanks
-- Nico

Quoted 1 line
#19 lore raw

Re: [PATCH v5 07/12] khugepaged: add mTHP support

Quoted 57 lines · Nico Pache
Quoted 39 lines · Jann Horn
Quoted 14 lines · Nico Pache

Introduce the ability for khugepaged to collapse to different mTHP sizes. While scanning PMD ranges for potential collapse candidates, keep track of pages in KHUGEPAGED_MIN_MTHP_ORDER chunks via a bitmap. Each bit represents a utilized region of order KHUGEPAGED_MIN_MTHP_ORDER ptes. If mTHPs are enabled we remove the restriction of max_ptes_none during the scan phase so we dont bailout early and miss potential mTHP candidates.

After the scan is complete we will perform binary recursion on the bitmap to determine which mTHP size would be most efficient to collapse to. max_ptes_none will be scaled by the attempted collapse order to determine how full a THP must be to be eligible.

If a mTHP collapse is attempted, but contains swapped out, or shared pages, we dont perform the collapse.

[...]

Quoted 5 lines
mm/khugepaged.c +0 -1
@@ -1208,11 +1211,12 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
         vma_start_write(vma);
         anon_vma_lock_write(vma->anon_vma);
 
-       mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, address,

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1222

Quoted 10 lines
mm/khugepaged.c +3 -1
-                               address + HPAGE_PMD_SIZE);
+       mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, _address,
+                               _address + (PAGE_SIZE << order));
         mmu_notifier_invalidate_range_start(&range);
 
         pmd_ptl = pmd_lock(mm, pmd); /* probably unnecessary */
+
         /*
          * This removes any huge TLB entry from the CPU so we won't allow
          * huge and small TLB entries for the same virtual address to

It's not visible in this diff, but we're about to do a pmdp_collapse_flush() here. pmdp_collapse_flush() tears down the entire page table, meaning it tears down 2MiB of address space; and it assumes that the entire page table exclusively corresponds to the current VMA.

Quoted 5 lines

I think you'll need to ensure that the pmdp_collapse_flush() only happens for full-size THP, and that mTHP only tears down individual PTEs in the relevant range. (That code might get a bit messy, since the existing THP code tears down PTEs in a detached page table, while mTHP would have to do it in a still-attached page table.)

Hi Jann!

I was under the impression that this is needed to prevent GUP-fast races (and potentially others).
As you state here, conceptually the PMD case is, detach the PMD, do the collapse, then reinstall the PMD (similarly to how the system recovers from a failed PMD collapse). I tried to keep the current locking behavior as it seemed the easiest way to get it right (and not break anything). So I keep the PMD detaching and reinstalling for the mTHP case too. As Hugh points out I am releasing the anon lock too early. I will comment further on his response.

Quoted 3 lines

As I familiarize myself with the code more, I do see potential code improvements/cleanups and locking improvements, but I was going to leave those to a later series.

Right, the simplest approach on top of the current PMD collapse is to do exactly what we do in the PMD case, including the locking: which apparently is no completely the same yet :).

Instead of installing a PMD THP, we modify the page table and remap that.

Moving from the PMD lock to the PTE lock will not make a big change in practice for most cases: we already must disable essentially all page table walkers (vma lock, mmap lock in write, rmap lock in write).

The PMDP clear+flush is primarily to disable the last possible set of page table walkers: (1) HW modifications and (2) GUP-fast.

So after the PMDP clear+flush we know that (A) HW can not modify the pages concurrently and (B) GUP-fast cannot succeed anymore.

The issue with PTEP clear+flush is that we will have to remember all PTE values, to reset them if anything goes wrong. Using a single PMD value is arguably simpler. And then, the benefit vs. complexity is unclear.

Certainly something to look into later, but not a requirement for the first support,

The real challenge/benefit will be looking into avoiding taking all the heavy weight locks. Dev has already been thinking about that. For mTHP it might be easier than for THPs. Probably it will involve setting PTE migration entries whenever we drop the PTL, and dealing with the possibility of concurrent zapping of these migration entries.

Signature · 3 lines
Cheers,

David / dhildenb
#20 lore raw

Re: [PATCH v5 07/12] khugepaged: add mTHP support

Quoted 46 lines · David Hildenbrand
Quoted 45 lines · Nico Pache
Quoted 44 lines · Jann Horn
Quoted 14 lines · Nico Pache

Introduce the ability for khugepaged to collapse to different mTHP sizes. While scanning PMD ranges for potential collapse candidates, keep track of pages in KHUGEPAGED_MIN_MTHP_ORDER chunks via a bitmap. Each bit represents a utilized region of order KHUGEPAGED_MIN_MTHP_ORDER ptes. If mTHPs are enabled we remove the restriction of max_ptes_none during the scan phase so we dont bailout early and miss potential mTHP candidates.

After the scan is complete we will perform binary recursion on the bitmap to determine which mTHP size would be most efficient to collapse to. max_ptes_none will be scaled by the attempted collapse order to determine how full a THP must be to be eligible.

If a mTHP collapse is attempted, but contains swapped out, or shared pages, we dont perform the collapse.

[...]

Quoted 5 lines
mm/khugepaged.c +0 -1
@@ -1208,11 +1211,12 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
         vma_start_write(vma);
         anon_vma_lock_write(vma->anon_vma);
 
-       mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, address,

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1222

Quoted 10 lines
mm/khugepaged.c +3 -1
-                               address + HPAGE_PMD_SIZE);
+       mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, _address,
+                               _address + (PAGE_SIZE << order));
         mmu_notifier_invalidate_range_start(&range);
 
         pmd_ptl = pmd_lock(mm, pmd); /* probably unnecessary */
+
         /*
          * This removes any huge TLB entry from the CPU so we won't allow
          * huge and small TLB entries for the same virtual address to

It's not visible in this diff, but we're about to do a pmdp_collapse_flush() here. pmdp_collapse_flush() tears down the entire page table, meaning it tears down 2MiB of address space; and it assumes that the entire page table exclusively corresponds to the current VMA.

I think you'll need to ensure that the pmdp_collapse_flush() only happens for full-size THP, and that mTHP only tears down individual PTEs in the relevant range. (That code might get a bit messy, since the existing THP code tears down PTEs in a detached page table, while mTHP would have to do it in a still-attached page table.)

Quoted 4 lines
Quoted 4 lines

Hi Jann!

I was under the impression that this is needed to prevent GUP-fast races (and potentially others).

Why would you need to touch the PMD entry to prevent GUP-fast races for mTHP?

Quoted 7 lines
Quoted 7 lines

As you state here, conceptually the PMD case is, detach the PMD, do the collapse, then reinstall the PMD (similarly to how the system recovers from a failed PMD collapse). I tried to keep the current locking behavior as it seemed the easiest way to get it right (and not break anything). So I keep the PMD detaching and reinstalling for the mTHP case too. As Hugh points out I am releasing the anon lock too early. I will comment further on his response.

As I see it, you're not "keeping" the current locking behavior; you're making a big implicit locking change by reusing a codepath designed for PMD THP for mTHP, where the page table may not be exclusively owned by one VMA.

Quoted 20 lines
Quoted 3 lines

As I familiarize myself with the code more, I do see potential code improvements/cleanups and locking improvements, but I was going to leave those to a later series.

Right, the simplest approach on top of the current PMD collapse is to do exactly what we do in the PMD case, including the locking: which apparently is no completely the same yet :).

Instead of installing a PMD THP, we modify the page table and remap that.

Moving from the PMD lock to the PTE lock will not make a big change in practice for most cases: we already must disable essentially all page table walkers (vma lock, mmap lock in write, rmap lock in write).

The PMDP clear+flush is primarily to disable the last possible set of page table walkers: (1) HW modifications and (2) GUP-fast.

So after the PMDP clear+flush we know that (A) HW can not modify the pages concurrently and (B) GUP-fast cannot succeed anymore.

Quoted 6 lines

The issue with PTEP clear+flush is that we will have to remember all PTE values, to reset them if anything goes wrong. Using a single PMD value is arguably simpler. And then, the benefit vs. complexity is unclear.

Certainly something to look into later, but not a requirement for the first support,

As I understand, one rule we currently have in MM is that an operation that logically operates on one VMA (VMA 1) does not touch the page tables of other VMAs (VMA 2) in any way, except that it may walk page tables that cover address space that intersects with both VMA 1 and VMA 2, and create such page tables if they are missing.

This proposed patch changes that, without explicitly discussing this locking change.

Just as one example: I think this patch retracts a page table without VMA-locking the relevant address space (we hold a VMA lock on VMA 1, but not on VMA 2), and we then drop the PMD lock after (temporarily) retracting the page table. At that point, I think a racing fault that uses the VMA-locked fastpath can observe the empty PMD, and can install a new page table? Then when collapse_huge_page() tries to re-add the retracted page table, I think we'll get a BUG_ON(). Similar thing with concurrent ftruncate() or such trying to zap PTEs, we can probably end up not zapping PTEs that should have been zapped?

Quoted 5 lines

The real challenge/benefit will be looking into avoiding taking all the heavy weight locks. Dev has already been thinking about that. For mTHP it might be easier than for THPs. Probably it will involve setting PTE migration entries whenever we drop the PTL, and dealing with the possibility of concurrent zapping of these migration entries.

#21 lore raw

Re: [PATCH v5 07/12] khugepaged: add mTHP support

Quoted 62 lines · Jann Horn
Quoted 46 lines · David Hildenbrand
Quoted 45 lines · Nico Pache
Quoted 44 lines · Jann Horn
Quoted 14 lines · Nico Pache

Introduce the ability for khugepaged to collapse to different mTHP sizes. While scanning PMD ranges for potential collapse candidates, keep track of pages in KHUGEPAGED_MIN_MTHP_ORDER chunks via a bitmap. Each bit represents a utilized region of order KHUGEPAGED_MIN_MTHP_ORDER ptes. If mTHPs are enabled we remove the restriction of max_ptes_none during the scan phase so we dont bailout early and miss potential mTHP candidates.

After the scan is complete we will perform binary recursion on the bitmap to determine which mTHP size would be most efficient to collapse to. max_ptes_none will be scaled by the attempted collapse order to determine how full a THP must be to be eligible.

If a mTHP collapse is attempted, but contains swapped out, or shared pages, we dont perform the collapse.

[...]

Quoted 5 lines
mm/khugepaged.c +0 -1
@@ -1208,11 +1211,12 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
          vma_start_write(vma);
          anon_vma_lock_write(vma->anon_vma);
 
-       mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, address,

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1222

Quoted 10 lines
mm/khugepaged.c +3 -1
-                               address + HPAGE_PMD_SIZE);
+       mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, _address,
+                               _address + (PAGE_SIZE << order));
          mmu_notifier_invalidate_range_start(&range);
 
          pmd_ptl = pmd_lock(mm, pmd); /* probably unnecessary */
+
          /*
           * This removes any huge TLB entry from the CPU so we won't allow
           * huge and small TLB entries for the same virtual address to

It's not visible in this diff, but we're about to do a pmdp_collapse_flush() here. pmdp_collapse_flush() tears down the entire page table, meaning it tears down 2MiB of address space; and it assumes that the entire page table exclusively corresponds to the current VMA.

I think you'll need to ensure that the pmdp_collapse_flush() only happens for full-size THP, and that mTHP only tears down individual PTEs in the relevant range. (That code might get a bit messy, since the existing THP code tears down PTEs in a detached page table, while mTHP would have to do it in a still-attached page table.)

Quoted 4 lines
Quoted 4 lines

Hi Jann!

I was under the impression that this is needed to prevent GUP-fast races (and potentially others).

Why would you need to touch the PMD entry to prevent GUP-fast races for mTHP?

Quoted 7 lines
Quoted 7 lines

As you state here, conceptually the PMD case is, detach the PMD, do the collapse, then reinstall the PMD (similarly to how the system recovers from a failed PMD collapse). I tried to keep the current locking behavior as it seemed the easiest way to get it right (and not break anything). So I keep the PMD detaching and reinstalling for the mTHP case too. As Hugh points out I am releasing the anon lock too early. I will comment further on his response.

Quoted 4 lines

As I see it, you're not "keeping" the current locking behavior; you're making a big implicit locking change by reusing a codepath designed for PMD THP for mTHP, where the page table may not be exclusively owned by one VMA.

That is not the intention. The intention in this series (at least as we discussed) was to not do it across VMAs; that is considered the next logical step (which will be especially relevant on arm64 IMHO).

Quoted 25 lines
Quoted 25 lines
Quoted 4 lines

As I familiarize myself with the code more, I do see potential code improvements/cleanups and locking improvements, but I was going to leave those to a later series.

Right, the simplest approach on top of the current PMD collapse is to do exactly what we do in the PMD case, including the locking: which apparently is no completely the same yet :).

Instead of installing a PMD THP, we modify the page table and remap that.

Moving from the PMD lock to the PTE lock will not make a big change in practice for most cases: we already must disable essentially all page table walkers (vma lock, mmap lock in write, rmap lock in write).

The PMDP clear+flush is primarily to disable the last possible set of page table walkers: (1) HW modifications and (2) GUP-fast.

So after the PMDP clear+flush we know that (A) HW can not modify the pages concurrently and (B) GUP-fast cannot succeed anymore.

The issue with PTEP clear+flush is that we will have to remember all PTE values, to reset them if anything goes wrong. Using a single PMD value is arguably simpler. And then, the benefit vs. complexity is unclear.

Quoted 8 lines
Quoted 2 lines

Certainly something to look into later, but not a requirement for the first support,

As I understand, one rule we currently have in MM is that an operation that logically operates on one VMA (VMA 1) does not touch the page tables of other VMAs (VMA 2) in any way, except that it may walk page tables that cover address space that intersects with both VMA 1 and VMA 2, and create such page tables if they are missing.

Yes, absolutely. That must not happen. And I think I raised it as a problem in reply to one of Dev's series.

If this series does not rely on that it must be fixed.

Quoted 3 lines

This proposed patch changes that, without explicitly discussing this locking change.

Yes, that must not happen. We must not zap a PMD to temporarily replace it with a pmd_none() entry if any other sane page table walker could stumble over it.

This includes another VMA that is not write-locked that could span the PMD.

Signature · 3 lines
Cheers,

David / dhildenb
#22 lore raw

Re: [PATCH v5 07/12] khugepaged: add mTHP support

Quoted 112 lines · David Hildenbrand
Quoted 62 lines · Jann Horn
Quoted 46 lines · David Hildenbrand
Quoted 45 lines · Nico Pache
Quoted 44 lines · Jann Horn
Quoted 14 lines · Nico Pache

Introduce the ability for khugepaged to collapse to different mTHP sizes. While scanning PMD ranges for potential collapse candidates, keep track of pages in KHUGEPAGED_MIN_MTHP_ORDER chunks via a bitmap. Each bit represents a utilized region of order KHUGEPAGED_MIN_MTHP_ORDER ptes. If mTHPs are enabled we remove the restriction of max_ptes_none during the scan phase so we dont bailout early and miss potential mTHP candidates.

After the scan is complete we will perform binary recursion on the bitmap to determine which mTHP size would be most efficient to collapse to. max_ptes_none will be scaled by the attempted collapse order to determine how full a THP must be to be eligible.

If a mTHP collapse is attempted, but contains swapped out, or shared pages, we dont perform the collapse.

[...]

Quoted 5 lines
mm/khugepaged.c +0 -1
@@ -1208,11 +1211,12 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
          vma_start_write(vma);
          anon_vma_lock_write(vma->anon_vma);
 
-       mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, address,

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1222

Quoted 10 lines
mm/khugepaged.c +3 -1
-                               address + HPAGE_PMD_SIZE);
+       mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, _address,
+                               _address + (PAGE_SIZE << order));
          mmu_notifier_invalidate_range_start(&range);
 
          pmd_ptl = pmd_lock(mm, pmd); /* probably unnecessary */
+
          /*
           * This removes any huge TLB entry from the CPU so we won't allow
           * huge and small TLB entries for the same virtual address to

It's not visible in this diff, but we're about to do a pmdp_collapse_flush() here. pmdp_collapse_flush() tears down the entire page table, meaning it tears down 2MiB of address space; and it assumes that the entire page table exclusively corresponds to the current VMA.

I think you'll need to ensure that the pmdp_collapse_flush() only happens for full-size THP, and that mTHP only tears down individual PTEs in the relevant range. (That code might get a bit messy, since the existing THP code tears down PTEs in a detached page table, while mTHP would have to do it in a still-attached page table.)

Quoted 4 lines
Quoted 4 lines

Hi Jann!

I was under the impression that this is needed to prevent GUP-fast races (and potentially others).

Why would you need to touch the PMD entry to prevent GUP-fast races for mTHP?

Quoted 7 lines
Quoted 7 lines

As you state here, conceptually the PMD case is, detach the PMD, do the collapse, then reinstall the PMD (similarly to how the system recovers from a failed PMD collapse). I tried to keep the current locking behavior as it seemed the easiest way to get it right (and not break anything). So I keep the PMD detaching and reinstalling for the mTHP case too. As Hugh points out I am releasing the anon lock too early. I will comment further on his response.

Quoted 4 lines

As I see it, you're not "keeping" the current locking behavior; you're making a big implicit locking change by reusing a codepath designed for PMD THP for mTHP, where the page table may not be exclusively owned by one VMA.

That is not the intention. The intention in this series (at least as we discussed) was to not do it across VMAs; that is considered the next logical step (which will be especially relevant on arm64 IMHO).

Quoted 25 lines
Quoted 25 lines
Quoted 4 lines

As I familiarize myself with the code more, I do see potential code improvements/cleanups and locking improvements, but I was going to leave those to a later series.

Right, the simplest approach on top of the current PMD collapse is to do exactly what we do in the PMD case, including the locking: which apparently is no completely the same yet :).

Instead of installing a PMD THP, we modify the page table and remap that.

Moving from the PMD lock to the PTE lock will not make a big change in practice for most cases: we already must disable essentially all page table walkers (vma lock, mmap lock in write, rmap lock in write).

The PMDP clear+flush is primarily to disable the last possible set of page table walkers: (1) HW modifications and (2) GUP-fast.

So after the PMDP clear+flush we know that (A) HW can not modify the pages concurrently and (B) GUP-fast cannot succeed anymore.

The issue with PTEP clear+flush is that we will have to remember all PTE values, to reset them if anything goes wrong. Using a single PMD value is arguably simpler. And then, the benefit vs. complexity is unclear.

Quoted 8 lines
Quoted 2 lines

Certainly something to look into later, but not a requirement for the first support,

As I understand, one rule we currently have in MM is that an operation that logically operates on one VMA (VMA 1) does not touch the page tables of other VMAs (VMA 2) in any way, except that it may walk page tables that cover address space that intersects with both VMA 1 and VMA 2, and create such page tables if they are missing.

Yes, absolutely. That must not happen. And I think I raised it as a problem in reply to one of Dev's series.

If this series does not rely on that it must be fixed.

Quoted 1 line
Quoted 8 lines
Quoted 2 lines

This proposed patch changes that, without explicitly discussing this locking change.

Yes, that must not happen. We must not zap a PMD to temporarily replace it with a pmd_none() entry if any other sane page table walker could stumble over it.

This includes another VMA that is not write-locked that could span the PMD.

I feel like we should document these restrictions somewhere :)

Perhaps in a new page table walker doc, or on the
https://origin.kernel.org/doc/html/latest/mm/process_addrs.html page.

Which sounds like I'm volunteering myself to do so doesn't it...

[adds to todo...]

Quoted 6 lines

--
Cheers,

David / dhildenb

#23 lore raw

Re: [PATCH v5 07/12] khugepaged: add mTHP support

Quoted 122 lines · Lorenzo Stoakes
Quoted 112 lines · David Hildenbrand
Quoted 62 lines · Jann Horn
Quoted 46 lines · David Hildenbrand
Quoted 45 lines · Nico Pache
Quoted 44 lines · Jann Horn
Quoted 14 lines · Nico Pache

Introduce the ability for khugepaged to collapse to different mTHP sizes. While scanning PMD ranges for potential collapse candidates, keep track of pages in KHUGEPAGED_MIN_MTHP_ORDER chunks via a bitmap. Each bit represents a utilized region of order KHUGEPAGED_MIN_MTHP_ORDER ptes. If mTHPs are enabled we remove the restriction of max_ptes_none during the scan phase so we dont bailout early and miss potential mTHP candidates.

After the scan is complete we will perform binary recursion on the bitmap to determine which mTHP size would be most efficient to collapse to. max_ptes_none will be scaled by the attempted collapse order to determine how full a THP must be to be eligible.

If a mTHP collapse is attempted, but contains swapped out, or shared pages, we dont perform the collapse.

[...]

Quoted 5 lines
(quoted diff) +0 -1
@@ -1208,11 +1211,12 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
           vma_start_write(vma);
           anon_vma_lock_write(vma->anon_vma);
 
-       mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, address,

Review static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1222

Quoted 10 lines
(quoted diff) +3 -1
-                               address + HPAGE_PMD_SIZE);
+       mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, _address,
+                               _address + (PAGE_SIZE << order));
           mmu_notifier_invalidate_range_start(&range);
 
           pmd_ptl = pmd_lock(mm, pmd); /* probably unnecessary */
+
           /*
            * This removes any huge TLB entry from the CPU so we won't allow
            * huge and small TLB entries for the same virtual address to

It's not visible in this diff, but we're about to do a pmdp_collapse_flush() here. pmdp_collapse_flush() tears down the entire page table, meaning it tears down 2MiB of address space; and it assumes that the entire page table exclusively corresponds to the current VMA.

I think you'll need to ensure that the pmdp_collapse_flush() only happens for full-size THP, and that mTHP only tears down individual PTEs in the relevant range. (That code might get a bit messy, since the existing THP code tears down PTEs in a detached page table, while mTHP would have to do it in a still-attached page table.)

Quoted 4 lines
Quoted 4 lines

Hi Jann!

I was under the impression that this is needed to prevent GUP-fast races (and potentially others).

Why would you need to touch the PMD entry to prevent GUP-fast races for mTHP?

Quoted 7 lines
Quoted 7 lines

As you state here, conceptually the PMD case is, detach the PMD, do the collapse, then reinstall the PMD (similarly to how the system recovers from a failed PMD collapse). I tried to keep the current locking behavior as it seemed the easiest way to get it right (and not break anything). So I keep the PMD detaching and reinstalling for the mTHP case too. As Hugh points out I am releasing the anon lock too early. I will comment further on his response.

Quoted 4 lines

As I see it, you're not "keeping" the current locking behavior; you're making a big implicit locking change by reusing a codepath designed for PMD THP for mTHP, where the page table may not be exclusively owned by one VMA.

That is not the intention. The intention in this series (at least as we discussed) was to not do it across VMAs; that is considered the next logical step (which will be especially relevant on arm64 IMHO).

Quoted 25 lines
Quoted 25 lines
Quoted 4 lines

As I familiarize myself with the code more, I do see potential code improvements/cleanups and locking improvements, but I was going to leave those to a later series.

Right, the simplest approach on top of the current PMD collapse is to do exactly what we do in the PMD case, including the locking: which apparently is no completely the same yet :).

Instead of installing a PMD THP, we modify the page table and remap that.

Moving from the PMD lock to the PTE lock will not make a big change in practice for most cases: we already must disable essentially all page table walkers (vma lock, mmap lock in write, rmap lock in write).

The PMDP clear+flush is primarily to disable the last possible set of page table walkers: (1) HW modifications and (2) GUP-fast.

So after the PMDP clear+flush we know that (A) HW can not modify the pages concurrently and (B) GUP-fast cannot succeed anymore.

The issue with PTEP clear+flush is that we will have to remember all PTE values, to reset them if anything goes wrong. Using a single PMD value is arguably simpler. And then, the benefit vs. complexity is unclear.

Quoted 8 lines
Quoted 2 lines

Certainly something to look into later, but not a requirement for the first support,

As I understand, one rule we currently have in MM is that an operation that logically operates on one VMA (VMA 1) does not touch the page tables of other VMAs (VMA 2) in any way, except that it may walk page tables that cover address space that intersects with both VMA 1 and VMA 2, and create such page tables if they are missing.

Yes, absolutely. That must not happen. And I think I raised it as a problem in reply to one of Dev's series.

If this series does not rely on that it must be fixed.

Quoted 1 line
Quoted 8 lines
Quoted 2 lines

This proposed patch changes that, without explicitly discussing this locking change.

Yes, that must not happen. We must not zap a PMD to temporarily replace it with a pmd_none() entry if any other sane page table walker could stumble over it.

This includes another VMA that is not write-locked that could span the PMD.

Quoted 8 lines

I feel like we should document these restrictions somewhere :)

Perhaps in a new page table walker doc, or on the
https://origin.kernel.org/doc/html/latest/mm/process_addrs.html page.

Which sounds like I'm volunteering myself to do so doesn't it...

[adds to todo...]

:) that would be nice.

Yeah, I mean this is very subtle, but essentially: unless you exclude all page table walkers (well, okay, HW and GUP-fast are a bit special), temporarily replacing a present PTE by pte_none() will cause trouble. Same for PMDs.

That's also one of the problems of looking into only using the PTE table lock and not any other heavy-weight locking in khugepaged. As soon as we temporarily unlock the PTE table, but have to temporarily unmap the PTEs (->pte_none()) as well, we need something else (e.g., migration entry) to tell other page table walkers to back off and wait for us to re-take the PTL lock and finish. Zapping must still be able to continue, at which point it gets hairy ...

... which is why I'm hoping that we can play with that once we have the basics running. With the intend of reusing the existing locking scheme -> single VMA spans the PMD.

Signature · 3 lines
Cheers,

David / dhildenb
#24 lore raw

Re: [PATCH v5 07/12] khugepaged: add mTHP support

In reply to David Hildenbrand
Quoted 64 lines · David Hildenbrand
Quoted 62 lines · Jann Horn
Quoted 46 lines · David Hildenbrand
Quoted 45 lines · Nico Pache
Quoted 44 lines · Jann Horn
Quoted 14 lines · Nico Pache

Introduce the ability for khugepaged to collapse to different mTHP sizes. While scanning PMD ranges for potential collapse candidates, keep track of pages in KHUGEPAGED_MIN_MTHP_ORDER chunks via a bitmap. Each bit represents a utilized region of order KHUGEPAGED_MIN_MTHP_ORDER ptes. If mTHPs are enabled we remove the restriction of max_ptes_none during the scan phase so we dont bailout early and miss potential mTHP candidates.

After the scan is complete we will perform binary recursion on the bitmap to determine which mTHP size would be most efficient to collapse to. max_ptes_none will be scaled by the attempted collapse order to determine how full a THP must be to be eligible.

If a mTHP collapse is attempted, but contains swapped out, or shared pages, we dont perform the collapse.

[...]

Quoted 5 lines
mm/khugepaged.c +0 -1
@@ -1208,11 +1211,12 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
          vma_start_write(vma);
          anon_vma_lock_write(vma->anon_vma);
 
-       mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, address,

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1222

Quoted 10 lines
mm/khugepaged.c +3 -1
-                               address + HPAGE_PMD_SIZE);
+       mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, _address,
+                               _address + (PAGE_SIZE << order));
          mmu_notifier_invalidate_range_start(&range);
 
          pmd_ptl = pmd_lock(mm, pmd); /* probably unnecessary */
+
          /*
           * This removes any huge TLB entry from the CPU so we won't allow
           * huge and small TLB entries for the same virtual address to

It's not visible in this diff, but we're about to do a pmdp_collapse_flush() here. pmdp_collapse_flush() tears down the entire page table, meaning it tears down 2MiB of address space; and it assumes that the entire page table exclusively corresponds to the current VMA.

I think you'll need to ensure that the pmdp_collapse_flush() only happens for full-size THP, and that mTHP only tears down individual PTEs in the relevant range. (That code might get a bit messy, since the existing THP code tears down PTEs in a detached page table, while mTHP would have to do it in a still-attached page table.)

Quoted 4 lines
Quoted 4 lines

Hi Jann!

I was under the impression that this is needed to prevent GUP-fast races (and potentially others).

Why would you need to touch the PMD entry to prevent GUP-fast races for mTHP?

Quoted 7 lines
Quoted 7 lines

As you state here, conceptually the PMD case is, detach the PMD, do the collapse, then reinstall the PMD (similarly to how the system recovers from a failed PMD collapse). I tried to keep the current locking behavior as it seemed the easiest way to get it right (and not break anything). So I keep the PMD detaching and reinstalling for the mTHP case too. As Hugh points out I am releasing the anon lock too early. I will comment further on his response.

Quoted 8 lines
Quoted 4 lines

As I see it, you're not "keeping" the current locking behavior; you're making a big implicit locking change by reusing a codepath designed for PMD THP for mTHP, where the page table may not be exclusively owned by one VMA.

That is not the intention. The intention in this series (at least as we discussed) was to not do it across VMAs; that is considered the next logical step (which will be especially relevant on arm64 IMHO).

Ah, so for now this is supposed to only work for PTEs which are in a PMD which is fully covered by the VMA? So if I make a 16KiB VMA and then try to collapse its contents to an order-2 mTHP page, that should just not work?

author
#25 lore raw

Re: [PATCH v5 07/12] khugepaged: add mTHP support

Quoted 71 lines · Jann Horn
Quoted 69 lines · David Hildenbrand
Quoted 66 lines · Jann Horn
Quoted 46 lines · David Hildenbrand
Quoted 45 lines · Nico Pache
Quoted 44 lines · Jann Horn
Quoted 14 lines · Nico Pache

Introduce the ability for khugepaged to collapse to different mTHP sizes. While scanning PMD ranges for potential collapse candidates, keep track of pages in KHUGEPAGED_MIN_MTHP_ORDER chunks via a bitmap. Each bit represents a utilized region of order KHUGEPAGED_MIN_MTHP_ORDER ptes. If mTHPs are enabled we remove the restriction of max_ptes_none during the scan phase so we dont bailout early and miss potential mTHP candidates.

After the scan is complete we will perform binary recursion on the bitmap to determine which mTHP size would be most efficient to collapse to. max_ptes_none will be scaled by the attempted collapse order to determine how full a THP must be to be eligible.

If a mTHP collapse is attempted, but contains swapped out, or shared pages, we dont perform the collapse.

[...]

Quoted 5 lines
(quoted diff) +0 -1
@@ -1208,11 +1211,12 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
          vma_start_write(vma);
          anon_vma_lock_write(vma->anon_vma);
 
-       mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, address,

Review static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1222

Quoted 10 lines
(quoted diff) +3 -1
-                               address + HPAGE_PMD_SIZE);
+       mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, _address,
+                               _address + (PAGE_SIZE << order));
          mmu_notifier_invalidate_range_start(&range);
 
          pmd_ptl = pmd_lock(mm, pmd); /* probably unnecessary */
+
          /*
           * This removes any huge TLB entry from the CPU so we won't allow
           * huge and small TLB entries for the same virtual address to

It's not visible in this diff, but we're about to do a pmdp_collapse_flush() here. pmdp_collapse_flush() tears down the entire page table, meaning it tears down 2MiB of address space; and it assumes that the entire page table exclusively corresponds to the current VMA.

I think you'll need to ensure that the pmdp_collapse_flush() only happens for full-size THP, and that mTHP only tears down individual PTEs in the relevant range. (That code might get a bit messy, since the existing THP code tears down PTEs in a detached page table, while mTHP would have to do it in a still-attached page table.)

Quoted 4 lines
Quoted 4 lines

Hi Jann!

I was under the impression that this is needed to prevent GUP-fast races (and potentially others).

Why would you need to touch the PMD entry to prevent GUP-fast races for mTHP?

Quoted 7 lines
Quoted 7 lines

As you state here, conceptually the PMD case is, detach the PMD, do the collapse, then reinstall the PMD (similarly to how the system recovers from a failed PMD collapse). I tried to keep the current locking behavior as it seemed the easiest way to get it right (and not break anything). So I keep the PMD detaching and reinstalling for the mTHP case too. As Hugh points out I am releasing the anon lock too early. I will comment further on his response.

As I see it, you're not "keeping" the current locking behavior; you're making a big implicit locking change by reusing a codepath designed for PMD THP for mTHP, where the page table may not be exclusively owned by one VMA.

Quoted 8 lines
Quoted 3 lines

That is not the intention. The intention in this series (at least as we discussed) was to not do it across VMAs; that is considered the next logical step (which will be especially relevant on arm64 IMHO).

Ah, so for now this is supposed to only work for PTEs which are in a PMD which is fully covered by the VMA? So if I make a 16KiB VMA and then try to collapse its contents to an order-2 mTHP page, that should just not work?

Correct! As I started in reply to Hugh, the locking conditions explode if we drop that requirement. A simple workaround we've considered is only collapsing if a single VMA intersects a PMD. I can make sure this is more clear in the coverletter + this patch.

Cheers,
-- Nico

Quoted 1 line
#26 lore raw

Re: [PATCH v5 07/12] khugepaged: add mTHP support

Quoted 76 lines · Nico Pache
Quoted 75 lines · Jann Horn
Quoted 72 lines · David Hildenbrand
Quoted 62 lines · Jann Horn
Quoted 46 lines · David Hildenbrand
Quoted 45 lines · Nico Pache
Quoted 44 lines · Jann Horn
Quoted 14 lines · Nico Pache

Introduce the ability for khugepaged to collapse to different mTHP sizes. While scanning PMD ranges for potential collapse candidates, keep track of pages in KHUGEPAGED_MIN_MTHP_ORDER chunks via a bitmap. Each bit represents a utilized region of order KHUGEPAGED_MIN_MTHP_ORDER ptes. If mTHPs are enabled we remove the restriction of max_ptes_none during the scan phase so we dont bailout early and miss potential mTHP candidates.

After the scan is complete we will perform binary recursion on the bitmap to determine which mTHP size would be most efficient to collapse to. max_ptes_none will be scaled by the attempted collapse order to determine how full a THP must be to be eligible.

If a mTHP collapse is attempted, but contains swapped out, or shared pages, we dont perform the collapse.

[...]

Quoted 5 lines
(quoted diff) +0 -1
@@ -1208,11 +1211,12 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
           vma_start_write(vma);
           anon_vma_lock_write(vma->anon_vma);
 
-       mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, address,

Review static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1222

Quoted 10 lines
(quoted diff) +3 -1
-                               address + HPAGE_PMD_SIZE);
+       mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, _address,
+                               _address + (PAGE_SIZE << order));
           mmu_notifier_invalidate_range_start(&range);
 
           pmd_ptl = pmd_lock(mm, pmd); /* probably unnecessary */
+
           /*
            * This removes any huge TLB entry from the CPU so we won't allow
            * huge and small TLB entries for the same virtual address to

It's not visible in this diff, but we're about to do a pmdp_collapse_flush() here. pmdp_collapse_flush() tears down the entire page table, meaning it tears down 2MiB of address space; and it assumes that the entire page table exclusively corresponds to the current VMA.

I think you'll need to ensure that the pmdp_collapse_flush() only happens for full-size THP, and that mTHP only tears down individual PTEs in the relevant range. (That code might get a bit messy, since the existing THP code tears down PTEs in a detached page table, while mTHP would have to do it in a still-attached page table.)

Quoted 4 lines
Quoted 4 lines

Hi Jann!

I was under the impression that this is needed to prevent GUP-fast races (and potentially others).

Why would you need to touch the PMD entry to prevent GUP-fast races for mTHP?

Quoted 7 lines
Quoted 7 lines

As you state here, conceptually the PMD case is, detach the PMD, do the collapse, then reinstall the PMD (similarly to how the system recovers from a failed PMD collapse). I tried to keep the current locking behavior as it seemed the easiest way to get it right (and not break anything). So I keep the PMD detaching and reinstalling for the mTHP case too. As Hugh points out I am releasing the anon lock too early. I will comment further on his response.

Quoted 4 lines

As I see it, you're not "keeping" the current locking behavior; you're making a big implicit locking change by reusing a codepath designed for PMD THP for mTHP, where the page table may not be exclusively owned by one VMA.

That is not the intention. The intention in this series (at least as we discussed) was to not do it across VMAs; that is considered the next logical step (which will be especially relevant on arm64 IMHO).

Quoted 6 lines
Quoted 4 lines

Ah, so for now this is supposed to only work for PTEs which are in a PMD which is fully covered by the VMA? So if I make a 16KiB VMA and then try to collapse its contents to an order-2 mTHP page, that should just not work?

Correct! As I started in reply to Hugh, the locking conditions explode if we drop that requirement.

Right. Adding to that, one could evaluate how much we would gain by trying to lock, say, up to $MAGIC_NUMBER related VMAs.

Of course, if no other VMA spans the PMD, and the VMA only covers it partially, it is likely still fine as long as we hold the mmap lock in write mode.

But probably, looking into a different locking scheme would be beneficial at this point.

Signature · 3 lines
Cheers,

David / dhildenb
#27 lore raw

Re: [PATCH v5 07/12] khugepaged: add mTHP support

In reply to Nico Pache
Quoted 12 lines · Nico Pache

Introduce the ability for khugepaged to collapse to different mTHP sizes. While scanning PMD ranges for potential collapse candidates, keep track of pages in KHUGEPAGED_MIN_MTHP_ORDER chunks via a bitmap. Each bit represents a utilized region of order KHUGEPAGED_MIN_MTHP_ORDER ptes. If mTHPs are enabled we remove the restriction of max_ptes_none during the scan phase so we dont bailout early and miss potential mTHP candidates.

After the scan is complete we will perform binary recursion on the bitmap to determine which mTHP size would be most efficient to collapse to. max_ptes_none will be scaled by the attempted collapse order to determine how full a THP must be to be eligible.

Quoted 4 lines

If a mTHP collapse is attempted, but contains swapped out, or shared pages, we dont perform the collapse.

There are locking errors in this patch. Let me comment inline below, then at the end append the fix patch I'm using, to keep mm-new usable for me. But that's more of an emergency rescue than a recommended fixup:
I don't much like your approach here, and hope it will change in v6.

Quoted 9 lines
---
 mm/khugepaged.c | 125 ++++++++++++++++++++++++++++++++++--------------
 1 file changed, 88 insertions(+), 37 deletions(-)
mm/khugepaged.c +0 -0
index 6e67db86409a..3a846cd70c66 100644

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1139

Quoted 5 lines
mm/khugepaged.c +1 -1
@@ -1136,13 +1136,14 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 {
 	LIST_HEAD(compound_pagelist);
 	pmd_t *pmd, _pmd;
-	pte_t *pte;
+	pte_t *pte, mthp_pte;

I didn't wait to see the problem, just noticed that in the v4->v5 update, pte gets used at out_up_write, but there are gotos before pte has been initialized. Declare pte = NULL here.

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address,

Quoted 53 lines
mm/khugepaged.c +8 -5
 	pgtable_t pgtable;
 	struct folio *folio;
 	spinlock_t *pmd_ptl, *pte_ptl;
 	int result = SCAN_FAIL;
 	struct vm_area_struct *vma;
 	struct mmu_notifier_range range;
+	unsigned long _address = address + offset * PAGE_SIZE;
 
 	VM_BUG_ON(address & ~HPAGE_PMD_MASK);
 
@@ -1158,12 +1159,13 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 		*mmap_locked = false;
 	}
 
-	result = alloc_charge_folio(&folio, mm, cc, HPAGE_PMD_ORDER);
+	result = alloc_charge_folio(&folio, mm, cc, order);
 	if (result != SCAN_SUCCEED)
 		goto out_nolock;
 
 	mmap_read_lock(mm);
-	result = hugepage_vma_revalidate(mm, address, true, &vma, cc, HPAGE_PMD_ORDER);
+	*mmap_locked = true;
+	result = hugepage_vma_revalidate(mm, address, true, &vma, cc, order);
 	if (result != SCAN_SUCCEED) {
 		mmap_read_unlock(mm);
 		goto out_nolock;
@@ -1181,13 +1183,14 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 		 * released when it fails. So we jump out_nolock directly in
 		 * that case.  Continuing to collapse causes inconsistency.
 		 */
-		result = __collapse_huge_page_swapin(mm, vma, address, pmd,
-				referenced, HPAGE_PMD_ORDER);
+		result = __collapse_huge_page_swapin(mm, vma, _address, pmd,
+				referenced, order);
 		if (result != SCAN_SUCCEED)
 			goto out_nolock;
 	}
 
 	mmap_read_unlock(mm);
+	*mmap_locked = false;
 	/*
 	 * Prevent all access to pagetables with the exception of
 	 * gup_fast later handled by the ptep_clear_flush and the VM
@@ -1197,7 +1200,7 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 	 * mmap_lock.
 	 */
 	mmap_write_lock(mm);
-	result = hugepage_vma_revalidate(mm, address, true, &vma, cc, HPAGE_PMD_ORDER);
+	result = hugepage_vma_revalidate(mm, address, true, &vma, cc, order);
 	if (result != SCAN_SUCCEED)
 		goto out_up_write;
 	/* check if the pmd is still valid */
@@ -1208,11 +1211,12 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,

I spent a long time trying to work out why the include/linux/swapops.h:511 BUG is soon hit - the BUG which tells there's a migration entry left behind after its folio has been unlocked.

In the patch at the end you'll see that I've inserted a check here, to abort if the VMA following the revalidated "vma" is sharing the page table (and so also affected by clearing *pmd). That turned out not to be the problem (WARN_ONs inserted never fired in my limited testing), but it still looks to me as if some such check is needed. Or I may be wrong, and "revalidate" (a better place for the check) does actually check that, but it wasn't obvious, and I haven't spent more time looking at it (but it did appear to rule out the case of a VMA before "vma" sharing the page table).

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1215

Quoted 7 lines
mm/khugepaged.c +2 -2
 	vma_start_write(vma);
 	anon_vma_lock_write(vma->anon_vma);
 
-	mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, address,
-				address + HPAGE_PMD_SIZE);
+	mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, _address,
+				_address + (PAGE_SIZE << order));

mmu_notifiers tend to be rather a mystery to me, so I've made no change below, but it's not obvious whether it's correct clear the *pmd but only notify of clearing a subset of that range: what's outside the range soon gets replaced as it was, but is that good enough? I don't know.

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1222

Quoted 7 lines
mm/khugepaged.c +1 -0
 	mmu_notifier_invalidate_range_start(&range);
 
 	pmd_ptl = pmd_lock(mm, pmd); /* probably unnecessary */
+
 	/*
 	 * This removes any huge TLB entry from the CPU so we won't allow
 	 * huge and small TLB entries for the same virtual address to

The line I want to comment on does not appear in this diff context:

	_pmd = pmdp_collapse_flush(vma, address, pmd);

That is appropriate for a THP occupying the whole range of the page table, but is a surprising way to handle an "mTHP" of just some of its ptes:
I would expect you to be invalidating and replacing just those.

And that is the cause of the swapops:511 BUGs: "uninvolved" ptes are being temporarily hidden, so not found when remove_migration_ptes() goes looking for them.

This reliance on pmdp_collapse_flush() can be rescued, with stricter locking (comment below); but I don't like it, and notice Jann has picked up on it too. I hope v6 switches to handling ptes by ptes.

Quoted 23 lines
mm/khugepaged.c +3 -5
@@ -1226,18 +1230,16 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 	mmu_notifier_invalidate_range_end(&range);
 	tlb_remove_table_sync_one();
 
-	pte = pte_offset_map_lock(mm, &_pmd, address, &pte_ptl);
+	pte = pte_offset_map_lock(mm, &_pmd, _address, &pte_ptl);
 	if (pte) {
-		result = __collapse_huge_page_isolate(vma, address, pte, cc,
-					&compound_pagelist, HPAGE_PMD_ORDER);
+		result = __collapse_huge_page_isolate(vma, _address, pte, cc,
+					&compound_pagelist, order);
 		spin_unlock(pte_ptl);
 	} else {
 		result = SCAN_PMD_NULL;
 	}
 
 	if (unlikely(result != SCAN_SUCCEED)) {
-		if (pte)
-			pte_unmap(pte);
 		spin_lock(pmd_ptl);
 		BUG_ON(!pmd_none(*pmd));
 		/*

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1260

Quoted 1 line
mm/khugepaged.c +0 -0
@@ -1258,9 +1260,8 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 	anon_vma_unlock_write(vma->anon_vma);

Phew, it's just visible there in the context. The anon_vma lock is what keeps out racing lookups; so, that anon_vma_unlock_write() (and its "All pages are isolated and locked" comment) is appropriate in the HPAGE_PMD_SIZEd THP case, but has to be left until later for mTHP ptes.

But the anon_vma lock may well span a much larger range than the pte lock, and the pmd lock certainly spans a much larger range than the pte lock; so we really prefer to release anon_vma lock and pmd lock as soon as is safe, and use pte lock in preference where possible.

Quoted 37 lines
mm/khugepaged.c +11 -17
 	result = __collapse_huge_page_copy(pte, folio, pmd, _pmd,
-					   vma, address, pte_ptl,
-					   &compound_pagelist, HPAGE_PMD_ORDER);
-	pte_unmap(pte);
+					   vma, _address, pte_ptl,
+					   &compound_pagelist, order);
 	if (unlikely(result != SCAN_SUCCEED))
 		goto out_up_write;
 
@@ -1270,25 +1271,42 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 	 * write.
 	 */
 	__folio_mark_uptodate(folio);
-	pgtable = pmd_pgtable(_pmd);
-
-	_pmd = folio_mk_pmd(folio, vma->vm_page_prot);
-	_pmd = maybe_pmd_mkwrite(pmd_mkdirty(_pmd), vma);
-
-	spin_lock(pmd_ptl);
-	BUG_ON(!pmd_none(*pmd));
-	folio_add_new_anon_rmap(folio, vma, address, RMAP_EXCLUSIVE);
-	folio_add_lru_vma(folio, vma);
-	pgtable_trans_huge_deposit(mm, pmd, pgtable);
-	set_pmd_at(mm, address, pmd, _pmd);
-	update_mmu_cache_pmd(vma, address, pmd);
-	deferred_split_folio(folio, false);
-	spin_unlock(pmd_ptl);
+	if (order == HPAGE_PMD_ORDER) {
+		pgtable = pmd_pgtable(_pmd);
+		_pmd = folio_mk_pmd(folio, vma->vm_page_prot);
+		_pmd = maybe_pmd_mkwrite(pmd_mkdirty(_pmd), vma);
+
+		spin_lock(pmd_ptl);
+		BUG_ON(!pmd_none(*pmd));
+		folio_add_new_anon_rmap(folio, vma, _address, RMAP_EXCLUSIVE);
+		folio_add_lru_vma(folio, vma);

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1292

Quoted 10 lines
mm/khugepaged.c +10 -0
+		pgtable_trans_huge_deposit(mm, pmd, pgtable);
+		set_pmd_at(mm, address, pmd, _pmd);
+		update_mmu_cache_pmd(vma, address, pmd);
+		deferred_split_folio(folio, false);
+		spin_unlock(pmd_ptl);
+	} else { /* mTHP collapse */
+		mthp_pte = mk_pte(&folio->page, vma->vm_page_prot);
+		mthp_pte = maybe_mkwrite(pte_mkdirty(mthp_pte), vma);
+
+		spin_lock(pmd_ptl);

I haven't changed that, but it is odd: yes, pmd_ptl will be required when doing the pmd_populate(), but it serves no purpose here when fiddling around with ptes in a disconnected page table.

Quoted 4 lines
mm/khugepaged.c +4 -0
+		folio_ref_add(folio, (1 << order) - 1);
+		folio_add_new_anon_rmap(folio, vma, _address, RMAP_EXCLUSIVE);
+		folio_add_lru_vma(folio, vma);
+		set_ptes(vma->vm_mm, _address, pte, mthp_pte, (1 << order));

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1306

Quoted 10 lines
mm/khugepaged.c +6 -0
+		update_mmu_cache_range(NULL, vma, _address, pte, (1 << order));
+
+		smp_wmb(); /* make pte visible before pmd */
+		pmd_populate(mm, pmd, pmd_pgtable(_pmd));
+		spin_unlock(pmd_ptl);
+	}
 
 	folio = NULL;
 
 	result = SCAN_SUCCEED;

Somewhere around here it becomes safe for mTHP to anon_vma_unlock_write().

Quoted 107 lines
mm/khugepaged.c +42 -7
 out_up_write:
+	if (pte)
+		pte_unmap(pte);
 	mmap_write_unlock(mm);
 out_nolock:
 	*mmap_locked = false;
@@ -1364,31 +1382,58 @@ static int khugepaged_scan_pmd(struct mm_struct *mm,
 {
 	pmd_t *pmd;
 	pte_t *pte, *_pte;
+	int i;
 	int result = SCAN_FAIL, referenced = 0;
 	int none_or_zero = 0, shared = 0;
 	struct page *page = NULL;
 	struct folio *folio = NULL;
 	unsigned long _address;
+	unsigned long enabled_orders;
 	spinlock_t *ptl;
 	int node = NUMA_NO_NODE, unmapped = 0;
+	bool is_pmd_only;
 	bool writable = false;
-
+	int chunk_none_count = 0;
+	int scaled_none = khugepaged_max_ptes_none >> (HPAGE_PMD_ORDER - KHUGEPAGED_MIN_MTHP_ORDER);
+	unsigned long tva_flags = cc->is_khugepaged ? TVA_ENFORCE_SYSFS : 0;
 	VM_BUG_ON(address & ~HPAGE_PMD_MASK);
 
 	result = find_pmd_or_thp_or_none(mm, address, &pmd);
 	if (result != SCAN_SUCCEED)
 		goto out;
 
+	bitmap_zero(cc->mthp_bitmap, MAX_MTHP_BITMAP_SIZE);
+	bitmap_zero(cc->mthp_bitmap_temp, MAX_MTHP_BITMAP_SIZE);
 	memset(cc->node_load, 0, sizeof(cc->node_load));
 	nodes_clear(cc->alloc_nmask);
+
+	enabled_orders = thp_vma_allowable_orders(vma, vma->vm_flags,
+		tva_flags, THP_ORDERS_ALL_ANON);
+
+	is_pmd_only = (enabled_orders == (1 << HPAGE_PMD_ORDER));
+
 	pte = pte_offset_map_lock(mm, pmd, address, &ptl);
 	if (!pte) {
 		result = SCAN_PMD_NULL;
 		goto out;
 	}
 
-	for (_address = address, _pte = pte; _pte < pte + HPAGE_PMD_NR;
-	     _pte++, _address += PAGE_SIZE) {
+	for (i = 0; i < HPAGE_PMD_NR; i++) {
+		/*
+		 * we are reading in KHUGEPAGED_MIN_MTHP_NR page chunks. if
+		 * there are pages in this chunk keep track of it in the bitmap
+		 * for mTHP collapsing.
+		 */
+		if (i % KHUGEPAGED_MIN_MTHP_NR == 0) {
+			if (chunk_none_count <= scaled_none)
+				bitmap_set(cc->mthp_bitmap,
+					   i / KHUGEPAGED_MIN_MTHP_NR, 1);
+
+			chunk_none_count = 0;
+		}
+
+		_pte = pte + i;
+		_address = address + i * PAGE_SIZE;
 		pte_t pteval = ptep_get(_pte);
 		if (is_swap_pte(pteval)) {
 			++unmapped;
@@ -1411,10 +1456,11 @@ static int khugepaged_scan_pmd(struct mm_struct *mm,
 			}
 		}
 		if (pte_none(pteval) || is_zero_pfn(pte_pfn(pteval))) {
+			++chunk_none_count;
 			++none_or_zero;
 			if (!userfaultfd_armed(vma) &&
-			    (!cc->is_khugepaged ||
-			     none_or_zero <= khugepaged_max_ptes_none)) {
+			    (!cc->is_khugepaged || !is_pmd_only ||
+				none_or_zero <= khugepaged_max_ptes_none)) {
 				continue;
 			} else {
 				result = SCAN_EXCEED_NONE_PTE;
@@ -1510,6 +1556,7 @@ static int khugepaged_scan_pmd(struct mm_struct *mm,
 								     address)))
 			referenced++;
 	}
+
 	if (!writable) {
 		result = SCAN_PAGE_RO;
 	} else if (cc->is_khugepaged &&
@@ -1522,8 +1569,12 @@ static int khugepaged_scan_pmd(struct mm_struct *mm,
 out_unmap:
 	pte_unmap_unlock(pte, ptl);
 	if (result == SCAN_SUCCEED) {
-		result = collapse_huge_page(mm, address, referenced,
-					    unmapped, cc, mmap_locked, HPAGE_PMD_ORDER, 0);
+		result = khugepaged_scan_bitmap(mm, address, referenced, unmapped, cc,
+			       mmap_locked, enabled_orders);
+		if (result > 0)
+			result = SCAN_SUCCEED;
+		else
+			result = SCAN_FAIL;
 	}
 out:
 	trace_mm_khugepaged_scan_pmd(mm, &folio->page, writable, referenced,
Signature · 1 line
2.48.1

Fixes to 07/12 "khugepaged: add mTHP support".
But I see now that the first hunk is actually not to this 07/12, but to 05/12 "khugepaged: generalize __collapse_huge_page_* for mTHP support":
the mTHP check added in __collapse_huge_page_swapin() forgets to unmap and unlock before returning, causing RCU imbalance warnings and lockups. I won't separate it out here, let me leave that to you.

And I had other fixes to v4, which you've fixed differently in v5, I haven't looked up which patch: where khugepaged_collapse_single_pmd() does mmap_read_(un)lock() around collapse_pte_mapped_thp(). I dislike your special use of result SCAN_ANY_PROCESS there, because mmap_locked is precisely the tool for that job, so just lock and unlock without setting *mmap_locked true (but I'd agree that mmap_locked is confusing, and offhand wouldn't want to assert exactly what it means - does it mean that mmap lock was *never* dropped, so "vma" is safe without revalidation? depends on where it's used perhaps).

Hugh

---
 mm/khugepaged.c | 32 +++++++++++++++++++++++++++-----
 1 file changed, 27 insertions(+), 5 deletions(-)
mm/khugepaged.c +27 -5
index c1c637dbcb81..2c814c239d65 100644
@@ -1054,6 +1054,8 @@ static int __collapse_huge_page_swapin(struct mm_struct *mm,
 
 		/* Dont swapin for mTHP collapse */
 		if (order != HPAGE_PMD_ORDER) {
+			pte_unmap(pte);
+			mmap_read_unlock(mm);
 			result = SCAN_EXCEED_SWAP_PTE;
 			goto out;
 		}
@@ -1136,7 +1138,7 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 {
 	LIST_HEAD(compound_pagelist);
 	pmd_t *pmd, _pmd;
-	pte_t *pte, mthp_pte;
+	pte_t *pte = NULL, mthp_pte;
 	pgtable_t pgtable;
 	struct folio *folio;
 	spinlock_t *pmd_ptl, *pte_ptl;
@@ -1208,6 +1210,21 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 	if (result != SCAN_SUCCEED)
 		goto out_up_write;
 
+	if (vma->vm_end < address + HPAGE_PMD_SIZE) {
+		struct vm_area_struct *next_vma = find_vma(mm, vma->vm_end);
+		/*
+		 * We must not clear *pmd if it is used by the following VMA.
+		 * Well, perhaps we could if it, and all following VMAs using
+		 * this same page table, share the same anon_vma, and so are
+		 * locked out together: but keep it simple for now (and this
+		 * code might better belong in hugepage_vma_revalidate()).
+		 */
+		if (next_vma && next_vma->vm_start < address + HPAGE_PMD_SIZE) {
+			result = SCAN_ADDRESS_RANGE;
+			goto out_up_write;
+		}
+	}
+
 	vma_start_write(vma);
 	anon_vma_lock_write(vma->anon_vma);
 
@@ -1255,15 +1272,17 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 
 	/*
 	 * All pages are isolated and locked so anon_vma rmap
-	 * can't run anymore.
-	 */
-	anon_vma_unlock_write(vma->anon_vma);
+	 * can't run anymore - IF the entire extent has been isolated.
+	 * anon_vma lock may cover a large area: better unlock a.s.a.p.
+	 */	
+	if (order == HPAGE_PMD_ORDER)
+		anon_vma_unlock_write(vma->anon_vma);
 
 	result = __collapse_huge_page_copy(pte, folio, pmd, _pmd,
 					   vma, _address, pte_ptl,
 					   &compound_pagelist, order);
 	if (unlikely(result != SCAN_SUCCEED))
-		goto out_up_write;
+		goto out_unlock_anon_vma;
 
 	/*
 	 * The smp_wmb() inside __folio_mark_uptodate() ensures the
@@ -1304,6 +1323,9 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 	folio = NULL;
 
 	result = SCAN_SUCCEED;
+out_unlock_anon_vma:
+	if (order != HPAGE_PMD_ORDER)
+		anon_vma_unlock_write(vma->anon_vma);
 out_up_write:
 	if (pte)
 		pte_unmap(pte);
Signature · 1 line
2.43.0
maintainer
#28 lore raw

Re: [PATCH v5 07/12] khugepaged: add mTHP support

Quoted 1 line · On Thu, 1 May 2025 05:58:40 -0700 (PDT) Hugh Dickins <[email protected]> wrote:

There are locking errors in this patch.

Thanks, Hugh. I'll remove the v5 series from mm-new.

author
#29 lore raw

Re: [PATCH v5 07/12] khugepaged: add mTHP support

In reply to Hugh Dickins
Quoted 18 lines · Hugh Dickins
Quoted 15 lines · Nico Pache

Introduce the ability for khugepaged to collapse to different mTHP sizes. While scanning PMD ranges for potential collapse candidates, keep track of pages in KHUGEPAGED_MIN_MTHP_ORDER chunks via a bitmap. Each bit represents a utilized region of order KHUGEPAGED_MIN_MTHP_ORDER ptes. If mTHPs are enabled we remove the restriction of max_ptes_none during the scan phase so we dont bailout early and miss potential mTHP candidates.

After the scan is complete we will perform binary recursion on the bitmap to determine which mTHP size would be most efficient to collapse to. max_ptes_none will be scaled by the attempted collapse order to determine how full a THP must be to be eligible.

If a mTHP collapse is attempted, but contains swapped out, or shared pages, we dont perform the collapse.

Quoted 6 lines
Quoted 1 line

There are locking errors in this patch. Let me comment inline below, then at the end append the fix patch I'm using, to keep mm-new usable for me. But that's more of an emergency rescue than a recommended fixup:
I don't much like your approach here, and hope it will change in v6.

Hi Hugh,

Thank you for testing, and providing such a detailed report + fix!

Quoted 5 lines
Quoted 5 lines
---
 mm/khugepaged.c | 125 ++++++++++++++++++++++++++++++++++--------------
 1 file changed, 88 insertions(+), 37 deletions(-)
Quoted 14 lines

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1139

Quoted 10 lines
mm/khugepaged.c +1 -1
index 6e67db86409a..3a846cd70c66 100644
@@ -1136,13 +1136,14 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 {
      LIST_HEAD(compound_pagelist);
      pmd_t *pmd, _pmd;
-     pte_t *pte;
+     pte_t *pte, mthp_pte;

I didn't wait to see the problem, just noticed that in the v4->v5 update, pte gets used at out_up_write, but there are gotos before pte has been initialized. Declare pte = NULL here.

Ah thanks I missed that when I moved the PTE unmapping to out_up_write.

Quoted 50 lines
Quoted 50 lines
mm/khugepaged.c +8 -5
      pgtable_t pgtable;
      struct folio *folio;
      spinlock_t *pmd_ptl, *pte_ptl;
      int result = SCAN_FAIL;
      struct vm_area_struct *vma;
      struct mmu_notifier_range range;
+     unsigned long _address = address + offset * PAGE_SIZE;
 
      VM_BUG_ON(address & ~HPAGE_PMD_MASK);
 
@@ -1158,12 +1159,13 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
              *mmap_locked = false;
      }
 
-     result = alloc_charge_folio(&folio, mm, cc, HPAGE_PMD_ORDER);
+     result = alloc_charge_folio(&folio, mm, cc, order);
      if (result != SCAN_SUCCEED)
              goto out_nolock;
 
      mmap_read_lock(mm);
-     result = hugepage_vma_revalidate(mm, address, true, &vma, cc, HPAGE_PMD_ORDER);
+     *mmap_locked = true;
+     result = hugepage_vma_revalidate(mm, address, true, &vma, cc, order);
      if (result != SCAN_SUCCEED) {
              mmap_read_unlock(mm);
              goto out_nolock;
@@ -1181,13 +1183,14 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
               * released when it fails. So we jump out_nolock directly in
               * that case.  Continuing to collapse causes inconsistency.
               */
-             result = __collapse_huge_page_swapin(mm, vma, address, pmd,
-                             referenced, HPAGE_PMD_ORDER);
+             result = __collapse_huge_page_swapin(mm, vma, _address, pmd,
+                             referenced, order);
              if (result != SCAN_SUCCEED)
                      goto out_nolock;
      }
 
      mmap_read_unlock(mm);
+     *mmap_locked = false;
      /*
       * Prevent all access to pagetables with the exception of
       * gup_fast later handled by the ptep_clear_flush and the VM
@@ -1197,7 +1200,7 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
       * mmap_lock.
       */
      mmap_write_lock(mm);
-     result = hugepage_vma_revalidate(mm, address, true, &vma, cc, HPAGE_PMD_ORDER);
+     result = hugepage_vma_revalidate(mm, address, true, &vma, cc, order);
Quoted 8 lines

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address,

Quoted 4 lines
mm/khugepaged.c +0 -0
      if (result != SCAN_SUCCEED)
              goto out_up_write;
      /* check if the pmd is still valid */
@@ -1208,11 +1211,12 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,

I spent a long time trying to work out why the include/linux/swapops.h:511 BUG is soon hit - the BUG which tells there's a migration entry left behind after its folio has been unlocked.

Can you please share how you reproduce the bug? I haven't been able to reproduce any BUGs with most of the memory debuggers enabled. This has also been through a number of mm test suites and some internal testing. So i'm curious how to hit this issue!

Quoted 9 lines

In the patch at the end you'll see that I've inserted a check here, to abort if the VMA following the revalidated "vma" is sharing the page table (and so also affected by clearing *pmd). That turned out not to be the problem (WARN_ONs inserted never fired in my limited testing), but it still looks to me as if some such check is needed. Or I may be wrong, and "revalidate" (a better place for the check) does actually check that, but it wasn't obvious, and I haven't spent more time looking at it (but it did appear to rule out the case of a VMA before "vma" sharing the page table

Hmm if I understand this correctly, the check you are adding is already being handled in the PMD case through thp_vma_suitable_order(s) (by checking that a PMD can fit in the VMA @address); however, I think you are correct, we much check that the VMA still spans the whole PMD region we are trying to a mTHP collapse within it... if not its possible that a mremap+mmap might have occured allowing a different mapping to belong to the same PMD (this also makes support mTHP collapse in mappings <PMD sized difficult and is the reason we haven't pursued it yet, the locking requires explode, the simple solutions is as you noted, only support <PMD sized collapses with a single VMA in the PMD range, this is a future change).

I actually realized my revalidation is rather weak... mostly because I'm passing the PMD address, not the mTHP starting address (see address vs _address in collapse_huge_page). I think your check would be handled if I pass it _address. If that was the case the following check would be performed in thp_vma_suitable_order:

if (haddr < vma->vm_start || haddr + hpage_size > vma->vm_end) return false;

Quoted 9 lines

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1215

Quoted 8 lines
mm/khugepaged.c +2 -2
      vma_start_write(vma);
      anon_vma_lock_write(vma->anon_vma);
 
-     mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, address,
-                             address + HPAGE_PMD_SIZE);
+     mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, _address,
+                             _address + (PAGE_SIZE << order));
Quoted 4 lines

mmu_notifiers tend to be rather a mystery to me, so I've made no change below, but it's not obvious whether it's correct clear the *pmd but only notify of clearing a subset of that range: what's outside the range soon gets replaced as it was, but is that good enough? I don't know.

Sadly I dont have a good answer for you as mmu_notifier is mostly a mystery to me too. I assume the anon_vma_lock_write would prevent any others from touching the pages we ARE NOT invalidating here, and that may be enough. Honestly I think the anon_vma_lock_write allows up to remove a lot of the locking (but as i stated im trying to keep the locking the *same* in this series).

Quoted 9 lines

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1222

Quoted 8 lines
mm/khugepaged.c +1 -0
      mmu_notifier_invalidate_range_start(&range);
 
      pmd_ptl = pmd_lock(mm, pmd); /* probably unnecessary */
+
      /*
       * This removes any huge TLB entry from the CPU so we won't allow
       * huge and small TLB entries for the same virtual address to
Quoted 6 lines

The line I want to comment on does not appear in this diff context:

        _pmd = pmdp_collapse_flush(vma, address, pmd);

That is appropriate for a THP occupying the whole range of the page table, but is a surprising way to handle an "mTHP" of just some of its ptes:
I would expect you to be invalidating and replacing just those.

The reason for leaving it in the mTHP case was to prevent the aforementioned GUP-fast race.
* Parallel GUP-fast is fine since GUP-fast will back off when
* it detects PMD is changed.

I tried to keep the same locking principles as the PMD case: remove the PMD, hold all the same locks, collapse to (m)THP, reinstall the PMD. This seems the easiest way to get it right and allowed me to focus on adding the feature. The codebase being scattered with mentions of potential races, and taking locks that might not be needed, also made me weary.

I know Dev was looking into optimizations for the locking, and I have some ideas of ways to improve it, or at least clean up some of the locking.

Quoted 8 lines

And that is the cause of the swapops:511 BUGs: "uninvolved" ptes are being temporarily hidden, so not found when remove_migration_ptes() goes looking for them.

This reliance on pmdp_collapse_flush() can be rescued, with stricter locking (comment below); but I don't like it, and notice Jann has picked up on it too. I hope v6 switches to handling ptes by ptes.

I believe the current approach with your anon_write_unlock fix would suffice (if the gup race is a valid reason to keep the pmd flush), and then we can follow up with locking improvements.

Quoted 17 lines
Quoted 17 lines
mm/khugepaged.c +3 -3
@@ -1226,18 +1230,16 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
      mmu_notifier_invalidate_range_end(&range);
      tlb_remove_table_sync_one();
 
-     pte = pte_offset_map_lock(mm, &_pmd, address, &pte_ptl);
+     pte = pte_offset_map_lock(mm, &_pmd, _address, &pte_ptl);
      if (pte) {
-             result = __collapse_huge_page_isolate(vma, address, pte, cc,
-                                     &compound_pagelist, HPAGE_PMD_ORDER);
+             result = __collapse_huge_page_isolate(vma, _address, pte, cc,
+                                     &compound_pagelist, order);
              spin_unlock(pte_ptl);
      } else {
              result = SCAN_PMD_NULL;
      }
 
Quoted 13 lines

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1260

Quoted 8 lines
mm/khugepaged.c +0 -2
      if (unlikely(result != SCAN_SUCCEED)) {
-             if (pte)
-                     pte_unmap(pte);
              spin_lock(pmd_ptl);
              BUG_ON(!pmd_none(*pmd));
              /*
@@ -1258,9 +1260,8 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
      anon_vma_unlock_write(vma->anon_vma);

Phew, it's just visible there in the context. The anon_vma lock is what keeps out racing lookups; so, that anon_vma_unlock_write() (and its "All pages are isolated and locked" comment) is appropriate in the HPAGE_PMD_SIZEd THP case, but has to be left until later for mTHP ptes.

Makes sense!

Quoted 49 lines

But the anon_vma lock may well span a much larger range than the pte lock, and the pmd lock certainly spans a much larger range than the pte lock; so we really prefer to release anon_vma lock and pmd lock as soon as is safe, and use pte lock in preference where possible.

Quoted 43 lines
mm/khugepaged.c +17 -17
      result = __collapse_huge_page_copy(pte, folio, pmd, _pmd,
-                                        vma, address, pte_ptl,
-                                        &compound_pagelist, HPAGE_PMD_ORDER);
-     pte_unmap(pte);
+                                        vma, _address, pte_ptl,
+                                        &compound_pagelist, order);
      if (unlikely(result != SCAN_SUCCEED))
              goto out_up_write;
 
@@ -1270,25 +1271,42 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
       * write.
       */
      __folio_mark_uptodate(folio);
-     pgtable = pmd_pgtable(_pmd);
-
-     _pmd = folio_mk_pmd(folio, vma->vm_page_prot);
-     _pmd = maybe_pmd_mkwrite(pmd_mkdirty(_pmd), vma);
-
-     spin_lock(pmd_ptl);
-     BUG_ON(!pmd_none(*pmd));
-     folio_add_new_anon_rmap(folio, vma, address, RMAP_EXCLUSIVE);
-     folio_add_lru_vma(folio, vma);
-     pgtable_trans_huge_deposit(mm, pmd, pgtable);
-     set_pmd_at(mm, address, pmd, _pmd);
-     update_mmu_cache_pmd(vma, address, pmd);
-     deferred_split_folio(folio, false);
-     spin_unlock(pmd_ptl);
+     if (order == HPAGE_PMD_ORDER) {
+             pgtable = pmd_pgtable(_pmd);
+             _pmd = folio_mk_pmd(folio, vma->vm_page_prot);
+             _pmd = maybe_pmd_mkwrite(pmd_mkdirty(_pmd), vma);
+
+             spin_lock(pmd_ptl);
+             BUG_ON(!pmd_none(*pmd));
+             folio_add_new_anon_rmap(folio, vma, _address, RMAP_EXCLUSIVE);
+             folio_add_lru_vma(folio, vma);
+             pgtable_trans_huge_deposit(mm, pmd, pgtable);
+             set_pmd_at(mm, address, pmd, _pmd);
+             update_mmu_cache_pmd(vma, address, pmd);
+             deferred_split_folio(folio, false);
+             spin_unlock(pmd_ptl);
+     } else { /* mTHP collapse */
Quoted 8 lines

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1292

Quoted 4 lines
mm/khugepaged.c +4 -0
+             mthp_pte = mk_pte(&folio->page, vma->vm_page_prot);
+             mthp_pte = maybe_mkwrite(pte_mkdirty(mthp_pte), vma);
+
+             spin_lock(pmd_ptl);

I haven't changed that, but it is odd: yes, pmd_ptl will be required when doing the pmd_populate(), but it serves no purpose here when fiddling around with ptes in a disconnected page table.

Yes I believe a lot of locking can be improved and some is unnecessary.

Quoted 124 lines
Quoted 5 lines
mm/khugepaged.c +4 -0
+             folio_ref_add(folio, (1 << order) - 1);
+             folio_add_new_anon_rmap(folio, vma, _address, RMAP_EXCLUSIVE);
+             folio_add_lru_vma(folio, vma);
+             set_ptes(vma->vm_mm, _address, pte, mthp_pte, (1 << order));

mm/khugepaged.c static int collapse_huge_page(struct mm_struct *mm, unsigned long address, · line 1306

Quoted 10 lines
mm/khugepaged.c +6 -0
+             update_mmu_cache_range(NULL, vma, _address, pte, (1 << order));
+
+             smp_wmb(); /* make pte visible before pmd */
+             pmd_populate(mm, pmd, pmd_pgtable(_pmd));
+             spin_unlock(pmd_ptl);
+     }
 
      folio = NULL;
 
      result = SCAN_SUCCEED;

Somewhere around here it becomes safe for mTHP to anon_vma_unlock_write().

Quoted 106 lines
mm/khugepaged.c +42 -8
 out_up_write:
+     if (pte)
+             pte_unmap(pte);
      mmap_write_unlock(mm);
 out_nolock:
      *mmap_locked = false;
@@ -1364,31 +1382,58 @@ static int khugepaged_scan_pmd(struct mm_struct *mm,
 {
      pmd_t *pmd;
      pte_t *pte, *_pte;
+     int i;
      int result = SCAN_FAIL, referenced = 0;
      int none_or_zero = 0, shared = 0;
      struct page *page = NULL;
      struct folio *folio = NULL;
      unsigned long _address;
+     unsigned long enabled_orders;
      spinlock_t *ptl;
      int node = NUMA_NO_NODE, unmapped = 0;
+     bool is_pmd_only;
      bool writable = false;
-
+     int chunk_none_count = 0;
+     int scaled_none = khugepaged_max_ptes_none >> (HPAGE_PMD_ORDER - KHUGEPAGED_MIN_MTHP_ORDER);
+     unsigned long tva_flags = cc->is_khugepaged ? TVA_ENFORCE_SYSFS : 0;
      VM_BUG_ON(address & ~HPAGE_PMD_MASK);
 
      result = find_pmd_or_thp_or_none(mm, address, &pmd);
      if (result != SCAN_SUCCEED)
              goto out;
 
+     bitmap_zero(cc->mthp_bitmap, MAX_MTHP_BITMAP_SIZE);
+     bitmap_zero(cc->mthp_bitmap_temp, MAX_MTHP_BITMAP_SIZE);
      memset(cc->node_load, 0, sizeof(cc->node_load));
      nodes_clear(cc->alloc_nmask);
+
+     enabled_orders = thp_vma_allowable_orders(vma, vma->vm_flags,
+             tva_flags, THP_ORDERS_ALL_ANON);
+
+     is_pmd_only = (enabled_orders == (1 << HPAGE_PMD_ORDER));
+
      pte = pte_offset_map_lock(mm, pmd, address, &ptl);
      if (!pte) {
              result = SCAN_PMD_NULL;
              goto out;
      }
 
-     for (_address = address, _pte = pte; _pte < pte + HPAGE_PMD_NR;
-          _pte++, _address += PAGE_SIZE) {
+     for (i = 0; i < HPAGE_PMD_NR; i++) {
+             /*
+              * we are reading in KHUGEPAGED_MIN_MTHP_NR page chunks. if
+              * there are pages in this chunk keep track of it in the bitmap
+              * for mTHP collapsing.
+              */
+             if (i % KHUGEPAGED_MIN_MTHP_NR == 0) {
+                     if (chunk_none_count <= scaled_none)
+                             bitmap_set(cc->mthp_bitmap,
+                                        i / KHUGEPAGED_MIN_MTHP_NR, 1);
+
+                     chunk_none_count = 0;
+             }
+
+             _pte = pte + i;
+             _address = address + i * PAGE_SIZE;
              pte_t pteval = ptep_get(_pte);
              if (is_swap_pte(pteval)) {
                      ++unmapped;
@@ -1411,10 +1456,11 @@ static int khugepaged_scan_pmd(struct mm_struct *mm,
                      }
              }
              if (pte_none(pteval) || is_zero_pfn(pte_pfn(pteval))) {
+                     ++chunk_none_count;
                      ++none_or_zero;
                      if (!userfaultfd_armed(vma) &&
-                         (!cc->is_khugepaged ||
-                          none_or_zero <= khugepaged_max_ptes_none)) {
+                         (!cc->is_khugepaged || !is_pmd_only ||
+                             none_or_zero <= khugepaged_max_ptes_none)) {
                              continue;
                      } else {
                              result = SCAN_EXCEED_NONE_PTE;
@@ -1510,6 +1556,7 @@ static int khugepaged_scan_pmd(struct mm_struct *mm,
                                                                   address)))
                      referenced++;
      }
+
      if (!writable) {
              result = SCAN_PAGE_RO;
      } else if (cc->is_khugepaged &&
@@ -1522,8 +1569,12 @@ static int khugepaged_scan_pmd(struct mm_struct *mm,
 out_unmap:
      pte_unmap_unlock(pte, ptl);
      if (result == SCAN_SUCCEED) {
-             result = collapse_huge_page(mm, address, referenced,
-                                         unmapped, cc, mmap_locked, HPAGE_PMD_ORDER, 0);
+             result = khugepaged_scan_bitmap(mm, address, referenced, unmapped, cc,
+                            mmap_locked, enabled_orders);
+             if (result > 0)
+                     result = SCAN_SUCCEED;
+             else
+                     result = SCAN_FAIL;
      }
 out:
      trace_mm_khugepaged_scan_pmd(mm, &folio->page, writable, referenced,
--
Quoted 8 lines
Quoted 1 line

2.48.1

Fixes to 07/12 "khugepaged: add mTHP support".
But I see now that the first hunk is actually not to this 07/12, but to 05/12 "khugepaged: generalize __collapse_huge_page_* for mTHP support":
the mTHP check added in __collapse_huge_page_swapin() forgets to unmap and unlock before returning, causing RCU imbalance warnings and lockups. I won't separate it out here, let me leave that to you.

Thanks I'll get both of these issues fixed!

Quoted 5 lines

And I had other fixes to v4, which you've fixed differently in v5, I haven't looked up which patch: where khugepaged_collapse_single_pmd() does mmap_read_(un)lock() around collapse_pte_mapped_thp(). I dislike your special use of result SCAN_ANY_PROCESS there, because mmap_locked

This is what the revalidate func is doing with khugepaged_test_exit_or_disable so I tried to keep it consistent. Sadly this was the cleanest solution I could come up with. If you dont mind sharing what your solution to this was, I'd be happy to take a look!

Quoted 5 lines

is precisely the tool for that job, so just lock and unlock without setting *mmap_locked true (but I'd agree that mmap_locked is confusing, and offhand wouldn't want to assert exactly what it means - does it mean that mmap lock was *never* dropped, so "vma" is safe without revalidation? depends on where it's used perhaps).

I agree its use is confusing and I like to think of it as ONLY the indicator of it being locked/unlocked. Im not sure if there were other intended uses.

Quoted 86 lines

Hugh

---
 mm/khugepaged.c | 32 +++++++++++++++++++++++++++-----
 1 file changed, 27 insertions(+), 5 deletions(-)
mm/khugepaged.c +27 -6
index c1c637dbcb81..2c814c239d65 100644
@@ -1054,6 +1054,8 @@ static int __collapse_huge_page_swapin(struct mm_struct *mm,
 
                /* Dont swapin for mTHP collapse */
                if (order != HPAGE_PMD_ORDER) {
+                       pte_unmap(pte);
+                       mmap_read_unlock(mm);
                        result = SCAN_EXCEED_SWAP_PTE;
                        goto out;
                }
@@ -1136,7 +1138,7 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 {
        LIST_HEAD(compound_pagelist);
        pmd_t *pmd, _pmd;
-       pte_t *pte, mthp_pte;
+       pte_t *pte = NULL, mthp_pte;
        pgtable_t pgtable;
        struct folio *folio;
        spinlock_t *pmd_ptl, *pte_ptl;
@@ -1208,6 +1210,21 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
        if (result != SCAN_SUCCEED)
                goto out_up_write;
 
+       if (vma->vm_end < address + HPAGE_PMD_SIZE) {
+               struct vm_area_struct *next_vma = find_vma(mm, vma->vm_end);
+               /*
+                * We must not clear *pmd if it is used by the following VMA.
+                * Well, perhaps we could if it, and all following VMAs using
+                * this same page table, share the same anon_vma, and so are
+                * locked out together: but keep it simple for now (and this
+                * code might better belong in hugepage_vma_revalidate()).
+                */
+               if (next_vma && next_vma->vm_start < address + HPAGE_PMD_SIZE) {
+                       result = SCAN_ADDRESS_RANGE;
+                       goto out_up_write;
+               }
+       }
+
        vma_start_write(vma);
        anon_vma_lock_write(vma->anon_vma);
 
@@ -1255,15 +1272,17 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 
        /*
         * All pages are isolated and locked so anon_vma rmap
-        * can't run anymore.
-        */
-       anon_vma_unlock_write(vma->anon_vma);
+        * can't run anymore - IF the entire extent has been isolated.
+        * anon_vma lock may cover a large area: better unlock a.s.a.p.
+        */
+       if (order == HPAGE_PMD_ORDER)
+               anon_vma_unlock_write(vma->anon_vma);
 
        result = __collapse_huge_page_copy(pte, folio, pmd, _pmd,
                                           vma, _address, pte_ptl,
                                           &compound_pagelist, order);
        if (unlikely(result != SCAN_SUCCEED))
-               goto out_up_write;
+               goto out_unlock_anon_vma;
 
        /*
         * The smp_wmb() inside __folio_mark_uptodate() ensures the
@@ -1304,6 +1323,9 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
        folio = NULL;
 
        result = SCAN_SUCCEED;
+out_unlock_anon_vma:
+       if (order != HPAGE_PMD_ORDER)
+               anon_vma_unlock_write(vma->anon_vma);
 out_up_write:
        if (pte)
                pte_unmap(pte);
--

2.43.0

#30 lore raw

Re: [PATCH v5 07/12] khugepaged: add mTHP support

In reply to Nico Pache
kernel test robot noticed the following build warnings:

Hi Nico,

kernel test robot noticed the following build warnings:

[auto build test WARNING on next-20250428]
[cannot apply to akpm-mm/mm-everything trace/for-next lwn/docs-next linus/master v6.15-rc4 v6.15-rc3 v6.15-rc2 v6.15-rc5] [If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]

url:    https://github.com/intel-lab-lkp/linux/commits/Nico-Pache/khugepaged-rename-hpage_collapse_-to-khugepaged_/20250429-021548
base:   next-20250428
patch link:    https://lore.kernel.org/r/20250428181218.85925-8-npache%40redhat.com
patch subject: [PATCH v5 07/12] khugepaged: add mTHP support
config: x86_64-buildonly-randconfig-001-20250430 (https://download.01.org/0day-ci/archive/20250507/[email protected]/config)
compiler: clang version 20.1.2 (https://github.com/llvm/llvm-project 58df0ef89dd64126512e4ee27b4ac3fd8ddf6247)
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20250507/[email protected]/reproduce)

If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/

All warnings (new ones prefixed by >>):

>> mm/khugepaged.c:1208:6: warning: variable 'pte' is used uninitialized whenever 'if' condition is true [-Wsometimes-uninitialized]
    1208 |         if (result != SCAN_SUCCEED)
         |             ^~~~~~~~~~~~~~~~~~~~~~
   mm/khugepaged.c:1308:6: note: uninitialized use occurs here
    1308 |         if (pte)
         |             ^~~
   mm/khugepaged.c:1208:2: note: remove the 'if' if its condition is always false
    1208 |         if (result != SCAN_SUCCEED)
         |         ^~~~~~~~~~~~~~~~~~~~~~~~~~~
    1209 |                 goto out_up_write;
         |                 ~~~~~~~~~~~~~~~~~
   mm/khugepaged.c:1204:6: warning: variable 'pte' is used uninitialized whenever 'if' condition is true [-Wsometimes-uninitialized]
    1204 |         if (result != SCAN_SUCCEED)
         |             ^~~~~~~~~~~~~~~~~~~~~~
   mm/khugepaged.c:1308:6: note: uninitialized use occurs here
    1308 |         if (pte)
         |             ^~~
   mm/khugepaged.c:1204:2: note: remove the 'if' if its condition is always false
    1204 |         if (result != SCAN_SUCCEED)
         |         ^~~~~~~~~~~~~~~~~~~~~~~~~~~
    1205 |                 goto out_up_write;
         |                 ~~~~~~~~~~~~~~~~~
   mm/khugepaged.c:1139:12: note: initialize the variable 'pte' to silence this warning
    1139 |         pte_t *pte, mthp_pte;
         |                   ^
         |                    = NULL

2 warnings generated.

vim +1208 mm/khugepaged.c

9710a78ab2aed09 Zach O'Keefe            2022-07-06  1131  
50ad2f24b3b48c7 Zach O'Keefe            2022-07-06  1132  static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
50ad2f24b3b48c7 Zach O'Keefe            2022-07-06  1133  			      int referenced, int unmapped,
2e6c970ed974576 Nico Pache              2025-04-28  1134  			      struct collapse_control *cc, bool *mmap_locked,
2e6c970ed974576 Nico Pache              2025-04-28  1135  				  u8 order, u16 offset)
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1136  {
5503fbf2b0b80c1 Kirill A. Shutemov      2020-06-03  1137  	LIST_HEAD(compound_pagelist);
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1138  	pmd_t *pmd, _pmd;
d857f1e14edec88 Nico Pache              2025-04-28  1139  	pte_t *pte, mthp_pte;
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1140  	pgtable_t pgtable;
5432726848bb27a Matthew Wilcox (Oracle  2023-12-11  1141) 	struct folio *folio;
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1142  	spinlock_t *pmd_ptl, *pte_ptl;
50ad2f24b3b48c7 Zach O'Keefe            2022-07-06  1143  	int result = SCAN_FAIL;
c131f751ab1a852 Kirill A. Shutemov      2016-09-19  1144  	struct vm_area_struct *vma;
ac46d4f3c43241f Jérôme Glisse           2018-12-28  1145  	struct mmu_notifier_range range;
d857f1e14edec88 Nico Pache              2025-04-28  1146  	unsigned long _address = address + offset * PAGE_SIZE;
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1147  
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1148  	VM_BUG_ON(address & ~HPAGE_PMD_MASK);
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1149  
988ddb710bb5be2 Kirill A. Shutemov      2016-07-26  1150  	/*
c1e8d7c6a7a682e Michel Lespinasse       2020-06-08  1151  	 * Before allocating the hugepage, release the mmap_lock read lock.
988ddb710bb5be2 Kirill A. Shutemov      2016-07-26  1152  	 * The allocation can take potentially a long time if it involves
c1e8d7c6a7a682e Michel Lespinasse       2020-06-08  1153  	 * sync compaction, and we do not need to hold the mmap_lock during
988ddb710bb5be2 Kirill A. Shutemov      2016-07-26  1154  	 * that. We will recheck the vma after taking it again in write mode.
2e6c970ed974576 Nico Pache              2025-04-28  1155  	 * If collapsing mTHPs we may have already released the read_lock.
988ddb710bb5be2 Kirill A. Shutemov      2016-07-26  1156  	 */
2e6c970ed974576 Nico Pache              2025-04-28  1157  	if (*mmap_locked) {
d8ed45c5dcd455f Michel Lespinasse       2020-06-08  1158  		mmap_read_unlock(mm);
2e6c970ed974576 Nico Pache              2025-04-28  1159  		*mmap_locked = false;
2e6c970ed974576 Nico Pache              2025-04-28  1160  	}
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1161  
d857f1e14edec88 Nico Pache              2025-04-28  1162  	result = alloc_charge_folio(&folio, mm, cc, order);
9710a78ab2aed09 Zach O'Keefe            2022-07-06  1163  	if (result != SCAN_SUCCEED)
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1164  		goto out_nolock;
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1165  
d8ed45c5dcd455f Michel Lespinasse       2020-06-08  1166  	mmap_read_lock(mm);
d857f1e14edec88 Nico Pache              2025-04-28  1167  	*mmap_locked = true;
d857f1e14edec88 Nico Pache              2025-04-28  1168  	result = hugepage_vma_revalidate(mm, address, true, &vma, cc, order);
50ad2f24b3b48c7 Zach O'Keefe            2022-07-06  1169  	if (result != SCAN_SUCCEED) {
d8ed45c5dcd455f Michel Lespinasse       2020-06-08  1170  		mmap_read_unlock(mm);
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1171  		goto out_nolock;
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1172  	}
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1173  
507228044236804 Zach O'Keefe            2022-07-06  1174  	result = find_pmd_or_thp_or_none(mm, address, &pmd);
507228044236804 Zach O'Keefe            2022-07-06  1175  	if (result != SCAN_SUCCEED) {
d8ed45c5dcd455f Michel Lespinasse       2020-06-08  1176  		mmap_read_unlock(mm);
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1177  		goto out_nolock;
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1178  	}
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1179  
50ad2f24b3b48c7 Zach O'Keefe            2022-07-06  1180  	if (unmapped) {
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1181  		/*
50ad2f24b3b48c7 Zach O'Keefe            2022-07-06  1182  		 * __collapse_huge_page_swapin will return with mmap_lock
50ad2f24b3b48c7 Zach O'Keefe            2022-07-06  1183  		 * released when it fails. So we jump out_nolock directly in
50ad2f24b3b48c7 Zach O'Keefe            2022-07-06  1184  		 * that case.  Continuing to collapse causes inconsistency.
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1185  		 */
d857f1e14edec88 Nico Pache              2025-04-28  1186  		result = __collapse_huge_page_swapin(mm, vma, _address, pmd,
d857f1e14edec88 Nico Pache              2025-04-28  1187  				referenced, order);
50ad2f24b3b48c7 Zach O'Keefe            2022-07-06  1188  		if (result != SCAN_SUCCEED)
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1189  			goto out_nolock;
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1190  	}
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1191  
d8ed45c5dcd455f Michel Lespinasse       2020-06-08  1192  	mmap_read_unlock(mm);
d857f1e14edec88 Nico Pache              2025-04-28  1193  	*mmap_locked = false;
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1194  	/*
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1195  	 * Prevent all access to pagetables with the exception of
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1196  	 * gup_fast later handled by the ptep_clear_flush and the VM
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1197  	 * handled by the anon_vma lock + PG_lock.
adef440691bab82 Andrea Arcangeli        2023-12-06  1198  	 *
adef440691bab82 Andrea Arcangeli        2023-12-06  1199  	 * UFFDIO_MOVE is prevented to race as well thanks to the
adef440691bab82 Andrea Arcangeli        2023-12-06  1200  	 * mmap_lock.
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1201  	 */
d8ed45c5dcd455f Michel Lespinasse       2020-06-08  1202  	mmap_write_lock(mm);
d857f1e14edec88 Nico Pache              2025-04-28  1203  	result = hugepage_vma_revalidate(mm, address, true, &vma, cc, order);
50ad2f24b3b48c7 Zach O'Keefe            2022-07-06  1204  	if (result != SCAN_SUCCEED)
18d24a7cd9d3f35 Miaohe Lin              2021-05-04  1205  		goto out_up_write;
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1206  	/* check if the pmd is still valid */
507228044236804 Zach O'Keefe            2022-07-06  1207  	result = check_pmd_still_valid(mm, address, pmd);
507228044236804 Zach O'Keefe            2022-07-06 @1208  	if (result != SCAN_SUCCEED)
18d24a7cd9d3f35 Miaohe Lin              2021-05-04  1209  		goto out_up_write;
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1210  
55fd6fccad3172c Suren Baghdasaryan      2023-02-27  1211  	vma_start_write(vma);
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1212  	anon_vma_lock_write(vma->anon_vma);
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1213  
d857f1e14edec88 Nico Pache              2025-04-28  1214  	mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, mm, _address,
d857f1e14edec88 Nico Pache              2025-04-28  1215  				_address + (PAGE_SIZE << order));
ac46d4f3c43241f Jérôme Glisse           2018-12-28  1216  	mmu_notifier_invalidate_range_start(&range);
ec649c9d454ea37 Ville Syrjälä           2019-11-05  1217  
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1218  	pmd_ptl = pmd_lock(mm, pmd); /* probably unnecessary */
d857f1e14edec88 Nico Pache              2025-04-28  1219  
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1220  	/*
70cbc3cc78a997d Yang Shi                2022-09-07  1221  	 * This removes any huge TLB entry from the CPU so we won't allow
70cbc3cc78a997d Yang Shi                2022-09-07  1222  	 * huge and small TLB entries for the same virtual address to
70cbc3cc78a997d Yang Shi                2022-09-07  1223  	 * avoid the risk of CPU bugs in that area.
70cbc3cc78a997d Yang Shi                2022-09-07  1224  	 *
0ae0b2b32553398 David Hildenbrand       2024-04-02  1225  	 * Parallel GUP-fast is fine since GUP-fast will back off when
70cbc3cc78a997d Yang Shi                2022-09-07  1226  	 * it detects PMD is changed.
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1227  	 */
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1228  	_pmd = pmdp_collapse_flush(vma, address, pmd);
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1229  	spin_unlock(pmd_ptl);
ac46d4f3c43241f Jérôme Glisse           2018-12-28  1230  	mmu_notifier_invalidate_range_end(&range);
2ba99c5e0881249 Jann Horn               2022-11-25  1231  	tlb_remove_table_sync_one();
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1232  
d857f1e14edec88 Nico Pache              2025-04-28  1233  	pte = pte_offset_map_lock(mm, &_pmd, _address, &pte_ptl);
895f5ee464cc90a Hugh Dickins            2023-06-08  1234  	if (pte) {
d857f1e14edec88 Nico Pache              2025-04-28  1235  		result = __collapse_huge_page_isolate(vma, _address, pte, cc,
d857f1e14edec88 Nico Pache              2025-04-28  1236  					&compound_pagelist, order);
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1237  		spin_unlock(pte_ptl);
895f5ee464cc90a Hugh Dickins            2023-06-08  1238  	} else {
895f5ee464cc90a Hugh Dickins            2023-06-08  1239  		result = SCAN_PMD_NULL;
895f5ee464cc90a Hugh Dickins            2023-06-08  1240  	}
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1241  
50ad2f24b3b48c7 Zach O'Keefe            2022-07-06  1242  	if (unlikely(result != SCAN_SUCCEED)) {
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1243  		spin_lock(pmd_ptl);
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1244  		BUG_ON(!pmd_none(*pmd));
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1245  		/*
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1246  		 * We can only use set_pmd_at when establishing
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1247  		 * hugepmds and never for establishing regular pmds that
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1248  		 * points to regular pagetables. Use pmd_populate for that
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1249  		 */
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1250  		pmd_populate(mm, pmd, pmd_pgtable(_pmd));
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1251  		spin_unlock(pmd_ptl);
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1252  		anon_vma_unlock_write(vma->anon_vma);
18d24a7cd9d3f35 Miaohe Lin              2021-05-04  1253  		goto out_up_write;
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1254  	}
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1255  
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1256  	/*
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1257  	 * All pages are isolated and locked so anon_vma rmap
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1258  	 * can't run anymore.
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1259  	 */
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1260  	anon_vma_unlock_write(vma->anon_vma);
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1261  
8eca68e2cfdf863 Matthew Wilcox (Oracle  2024-04-03  1262) 	result = __collapse_huge_page_copy(pte, folio, pmd, _pmd,
d857f1e14edec88 Nico Pache              2025-04-28  1263  					   vma, _address, pte_ptl,
d857f1e14edec88 Nico Pache              2025-04-28  1264  					   &compound_pagelist, order);
98c76c9f1ef7599 Jiaqi Yan               2023-03-29  1265  	if (unlikely(result != SCAN_SUCCEED))
98c76c9f1ef7599 Jiaqi Yan               2023-03-29  1266  		goto out_up_write;
98c76c9f1ef7599 Jiaqi Yan               2023-03-29  1267  
588d01f918d42d2 Miaohe Lin              2021-05-04  1268  	/*
5432726848bb27a Matthew Wilcox (Oracle  2023-12-11  1269) 	 * The smp_wmb() inside __folio_mark_uptodate() ensures the
5432726848bb27a Matthew Wilcox (Oracle  2023-12-11  1270) 	 * copy_huge_page writes become visible before the set_pmd_at()
5432726848bb27a Matthew Wilcox (Oracle  2023-12-11  1271) 	 * write.
588d01f918d42d2 Miaohe Lin              2021-05-04  1272  	 */
5432726848bb27a Matthew Wilcox (Oracle  2023-12-11  1273) 	__folio_mark_uptodate(folio);
d857f1e14edec88 Nico Pache              2025-04-28  1274  	if (order == HPAGE_PMD_ORDER) {
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1275  		pgtable = pmd_pgtable(_pmd);
8c19e28d02d0517 Matthew Wilcox (Oracle  2025-04-02  1276) 		_pmd = folio_mk_pmd(folio, vma->vm_page_prot);
f55e1014f9e567d Linus Torvalds          2017-11-29  1277  		_pmd = maybe_pmd_mkwrite(pmd_mkdirty(_pmd), vma);
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1278  
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1279  		spin_lock(pmd_ptl);
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1280  		BUG_ON(!pmd_none(*pmd));
d857f1e14edec88 Nico Pache              2025-04-28  1281  		folio_add_new_anon_rmap(folio, vma, _address, RMAP_EXCLUSIVE);
5432726848bb27a Matthew Wilcox (Oracle  2023-12-11  1282) 		folio_add_lru_vma(folio, vma);
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1283  		pgtable_trans_huge_deposit(mm, pmd, pgtable);
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1284  		set_pmd_at(mm, address, pmd, _pmd);
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1285  		update_mmu_cache_pmd(vma, address, pmd);
dafff3f4c850c98 Usama Arif              2024-08-30  1286  		deferred_split_folio(folio, false);
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1287  		spin_unlock(pmd_ptl);
d857f1e14edec88 Nico Pache              2025-04-28  1288  	} else { /* mTHP collapse */
d857f1e14edec88 Nico Pache              2025-04-28  1289  		mthp_pte = mk_pte(&folio->page, vma->vm_page_prot);
d857f1e14edec88 Nico Pache              2025-04-28  1290  		mthp_pte = maybe_mkwrite(pte_mkdirty(mthp_pte), vma);
d857f1e14edec88 Nico Pache              2025-04-28  1291  
d857f1e14edec88 Nico Pache              2025-04-28  1292  		spin_lock(pmd_ptl);
d857f1e14edec88 Nico Pache              2025-04-28  1293  		folio_ref_add(folio, (1 << order) - 1);
d857f1e14edec88 Nico Pache              2025-04-28  1294  		folio_add_new_anon_rmap(folio, vma, _address, RMAP_EXCLUSIVE);
d857f1e14edec88 Nico Pache              2025-04-28  1295  		folio_add_lru_vma(folio, vma);
d857f1e14edec88 Nico Pache              2025-04-28  1296  		set_ptes(vma->vm_mm, _address, pte, mthp_pte, (1 << order));
d857f1e14edec88 Nico Pache              2025-04-28  1297  		update_mmu_cache_range(NULL, vma, _address, pte, (1 << order));
d857f1e14edec88 Nico Pache              2025-04-28  1298  
d857f1e14edec88 Nico Pache              2025-04-28  1299  		smp_wmb(); /* make pte visible before pmd */
d857f1e14edec88 Nico Pache              2025-04-28  1300  		pmd_populate(mm, pmd, pmd_pgtable(_pmd));
d857f1e14edec88 Nico Pache              2025-04-28  1301  		spin_unlock(pmd_ptl);
d857f1e14edec88 Nico Pache              2025-04-28  1302  	}
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1303  
0234779276e56fb Matthew Wilcox (Oracle  2024-04-03  1304) 	folio = NULL;
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1305  
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1306  	result = SCAN_SUCCEED;
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1307  out_up_write:
d857f1e14edec88 Nico Pache              2025-04-28  1308  	if (pte)
d857f1e14edec88 Nico Pache              2025-04-28  1309  		pte_unmap(pte);
d8ed45c5dcd455f Michel Lespinasse       2020-06-08  1310  	mmap_write_unlock(mm);
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1311  out_nolock:
2e6c970ed974576 Nico Pache              2025-04-28  1312  	*mmap_locked = false;
0234779276e56fb Matthew Wilcox (Oracle  2024-04-03  1313) 	if (folio)
0234779276e56fb Matthew Wilcox (Oracle  2024-04-03  1314) 		folio_put(folio);
50ad2f24b3b48c7 Zach O'Keefe            2022-07-06  1315  	trace_mm_collapse_huge_page(mm, result == SCAN_SUCCEED, result);
50ad2f24b3b48c7 Zach O'Keefe            2022-07-06  1316  	return result;
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1317  }
b46e756f5e47031 Kirill A. Shutemov      2016-07-26  1318  
Signature · 2 lines
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
author
#31 lore raw

PATCH v5 8/12 khugepaged: skip collapsing mTHP to smaller orders

In reply to Nico Pache

khugepaged may try to collapse a mTHP to a smaller mTHP, resulting in some pages being unmapped. Skip these cases until we have a way to check if its ok to collapse to a smaller mTHP size (like in the case of a partially mapped folio).

This patch is inspired by Dev Jain's work on khugepaged mTHP support [1].

[1] https://lore.kernel.org/lkml/[email protected]/

---
 mm/khugepaged.c | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)
mm/khugepaged.c +6 -1
index 3a846cd70c66..86d1153ce9e8 100644
@@ -625,7 +625,12 @@ static int __collapse_huge_page_isolate(struct vm_area_struct *vma,
 		folio = page_folio(page);
 		VM_BUG_ON_FOLIO(!folio_test_anon(folio), folio);
 
-		/* See hpage_collapse_scan_pmd(). */
+		if (order != HPAGE_PMD_ORDER && folio_order(folio) >= order) {
+			result = SCAN_PTE_MAPPED_HUGEPAGE;
+			goto out;
+		}
+
+		/* See khugepaged_scan_pmd(). */
 		if (folio_maybe_mapped_shared(folio)) {
 			++shared;
 			if (order != HPAGE_PMD_ORDER || (cc->is_khugepaged &&
Signature · 1 line
2.48.1
reviewer Reviewed-by on v5 8/12
#32 lore raw

Re: [PATCH v5 08/12] khugepaged: skip collapsing mTHP to smaller orders

Quoted 5 lines · Nico Pache

khugepaged may try to collapse a mTHP to a smaller mTHP, resulting in some pages being unmapped. Skip these cases until we have a way to check if its ok to collapse to a smaller mTHP size (like in the case of a partially mapped folio).

Quoted 7 lines

This patch is inspired by Dev Jain's work on khugepaged mTHP support [1].

[1] https://lore.kernel.org/lkml/[email protected]/

LGTM.

author
#33 lore raw

PATCH v5 9/12 khugepaged: avoid unnecessary mTHP collapse attempts

In reply to Nico Pache

There are cases where, if an attempted collapse fails, all subsequent orders are guaranteed to also fail. Avoid these collapse attempts by bailing out early.

---
 mm/khugepaged.c | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
mm/khugepaged.c +17 -0
index 86d1153ce9e8..5e6732cccb86 100644
@@ -1365,6 +1365,23 @@ static int khugepaged_scan_bitmap(struct mm_struct *mm, unsigned long address,
 				collapsed += (1 << order);
 				continue;
 			}
+			/*
+			 * Some ret values indicate all lower order will also
+			 * fail, dont trying to collapse smaller orders
+			 */
+			if (ret == SCAN_EXCEED_NONE_PTE ||
+				ret == SCAN_EXCEED_SWAP_PTE ||
+				ret == SCAN_EXCEED_SHARED_PTE ||
+				ret == SCAN_PTE_NON_PRESENT ||
+				ret == SCAN_PTE_UFFD_WP ||
+				ret == SCAN_ALLOC_HUGE_PAGE_FAIL ||
+				ret == SCAN_CGROUP_CHARGE_FAIL ||
+				ret == SCAN_COPY_MC ||
+				ret == SCAN_PAGE_LOCK ||
+				ret == SCAN_PAGE_COUNT)
+				goto next;
+			else
+				break;
 		}
 
 next:
Signature · 1 line
2.48.1
reviewer
#34 lore raw

Re: [PATCH v5 09/12] khugepaged: avoid unnecessary mTHP collapse attempts

Quoted 24 lines · Nico Pache

There are cases where, if an attempted collapse fails, all subsequent orders are guaranteed to also fail. Avoid these collapse attempts by bailing out early.

---
  mm/khugepaged.c | 17 +++++++++++++++++
  1 file changed, 17 insertions(+)
mm/khugepaged.c +7 -0
index 86d1153ce9e8..5e6732cccb86 100644
@@ -1365,6 +1365,23 @@ static int khugepaged_scan_bitmap(struct mm_struct *mm, unsigned long address,
  				collapsed += (1 << order);
  				continue;
  			}
+			/*
+			 * Some ret values indicate all lower order will also
+			 * fail, dont trying to collapse smaller orders
+			 */
+			if (ret == SCAN_EXCEED_NONE_PTE ||
+				ret == SCAN_EXCEED_SWAP_PTE ||
+				ret == SCAN_EXCEED_SHARED_PTE ||

mm/khugepaged.c static int khugepaged_scan_bitmap(struct mm_struct *mm, unsigned long address, · line 1384

Quoted 10 lines
mm/khugepaged.c +10 -0
+				ret == SCAN_PTE_NON_PRESENT ||
+				ret == SCAN_PTE_UFFD_WP ||
+				ret == SCAN_ALLOC_HUGE_PAGE_FAIL ||
+				ret == SCAN_CGROUP_CHARGE_FAIL ||
+				ret == SCAN_COPY_MC ||
+				ret == SCAN_PAGE_LOCK ||
+				ret == SCAN_PAGE_COUNT)
+				goto next;
+			else
+				break;

Better to merge this patch into patch 6, which can be helped to understand your logic.

author
#35 lore raw

Re: [PATCH v5 09/12] khugepaged: avoid unnecessary mTHP collapse attempts

Quoted 33 lines · Baolin Wang
Quoted 29 lines · Nico Pache

There are cases where, if an attempted collapse fails, all subsequent orders are guaranteed to also fail. Avoid these collapse attempts by bailing out early.

---
  mm/khugepaged.c | 17 +++++++++++++++++
  1 file changed, 17 insertions(+)
mm/khugepaged.c +12 -0
index 86d1153ce9e8..5e6732cccb86 100644
@@ -1365,6 +1365,23 @@ static int khugepaged_scan_bitmap(struct mm_struct *mm, unsigned long address,
                              collapsed += (1 << order);
                              continue;
                      }
+                     /*
+                      * Some ret values indicate all lower order will also
+                      * fail, dont trying to collapse smaller orders
+                      */
+                     if (ret == SCAN_EXCEED_NONE_PTE ||
+                             ret == SCAN_EXCEED_SWAP_PTE ||
+                             ret == SCAN_EXCEED_SHARED_PTE ||
+                             ret == SCAN_PTE_NON_PRESENT ||
+                             ret == SCAN_PTE_UFFD_WP ||
+                             ret == SCAN_ALLOC_HUGE_PAGE_FAIL ||
+                             ret == SCAN_CGROUP_CHARGE_FAIL ||
+                             ret == SCAN_COPY_MC ||
Quoted 8 lines

mm/khugepaged.c static int khugepaged_scan_bitmap(struct mm_struct *mm, unsigned long address, · line 1384

Quoted 5 lines
mm/khugepaged.c +5 -0
+                             ret == SCAN_PAGE_LOCK ||
+                             ret == SCAN_PAGE_COUNT)
+                             goto next;
+                     else
+                             break;

Better to merge this patch into patch 6, which can be helped to understand your logic.

Sounds good, it wasnt part of the original logic/RFCs so i separated it out to get some review on it.

Quoted 1 line
author
#36 lore raw

PATCH v5 10/12 khugepaged: improve tracepoints for mTHP orders

In reply to Nico Pache

Add the order to the tracepoints to give better insight into what order is being operated at for khugepaged.

---
 include/trace/events/huge_memory.h | 34 +++++++++++++++++++-----------
 mm/khugepaged.c                    | 10 +++++----
 2 files changed, 28 insertions(+), 16 deletions(-)
include/trace/events/huge_memory.h +22 -12
index 9d5c00b0285c..ea2fe20a39f5 100644
@@ -92,34 +92,37 @@ TRACE_EVENT(mm_khugepaged_scan_pmd,
 
 TRACE_EVENT(mm_collapse_huge_page,
 
-	TP_PROTO(struct mm_struct *mm, int isolated, int status),
+	TP_PROTO(struct mm_struct *mm, int isolated, int status, int order),
 
-	TP_ARGS(mm, isolated, status),
+	TP_ARGS(mm, isolated, status, order),
 
 	TP_STRUCT__entry(
 		__field(struct mm_struct *, mm)
 		__field(int, isolated)
 		__field(int, status)
+		__field(int, order)
 	),
 
 	TP_fast_assign(
 		__entry->mm = mm;
 		__entry->isolated = isolated;
 		__entry->status = status;
+		__entry->order = order;
 	),
 
-	TP_printk("mm=%p, isolated=%d, status=%s",
+	TP_printk("mm=%p, isolated=%d, status=%s order=%d",
 		__entry->mm,
 		__entry->isolated,
-		__print_symbolic(__entry->status, SCAN_STATUS))
+		__print_symbolic(__entry->status, SCAN_STATUS),
+		__entry->order)
 );
 
 TRACE_EVENT(mm_collapse_huge_page_isolate,
 
 	TP_PROTO(struct page *page, int none_or_zero,
-		 int referenced, bool  writable, int status),
+		 int referenced, bool  writable, int status, int order),
 
-	TP_ARGS(page, none_or_zero, referenced, writable, status),
+	TP_ARGS(page, none_or_zero, referenced, writable, status, order),
 
 	TP_STRUCT__entry(
 		__field(unsigned long, pfn)
@@ -127,6 +130,7 @@ TRACE_EVENT(mm_collapse_huge_page_isolate,
 		__field(int, referenced)
 		__field(bool, writable)
 		__field(int, status)
+		__field(int, order)
 	),
 
 	TP_fast_assign(
@@ -135,27 +139,31 @@ TRACE_EVENT(mm_collapse_huge_page_isolate,
 		__entry->referenced = referenced;
 		__entry->writable = writable;
 		__entry->status = status;
+		__entry->order = order;
 	),
 
-	TP_printk("scan_pfn=0x%lx, none_or_zero=%d, referenced=%d, writable=%d, status=%s",
+	TP_printk("scan_pfn=0x%lx, none_or_zero=%d, referenced=%d, writable=%d, status=%s order=%d",
 		__entry->pfn,
 		__entry->none_or_zero,
 		__entry->referenced,
 		__entry->writable,
-		__print_symbolic(__entry->status, SCAN_STATUS))
+		__print_symbolic(__entry->status, SCAN_STATUS),
+		__entry->order)
 );
 
 TRACE_EVENT(mm_collapse_huge_page_swapin,
 
-	TP_PROTO(struct mm_struct *mm, int swapped_in, int referenced, int ret),
+	TP_PROTO(struct mm_struct *mm, int swapped_in, int referenced, int ret,
+			int order),
 
-	TP_ARGS(mm, swapped_in, referenced, ret),
+	TP_ARGS(mm, swapped_in, referenced, ret, order),
 
 	TP_STRUCT__entry(
 		__field(struct mm_struct *, mm)
 		__field(int, swapped_in)
 		__field(int, referenced)
 		__field(int, ret)
+		__field(int, order)
 	),
 
 	TP_fast_assign(
@@ -163,13 +171,15 @@ TRACE_EVENT(mm_collapse_huge_page_swapin,
 		__entry->swapped_in = swapped_in;
 		__entry->referenced = referenced;
 		__entry->ret = ret;
+		__entry->order = order;
 	),
 
-	TP_printk("mm=%p, swapped_in=%d, referenced=%d, ret=%d",
+	TP_printk("mm=%p, swapped_in=%d, referenced=%d, ret=%d, order=%d",
 		__entry->mm,
 		__entry->swapped_in,
 		__entry->referenced,
-		__entry->ret)
+		__entry->ret,
+		__entry->order)
 );
 
 TRACE_EVENT(mm_khugepaged_scan_file,
mm/khugepaged.c +6 -4
index 5e6732cccb86..1d99ef184c3f 100644
@@ -721,13 +721,14 @@ static int __collapse_huge_page_isolate(struct vm_area_struct *vma,
 	} else {
 		result = SCAN_SUCCEED;
 		trace_mm_collapse_huge_page_isolate(&folio->page, none_or_zero,
-						    referenced, writable, result);
+						    referenced, writable, result,
+						    order);
 		return result;
 	}
 out:
 	release_pte_pages(pte, _pte, compound_pagelist);
 	trace_mm_collapse_huge_page_isolate(&folio->page, none_or_zero,
-					    referenced, writable, result);
+					    referenced, writable, result, order);
 	return result;
 }
 
@@ -1097,7 +1098,8 @@ static int __collapse_huge_page_swapin(struct mm_struct *mm,
 
 	result = SCAN_SUCCEED;
 out:
-	trace_mm_collapse_huge_page_swapin(mm, swapped_in, referenced, result);
+	trace_mm_collapse_huge_page_swapin(mm, swapped_in, referenced, result,
+						order);
 	return result;
 }
 
@@ -1317,7 +1319,7 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address,
 	*mmap_locked = false;
 	if (folio)
 		folio_put(folio);
-	trace_mm_collapse_huge_page(mm, result == SCAN_SUCCEED, result);
+	trace_mm_collapse_huge_page(mm, result == SCAN_SUCCEED, result, order);
 	return result;
 }
 
Signature · 1 line
2.48.1
author
#37 lore raw

PATCH v5 11/12 khugepaged: add per-order mTHP khugepaged stats

In reply to Nico Pache

With mTHP support inplace, let add the per-order mTHP stats for exceeding NONE, SWAP, and SHARED.

---
 include/linux/huge_mm.h |  3 +++
 mm/huge_memory.c        |  7 +++++++
 mm/khugepaged.c         | 16 +++++++++++++---
 3 files changed, 23 insertions(+), 3 deletions(-)
include/linux/huge_mm.h +3 -0
index 0bb65bd4e6dd..e3d15c737008 100644
@@ -139,6 +139,9 @@ enum mthp_stat_item {
 	MTHP_STAT_SPLIT_DEFERRED,
 	MTHP_STAT_NR_ANON,
 	MTHP_STAT_NR_ANON_PARTIALLY_MAPPED,
+	MTHP_STAT_COLLAPSE_EXCEED_SWAP,
+	MTHP_STAT_COLLAPSE_EXCEED_NONE,
+	MTHP_STAT_COLLAPSE_EXCEED_SHARED,
 	__MTHP_STAT_COUNT
 };
 
mm/huge_memory.c +7 -0
index 670b8b7a6738..8af5caa0d9bc 100644
@@ -633,6 +633,10 @@ DEFINE_MTHP_STAT_ATTR(split_failed, MTHP_STAT_SPLIT_FAILED);
 DEFINE_MTHP_STAT_ATTR(split_deferred, MTHP_STAT_SPLIT_DEFERRED);
 DEFINE_MTHP_STAT_ATTR(nr_anon, MTHP_STAT_NR_ANON);
 DEFINE_MTHP_STAT_ATTR(nr_anon_partially_mapped, MTHP_STAT_NR_ANON_PARTIALLY_MAPPED);
+DEFINE_MTHP_STAT_ATTR(collapse_exceed_swap_pte, MTHP_STAT_COLLAPSE_EXCEED_SWAP);
+DEFINE_MTHP_STAT_ATTR(collapse_exceed_none_pte, MTHP_STAT_COLLAPSE_EXCEED_NONE);
+DEFINE_MTHP_STAT_ATTR(collapse_exceed_shared_pte, MTHP_STAT_COLLAPSE_EXCEED_SHARED);
+
 
 static struct attribute *anon_stats_attrs[] = {
 	&anon_fault_alloc_attr.attr,
@@ -649,6 +653,9 @@ static struct attribute *anon_stats_attrs[] = {
 	&split_deferred_attr.attr,
 	&nr_anon_attr.attr,
 	&nr_anon_partially_mapped_attr.attr,
+	&collapse_exceed_swap_pte_attr.attr,
+	&collapse_exceed_none_pte_attr.attr,
+	&collapse_exceed_shared_pte_attr.attr,
 	NULL,
 };
 
mm/khugepaged.c +13 -3
index 1d99ef184c3f..812181354c46 100644
@@ -604,7 +604,10 @@ static int __collapse_huge_page_isolate(struct vm_area_struct *vma,
 				continue;
 			} else {
 				result = SCAN_EXCEED_NONE_PTE;
-				count_vm_event(THP_SCAN_EXCEED_NONE_PTE);
+				if (order == HPAGE_PMD_ORDER)
+					count_vm_event(THP_SCAN_EXCEED_NONE_PTE);
+				else
+					count_mthp_stat(order, MTHP_STAT_COLLAPSE_EXCEED_NONE);
 				goto out;
 			}
 		}
@@ -633,8 +636,14 @@ static int __collapse_huge_page_isolate(struct vm_area_struct *vma,
 		/* See khugepaged_scan_pmd(). */
 		if (folio_maybe_mapped_shared(folio)) {
 			++shared;
-			if (order != HPAGE_PMD_ORDER || (cc->is_khugepaged &&
-			    shared > khugepaged_max_ptes_shared)) {
+			if (order != HPAGE_PMD_ORDER) {
+				result = SCAN_EXCEED_SHARED_PTE;
+				count_mthp_stat(order, MTHP_STAT_COLLAPSE_EXCEED_SHARED);
+				goto out;
+			}
+
+			if (cc->is_khugepaged &&
+				shared > khugepaged_max_ptes_shared) {
 				result = SCAN_EXCEED_SHARED_PTE;
 				count_vm_event(THP_SCAN_EXCEED_SHARED_PTE);
 				goto out;
@@ -1060,6 +1069,7 @@ static int __collapse_huge_page_swapin(struct mm_struct *mm,
 
 		/* Dont swapin for mTHP collapse */
 		if (order != HPAGE_PMD_ORDER) {
+			count_mthp_stat(order, MTHP_STAT_COLLAPSE_EXCEED_SWAP);
 			result = SCAN_EXCEED_SWAP_PTE;
 			goto out;
 		}
Signature · 1 line
2.48.1
author
#38 lore raw

PATCH v5 12/12 Documentation: mm: update the admin guide for mTHP collapse

In reply to Nico Pache

Now that we can collapse to mTHPs lets update the admin guide to reflect these changes and provide proper guidence on how to utilize it.

---
 Documentation/admin-guide/mm/transhuge.rst | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)
Documentation/admin-guide/mm/transhuge.rst +13 -1
index dff8d5985f0f..5c63fe51b3ad 100644
@@ -63,7 +63,7 @@ often.
 THP can be enabled system wide or restricted to certain tasks or even
 memory ranges inside task's address space. Unless THP is completely
 disabled, there is ``khugepaged`` daemon that scans memory and
-collapses sequences of basic pages into PMD-sized huge pages.
+collapses sequences of basic pages into huge pages.
 
 The THP behaviour is controlled via :ref:`sysfs <thp_sysfs>`
 interface and using madvise(2) and prctl(2) system calls.
@@ -144,6 +144,18 @@ hugepage sizes have enabled="never". If enabling multiple hugepage
 sizes, the kernel will select the most appropriate enabled size for a
 given allocation.
 
+khugepaged uses max_ptes_none scaled to the order of the enabled mTHP size
+to determine collapses. When using mTHPs it's recommended to set
+max_ptes_none low-- ideally less than HPAGE_PMD_NR / 2 (255 on 4k page
+size). This will prevent undesired "creep" behavior that leads to
+continuously collapsing to a larger mTHP size; When we collapse, we are
+bringing in new non-zero pages that will, on a subsequent scan, cause the
+max_ptes_none check of the +1 order to always be satisfied. By limiting
+this to less than half the current order, we make sure we don't cause this
+feedback loop. max_ptes_shared and max_ptes_swap have no effect when
+collapsing to a mTHP, and mTHP collapse will fail on shared or swapped out
+pages.
+
 It's also possible to limit defrag efforts in the VM to generate
 anonymous hugepages in case they're not immediately free to madvise
 regions or to never try to defrag memory and simply fallback to regular
Signature · 1 line
2.48.1
Reviewed-by on v5 12/12
#39 lore raw

Re: [PATCH v5 12/12] Documentation: mm: update the admin guide for mTHP collapse

Quoted 22 lines · Nico Pache
Documentation/admin-guide/mm/transhuge.rst +6 -1
index dff8d5985f0f..5c63fe51b3ad 100644
@@ -63,7 +63,7 @@ often.
 THP can be enabled system wide or restricted to certain tasks or even
 memory ranges inside task's address space. Unless THP is completely
 disabled, there is ``khugepaged`` daemon that scans memory and
-collapses sequences of basic pages into PMD-sized huge pages.
+collapses sequences of basic pages into huge pages.
 
 The THP behaviour is controlled via :ref:`sysfs <thp_sysfs>`
 interface and using madvise(2) and prctl(2) system calls.
@@ -144,6 +144,18 @@ hugepage sizes have enabled="never". If enabling multiple hugepage
 sizes, the kernel will select the most appropriate enabled size for a
 given allocation.
 
+khugepaged uses max_ptes_none scaled to the order of the enabled mTHP size
+to determine collapses. When using mTHPs it's recommended to set
+max_ptes_none low-- ideally less than HPAGE_PMD_NR / 2 (255 on 4k page
+size). This will prevent undesired "creep" behavior that leads to
+continuously collapsing to a larger mTHP size; When we collapse, we are

Documentation/admin-guide/mm/transhuge.rst hugepage sizes have enabled="never". If enabling multiple hugepage · line 161

Quoted 10 lines
Documentation/admin-guide/mm/transhuge.rst +7 -0
+bringing in new non-zero pages that will, on a subsequent scan, cause the
+max_ptes_none check of the +1 order to always be satisfied. By limiting
+this to less than half the current order, we make sure we don't cause this
+feedback loop. max_ptes_shared and max_ptes_swap have no effect when
+collapsing to a mTHP, and mTHP collapse will fail on shared or swapped out
+pages.
+
 It's also possible to limit defrag efforts in the VM to generate
 anonymous hugepages in case they're not immediately free to madvise
 regions or to never try to defrag memory and simply fallback to regular

Looks good, thanks!

Signature · 1 line
An old man doll... just what I always wanted! - Clara
#40 lore raw

Re: [PATCH v5 12/12] Documentation: mm: update the admin guide for mTHP collapse

In reply to Nico Pache

Documentation/admin-guide/mm/transhuge.rst often. · line 66

Quoted 5 lines · Nico Pache

THP can be enabled system wide or restricted to certain tasks or even memory ranges inside task's address space. Unless THP is completely disabled, there is ``khugepaged`` daemon that scans memory and

Documentation/admin-guide/mm/transhuge.rst +1 -1
-collapses sequences of basic pages into PMD-sized huge pages.
+collapses sequences of basic pages into huge pages.

huge pages usually have a fixed size like 2M and are tied to the page table levels.

Would it not be advisable to use a different term here like "large folio" or "mTHP sized folio" or something like that?

#41 lore raw

Re: [PATCH v5 12/12] Documentation: mm: update the admin guide for mTHP collapse

Quoted 11 lines · Christoph Lameter (Ampere)

Documentation/admin-guide/mm/transhuge.rst often. · line 66

Quoted 5 lines · Nico Pache

THP can be enabled system wide or restricted to certain tasks or even memory ranges inside task's address space. Unless THP is completely disabled, there is ``khugepaged`` daemon that scans memory and

Documentation/admin-guide/mm/transhuge.rst +1 -1
-collapses sequences of basic pages into PMD-sized huge pages.
+collapses sequences of basic pages into huge pages.

huge pages usually have a fixed size like 2M and are tied to the page table levels.

Quoted 2 lines

Would it not be advisable to use a different term here like "large folio" or "mTHP sized folio" or something like that?

"Traditional THPs or mTHPs (both, currently represented as "large folios" in the kernel).

Signature · 3 lines
Cheers,

David / dhildenb