Skip to contentSkip to conversation

mm/huge_memory: Define split_type and consolidate split support checks

PATCH Applied Wei Yang 4 participants 32 messages Nov 6, 2025 – Nov 21, 2025

Subsystems (2)
lore
Share & tools
lore

Wei Yang

author
#0 lore raw

v3 cover mm/huge_memory: Define split_type and consolidate split support checks

This two-patch series focuses on improving code clarity and removing redundancy in the huge memory handling logic related to folio splitting.

The series is based on an original proposal to merge two significantly identical functions that check folio split support[1]. During this process, we found an opportunity to improve readability by explicitly defining the split types.

Patch 1: define split_type and use it
Patch 2: merge uniform_split_supported() and non_uniform_split_supported()

V3:
* rebase on latest mm-new with Zi Yan fix [3]
* introduce split_type to identify uniform/non-uniform split

V2:
* adjust comment
* remove need_check

V1: [1]

[1]: lkml.kernel.org/r/[email protected] [2]: lkml.kernel.org/r/[email protected] [3]: lkml.kernel.org/r/[email protected]

Wei Yang (2):
mm/huge_memory: introduce enum split_type for clarity mm/huge_memory: merge uniform_split_supported() and
non_uniform_split_supported()

 include/linux/huge_mm.h | 13 +++---
 mm/huge_memory.c        | 97 ++++++++++++++++++-----------------------
 2 files changed, 51 insertions(+), 59 deletions(-)
Signature · 1 line
2.34.1
author
#1 lore raw

PATCH v3 1/2 mm/huge_memory: introduce enum split_type for clarity

We currently handle two distinct types of large folio splitting:
* uniform split
* non-uniform split

Differentiating between these types using a simple boolean variable is not obvious and can harm code readability.

This commit introduces enum split_type to explicitly define these two types. Replacing the existing boolean variable with this enumeration significantly improves code clarity and expressiveness when dealing with folio splitting logic.

No functional change is expected.

Cc Zi Yan <[email protected]>
Cc "David Hildenbrand (Red Hat)" <[email protected]>
---
 include/linux/huge_mm.h |  5 +++++
 mm/huge_memory.c        | 30 +++++++++++++++---------------
 2 files changed, 20 insertions(+), 15 deletions(-)
include/linux/huge_mm.h +5 -0
index f381339842fa..9e96dbe2f246 100644
@@ -364,6 +364,11 @@ unsigned long thp_get_unmapped_area_vmflags(struct file *filp, unsigned long add
 		unsigned long len, unsigned long pgoff, unsigned long flags,
 		vm_flags_t vm_flags);
 
+enum split_type {
+	SPLIT_TYPE_UNIFORM,
+	SPLIT_TYPE_NON_UNIFORM,
+};
+
 bool can_split_folio(struct folio *folio, int caller_pins, int *pextra_pins);
 int __split_huge_page_to_list_to_order(struct page *page, struct list_head *list,
 		unsigned int new_order, bool unmapped);
mm/huge_memory.c +15 -15
index 5795c0b4c39c..659532199233 100644
@@ -3598,16 +3598,16 @@ static void __split_folio_to_order(struct folio *folio, int old_order,
  *            will be split until its order becomes @new_order.
  * @xas: xa_state pointing to folio->mapping->i_pages and locked by caller
  * @mapping: @folio->mapping
- * @uniform_split: if the split is uniform or not (buddy allocator like split)
+ * @split_type: if the split is uniform or not (buddy allocator like split)
  *
  *
  * 1. uniform split: the given @folio into multiple @new_order small folios,
  *    where all small folios have the same order. This is done when
- *    uniform_split is true.
+ *    split_type is SPLIT_TYPE_UNIFORM.
  * 2. buddy allocator like (non-uniform) split: the given @folio is split into
  *    half and one of the half (containing the given page) is split into half
  *    until the given @folio's order becomes @new_order. This is done when
- *    uniform_split is false.
+ *    split_type is SPLIT_TYPE_NON_UNIFORM.
  *
  * The high level flow for these two methods are:
  * 1. uniform split: @xas is split with no expectation of failure and a single
@@ -3629,11 +3629,11 @@ static void __split_folio_to_order(struct folio *folio, int old_order,
  */
 static int __split_unmapped_folio(struct folio *folio, int new_order,
 		struct page *split_at, struct xa_state *xas,
-		struct address_space *mapping, bool uniform_split)
+		struct address_space *mapping, enum split_type split_type)
 {
 	const bool is_anon = folio_test_anon(folio);
 	int old_order = folio_order(folio);
-	int start_order = uniform_split ? new_order : old_order - 1;
+	int start_order = split_type == SPLIT_TYPE_UNIFORM ? new_order : old_order - 1;
 	int split_order;
 
 	/*
@@ -3655,7 +3655,7 @@ static int __split_unmapped_folio(struct folio *folio, int new_order,
 			 * irq is disabled to allocate enough memory, whereas
 			 * non-uniform split can handle ENOMEM.
 			 */
-			if (uniform_split)
+			if (split_type == SPLIT_TYPE_UNIFORM)
 				xas_split(xas, folio, old_order);
 			else {
 				xas_set_order(xas, folio->index, split_order);
@@ -3752,7 +3752,7 @@ bool uniform_split_supported(struct folio *folio, unsigned int new_order,
  * @split_at: a page within the new folio
  * @lock_at: a page within @folio to be left locked to caller
  * @list: after-split folios will be put on it if non NULL
- * @uniform_split: perform uniform split or not (non-uniform split)
+ * @split_type: perform uniform split or not (non-uniform split)
  * @unmapped: The pages are already unmapped, they are migration entries.
  *
  * It calls __split_unmapped_folio() to perform uniform and non-uniform split.
@@ -3769,7 +3769,7 @@ bool uniform_split_supported(struct folio *folio, unsigned int new_order,
  */
 static int __folio_split(struct folio *folio, unsigned int new_order,
 		struct page *split_at, struct page *lock_at,
-		struct list_head *list, bool uniform_split, bool unmapped)
+		struct list_head *list, enum split_type split_type, bool unmapped)
 {
 	struct deferred_split *ds_queue;
 	XA_STATE(xas, &folio->mapping->i_pages, folio->index);
@@ -3794,10 +3794,10 @@ static int __folio_split(struct folio *folio, unsigned int new_order,
 	if (new_order >= old_order)
 		return -EINVAL;
 
-	if (uniform_split && !uniform_split_supported(folio, new_order, true))
+	if (split_type == SPLIT_TYPE_UNIFORM && !uniform_split_supported(folio, new_order, true))
 		return -EINVAL;
 
-	if (!uniform_split &&
+	if (split_type == SPLIT_TYPE_NON_UNIFORM &&
 	    !non_uniform_split_supported(folio, new_order, true))
 		return -EINVAL;
 
@@ -3859,7 +3859,7 @@ static int __folio_split(struct folio *folio, unsigned int new_order,
 			goto out;
 		}
 
-		if (uniform_split) {
+		if (split_type == SPLIT_TYPE_UNIFORM) {
 			xas_set_order(&xas, folio->index, new_order);
 			xas_split_alloc(&xas, folio, old_order, gfp);
 			if (xas_error(&xas)) {
@@ -3973,7 +3973,7 @@ static int __folio_split(struct folio *folio, unsigned int new_order,
 		lruvec = folio_lruvec_lock(folio);
 
 		ret = __split_unmapped_folio(folio, new_order, split_at, &xas,
-					     mapping, uniform_split);
+					     mapping, split_type);
 
 		/*
 		 * Unfreeze after-split folios and put them back to the right
@@ -4149,8 +4149,8 @@ int __split_huge_page_to_list_to_order(struct page *page, struct list_head *list
 {
 	struct folio *folio = page_folio(page);
 
-	return __folio_split(folio, new_order, &folio->page, page, list, true,
-				unmapped);
+	return __folio_split(folio, new_order, &folio->page, page, list,
+				SPLIT_TYPE_UNIFORM, unmapped);
 }
 
 /**
@@ -4181,7 +4181,7 @@ int folio_split(struct folio *folio, unsigned int new_order,
 		struct page *split_at, struct list_head *list)
 {
 	return __folio_split(folio, new_order, split_at, &folio->page, list,
-			false, false);
+				SPLIT_TYPE_NON_UNIFORM, false);
 }
 
 int min_order_for_split(struct folio *folio)
Signature · 1 line
2.34.1
maintainer Acked-by on v3 1/2
#2 lore raw

Re: [Patch v3 1/2] mm/huge_memory: introduce enum split_type for clarity

Quoted 18 lines · Wei Yang

We currently handle two distinct types of large folio splitting:
* uniform split
* non-uniform split

Differentiating between these types using a simple boolean variable is not obvious and can harm code readability.

This commit introduces enum split_type to explicitly define these two types. Replacing the existing boolean variable with this enumeration significantly improves code clarity and expressiveness when dealing with folio splitting logic.

No functional change is expected.

Cc Zi Yan <[email protected]>
Cc "David Hildenbrand (Red Hat)" <[email protected]>

---

...

Quoted 13 lines

* Unfreeze after-split folios and put them back to the right

mm/huge_memory.c +2 -2
@@ -4149,8 +4149,8 @@ int __split_huge_page_to_list_to_order(struct page *page, struct list_head *list
  {
  	struct folio *folio = page_folio(page);
 
-	return __folio_split(folio, new_order, &folio->page, page, list, true,
-				unmapped);
+	return __folio_split(folio, new_order, &folio->page, page, list,
+				SPLIT_TYPE_UNIFORM, unmapped);
  }
 
  /**

mm/huge_memory.c int folio_split(struct folio *folio, unsigned int new_order, · line 4184

Quoted 5 lines
mm/huge_memory.c +1 -1
@@ -4181,7 +4181,7 @@ int folio_split(struct folio *folio, unsigned int new_order,
  		struct page *split_at, struct list_head *list)
  {
  	return __folio_split(folio, new_order, split_at, &folio->page, list,
-			false, false);
+				SPLIT_TYPE_NON_UNIFORM, false);

Looks like both these are not properly aligned.

Should be

return __folio_split(folio, new_order, split_at, &folio->page, list,

		     SPLIT_TYPE_NON_UNIFORM, false);

Thanks!

Signature · 3 lines
Cheers

David
author
#3 lore raw

Re: [Patch v3 1/2] mm/huge_memory: introduce enum split_type for clarity

Quoted 41 lines · David Hildenbrand (Red Hat)
Quoted 18 lines · Wei Yang

We currently handle two distinct types of large folio splitting:
* uniform split
* non-uniform split

Differentiating between these types using a simple boolean variable is not obvious and can harm code readability.

This commit introduces enum split_type to explicitly define these two types. Replacing the existing boolean variable with this enumeration significantly improves code clarity and expressiveness when dealing with folio splitting logic.

No functional change is expected.

Cc Zi Yan <[email protected]>
Cc "David Hildenbrand (Red Hat)" <[email protected]>

---

...

Quoted 11 lines

* Unfreeze after-split folios and put them back to the right

mm/huge_memory.c +2 -2
@@ -4149,8 +4149,8 @@ int __split_huge_page_to_list_to_order(struct page *page, struct list_head *list
  {
  	struct folio *folio = page_folio(page);
-	return __folio_split(folio, new_order, &folio->page, page, list, true,
-				unmapped);
+	return __folio_split(folio, new_order, &folio->page, page, list,
+				SPLIT_TYPE_UNIFORM, unmapped);
  }
  /**

mm/huge_memory.c int folio_split(struct folio *folio, unsigned int new_order, · line 4184

Quoted 5 lines
mm/huge_memory.c +1 -1
@@ -4181,7 +4181,7 @@ int folio_split(struct folio *folio, unsigned int new_order,
  		struct page *split_at, struct list_head *list)
  {
  	return __folio_split(folio, new_order, split_at, &folio->page, list,
-			false, false);
+				SPLIT_TYPE_NON_UNIFORM, false);

Looks like both these are not properly aligned.

Quoted 5 lines

Should be

return __folio_split(folio, new_order, split_at, &folio->page, list,

		     SPLIT_TYPE_NON_UNIFORM, false);

Thanks.

@Andrew

Would you mind helping adjust this :-)

Quoted 9 lines

Thanks!

Signature · 3 lines
Cheers

David
Signature · 2 lines
Wei Yang
Help you, Help me
reviewer
#4 lore raw

Re: [Patch v3 1/2] mm/huge_memory: introduce enum split_type for clarity

In reply to Wei Yang
Quoted 14 lines · Wei Yang

We currently handle two distinct types of large folio splitting:
* uniform split
* non-uniform split

Differentiating between these types using a simple boolean variable is not obvious and can harm code readability.

This commit introduces enum split_type to explicitly define these two types. Replacing the existing boolean variable with this enumeration significantly improves code clarity and expressiveness when dealing with folio splitting logic.

No functional change is expected.

Quoted 8 lines
Cc Zi Yan <[email protected]>
Cc "David Hildenbrand (Red Hat)" <[email protected]>
---
 include/linux/huge_mm.h |  5 +++++
 mm/huge_memory.c        | 30 +++++++++++++++---------------
 2 files changed, 20 insertions(+), 15 deletions(-)

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

Best Regards,
Yan, Zi

author
#5 lore raw

PATCH v3 2/2 mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

In reply to Wei Yang

The functions uniform_split_supported() and non_uniform_split_supported() share significantly similar logic.

The only functional difference is that uniform_split_supported() includes an additional check on the requested @new_order.

The reason for this check comes from the following two aspects:

* some file system or swap cache just supports order-0 folio
* the behavioral difference between uniform/non-uniform split

The behavioral difference between uniform split and non-uniform:

* uniform split splits folio directly to @new_order
* non-uniform split creates after-split folios with orders from folio_order(folio) - 1 to new_order.

This means for non-uniform split or !new_order split we should check the file system and swap cache respectively.

This commit unifies the logic and merge the two functions into a single combined helper, removing redundant code and simplifying the split support checking mechanism.

Cc Zi Yan <[email protected]>
Cc "David Hildenbrand (Red Hat)" <[email protected]>

---
v3:
* adjust to use split_type
* rebase on Zi Yan fix lkml.kernel.org/r/[email protected]
v2:
* remove need_check
* update comment
* add more explanation in change log

---
 include/linux/huge_mm.h |  8 ++---
 mm/huge_memory.c        | 71 +++++++++++++++++------------------------
 2 files changed, 33 insertions(+), 46 deletions(-)
include/linux/huge_mm.h +3 -5
index 9e96dbe2f246..6f9e711b0954 100644
@@ -374,10 +374,8 @@ int __split_huge_page_to_list_to_order(struct page *page, struct list_head *list
 		unsigned int new_order, bool unmapped);
 int min_order_for_split(struct folio *folio);
 int split_folio_to_list(struct folio *folio, struct list_head *list);
-bool uniform_split_supported(struct folio *folio, unsigned int new_order,
-		bool warns);
-bool non_uniform_split_supported(struct folio *folio, unsigned int new_order,
-		bool warns);
+bool folio_split_supported(struct folio *folio, unsigned int new_order,
+		enum split_type split_type, bool warns);
 int folio_split(struct folio *folio, unsigned int new_order, struct page *page,
 		struct list_head *list);
 
@@ -408,7 +406,7 @@ static inline int split_huge_page_to_order(struct page *page, unsigned int new_o
 static inline int try_folio_split_to_order(struct folio *folio,
 		struct page *page, unsigned int new_order)
 {
-	if (!non_uniform_split_supported(folio, new_order, /* warns= */ false))
+	if (!folio_split_supported(folio, new_order, SPLIT_TYPE_NON_UNIFORM, /* warns= */ false))
 		return split_huge_page_to_order(&folio->page, new_order);
 	return folio_split(folio, new_order, page, NULL);
 }
mm/huge_memory.c +30 -41

97 lines not on this page · raw message

Signature · 1 line
2.34.1
maintainer Acked-by on v3 2/2
#6 lore raw

Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

Quoted 20 lines · Wei Yang

The functions uniform_split_supported() and non_uniform_split_supported() share significantly similar logic.

The only functional difference is that uniform_split_supported() includes an additional check on the requested @new_order.

The reason for this check comes from the following two aspects:

* some file system or swap cache just supports order-0 folio
* the behavioral difference between uniform/non-uniform split

The behavioral difference between uniform split and non-uniform:

* uniform split splits folio directly to @new_order
* non-uniform split creates after-split folios with orders from folio_order(folio) - 1 to new_order.

This means for non-uniform split or !new_order split we should check the file system and swap cache respectively.

Quoted 8 lines

This commit unifies the logic and merge the two functions into a single combined helper, removing redundant code and simplifying the split support checking mechanism.

Cc Zi Yan <[email protected]>
Cc "David Hildenbrand (Red Hat)" <[email protected]>
Signature · 3 lines
Cheers

David
reviewer
#7 lore raw

Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

In reply to Wei Yang
Quoted 36 lines · Wei Yang

The functions uniform_split_supported() and non_uniform_split_supported() share significantly similar logic.

The only functional difference is that uniform_split_supported() includes an additional check on the requested @new_order.

The reason for this check comes from the following two aspects:

* some file system or swap cache just supports order-0 folio
* the behavioral difference between uniform/non-uniform split

The behavioral difference between uniform split and non-uniform:

* uniform split splits folio directly to @new_order
* non-uniform split creates after-split folios with orders from folio_order(folio) - 1 to new_order.

This means for non-uniform split or !new_order split we should check the file system and swap cache respectively.

This commit unifies the logic and merge the two functions into a single combined helper, removing redundant code and simplifying the split support checking mechanism.

Cc Zi Yan <[email protected]>
Cc "David Hildenbrand (Red Hat)" <[email protected]>

---
v3:
* adjust to use split_type
* rebase on Zi Yan fix lkml.kernel.org/r/[email protected]
v2:
* remove need_check
* update comment
* add more explanation in change log

Quoted 5 lines
---
 include/linux/huge_mm.h |  8 ++---
 mm/huge_memory.c        | 71 +++++++++++++++++------------------------
 2 files changed, 33 insertions(+), 46 deletions(-)

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

Best Regards,
Yan, Zi

author
#8 lore raw

Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

Quoted 43 lines · Zi Yan
Quoted 36 lines · Wei Yang

The functions uniform_split_supported() and non_uniform_split_supported() share significantly similar logic.

The only functional difference is that uniform_split_supported() includes an additional check on the requested @new_order.

The reason for this check comes from the following two aspects:

* some file system or swap cache just supports order-0 folio
* the behavioral difference between uniform/non-uniform split

The behavioral difference between uniform split and non-uniform:

* uniform split splits folio directly to @new_order
* non-uniform split creates after-split folios with orders from folio_order(folio) - 1 to new_order.

This means for non-uniform split or !new_order split we should check the file system and swap cache respectively.

This commit unifies the logic and merge the two functions into a single combined helper, removing redundant code and simplifying the split support checking mechanism.

Cc Zi Yan <[email protected]>
Cc "David Hildenbrand (Red Hat)" <[email protected]>

---
v3:
* adjust to use split_type
* rebase on Zi Yan fix lkml.kernel.org/r/[email protected]
v2:
* remove need_check
* update comment
* add more explanation in change log

Quoted 5 lines
---
 include/linux/huge_mm.h |  8 ++---
 mm/huge_memory.c        | 71 +++++++++++++++++------------------------
 2 files changed, 33 insertions(+), 46 deletions(-)
Quoted 1 line

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

Hi, Zi

I am thinking whether it is proper to move the check (new_order < min_order) from __folio_split() to folio_split_supported(). So that we could bail out early if file system couldn't split to new_order.

Not sure you like it or not.

Signature · 2 lines
Wei Yang
Help you, Help me
reviewer
#9 lore raw

Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

Quoted 46 lines · Wei Yang
Quoted 43 lines · Zi Yan
Quoted 36 lines · Wei Yang

The functions uniform_split_supported() and non_uniform_split_supported() share significantly similar logic.

The only functional difference is that uniform_split_supported() includes an additional check on the requested @new_order.

The reason for this check comes from the following two aspects:

* some file system or swap cache just supports order-0 folio
* the behavioral difference between uniform/non-uniform split

The behavioral difference between uniform split and non-uniform:

* uniform split splits folio directly to @new_order
* non-uniform split creates after-split folios with orders from folio_order(folio) - 1 to new_order.

This means for non-uniform split or !new_order split we should check the file system and swap cache respectively.

This commit unifies the logic and merge the two functions into a single combined helper, removing redundant code and simplifying the split support checking mechanism.

Cc Zi Yan <[email protected]>
Cc "David Hildenbrand (Red Hat)" <[email protected]>

---
v3:
* adjust to use split_type
* rebase on Zi Yan fix lkml.kernel.org/r/[email protected]
v2:
* remove need_check
* update comment
* add more explanation in change log

Quoted 5 lines
---
 include/linux/huge_mm.h |  8 ++---
 mm/huge_memory.c        | 71 +++++++++++++++++------------------------
 2 files changed, 33 insertions(+), 46 deletions(-)
Quoted 1 line

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

Quoted 7 lines

Hi, Zi

I am thinking whether it is proper to move the check (new_order < min_order) from __folio_split() to folio_split_supported(). So that we could bail out early if file system couldn't split to new_order.

Not sure you like it or not.

It sounds reasonable. My only concern is that that might add another indentation to the else branch in folio_split_supported().

You can send a patch, so we can see how it looks.

Best Regards,
Yan, Zi

author
#10 lore raw

Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

Quoted 54 lines · Zi Yan
Quoted 52 lines · Wei Yang
Quoted 43 lines · Zi Yan
Quoted 36 lines · Wei Yang

The functions uniform_split_supported() and non_uniform_split_supported() share significantly similar logic.

The only functional difference is that uniform_split_supported() includes an additional check on the requested @new_order.

The reason for this check comes from the following two aspects:

* some file system or swap cache just supports order-0 folio
* the behavioral difference between uniform/non-uniform split

The behavioral difference between uniform split and non-uniform:

* uniform split splits folio directly to @new_order
* non-uniform split creates after-split folios with orders from folio_order(folio) - 1 to new_order.

This means for non-uniform split or !new_order split we should check the file system and swap cache respectively.

This commit unifies the logic and merge the two functions into a single combined helper, removing redundant code and simplifying the split support checking mechanism.

Cc Zi Yan <[email protected]>
Cc "David Hildenbrand (Red Hat)" <[email protected]>

---
v3:
* adjust to use split_type
* rebase on Zi Yan fix lkml.kernel.org/r/[email protected]
v2:
* remove need_check
* update comment
* add more explanation in change log

Quoted 5 lines
---
 include/linux/huge_mm.h |  8 ++---
 mm/huge_memory.c        | 71 +++++++++++++++++------------------------
 2 files changed, 33 insertions(+), 46 deletions(-)
Quoted 1 line

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

Hi, Zi

I am thinking whether it is proper to move the check (new_order < min_order) from __folio_split() to folio_split_supported(). So that we could bail out early if file system couldn't split to new_order.

Quoted 7 lines
Quoted 1 line

Not sure you like it or not.

It sounds reasonable. My only concern is that that might add another indentation to the else branch in folio_split_supported().

You can send a patch, so we can see how it looks.

Here is what come up my mind.

If !CONFIG_READ_ONLY_THP_FOR_FS, we directly compare new_order and min_order.

If CONFIG_READ_ONLY_THP_FOR_FS, one thing I am not sure is for the khugepaged collapsed THP. If its min_order is 0, it looks we can cover it with following check.

Look forward your insight.

mm/huge_memory.c +2 -9
index dee416b3f6ed..ef05f246df73 100644
@@ -3704,8 +3704,8 @@ bool folio_split_supported(struct folio *folio, unsigned int new_order,
 		if (new_order == 1)
 			return false;
 	} else if (split_type == SPLIT_TYPE_NON_UNIFORM || new_order) {
-		if (IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) &&
-		    !mapping_large_folio_support(folio->mapping)) {
+		unsigned int min_order = mapping_min_folio_order(folio->mapping);
+		if (new_order < min_order) {
 			/*
 			 * We can always split a folio down to a single page
 			 * (new_order == 0) uniformly.
@@ -3827,7 +3827,6 @@ static int __folio_split(struct folio *folio, unsigned int new_order,
 		}
 		mapping = NULL;
 	} else {
-		unsigned int min_order;
 		gfp_t gfp;
 
 		mapping = folio->mapping;
@@ -3843,12 +3842,6 @@ static int __folio_split(struct folio *folio, unsigned int new_order,
 			goto out;
 		}
 
-		min_order = mapping_min_folio_order(folio->mapping);
-		if (new_order < min_order) {
-			ret = -EINVAL;
-			goto out;
-		}
-
 		gfp = current_gfp_context(mapping_gfp_mask(mapping) &
 							GFP_RECLAIM_MASK);
 
Signature · 2 lines
Wei Yang
Help you, Help me
reviewer
#11 lore raw

Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

Quoted 63 lines · Wei Yang
Quoted 54 lines · Zi Yan
Quoted 52 lines · Wei Yang
Quoted 43 lines · Zi Yan
Quoted 36 lines · Wei Yang

The functions uniform_split_supported() and non_uniform_split_supported() share significantly similar logic.

The only functional difference is that uniform_split_supported() includes an additional check on the requested @new_order.

The reason for this check comes from the following two aspects:

* some file system or swap cache just supports order-0 folio
* the behavioral difference between uniform/non-uniform split

The behavioral difference between uniform split and non-uniform:

* uniform split splits folio directly to @new_order
* non-uniform split creates after-split folios with orders from folio_order(folio) - 1 to new_order.

This means for non-uniform split or !new_order split we should check the file system and swap cache respectively.

This commit unifies the logic and merge the two functions into a single combined helper, removing redundant code and simplifying the split support checking mechanism.

Cc Zi Yan <[email protected]>
Cc "David Hildenbrand (Red Hat)" <[email protected]>

---
v3:
* adjust to use split_type
* rebase on Zi Yan fix lkml.kernel.org/r/[email protected]
v2:
* remove need_check
* update comment
* add more explanation in change log

Quoted 5 lines
---
 include/linux/huge_mm.h |  8 ++---
 mm/huge_memory.c        | 71 +++++++++++++++++------------------------
 2 files changed, 33 insertions(+), 46 deletions(-)
Quoted 1 line

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

Hi, Zi

I am thinking whether it is proper to move the check (new_order < min_order) from __folio_split() to folio_split_supported(). So that we could bail out early if file system couldn't split to new_order.

Quoted 7 lines
Quoted 1 line

Not sure you like it or not.

It sounds reasonable. My only concern is that that might add another indentation to the else branch in folio_split_supported().

You can send a patch, so we can see how it looks.

Quoted 7 lines

Here is what come up my mind.

If !CONFIG_READ_ONLY_THP_FOR_FS, we directly compare new_order and min_order.

If CONFIG_READ_ONLY_THP_FOR_FS, one thing I am not sure is for the khugepaged collapsed THP. If its min_order is 0, it looks we can cover it with following check.

1. mapping_large_folio_support() checks if mapping_max_folio_order() > 0, meaning !mapping_large_folio_support() is mapping_max_folio_order() == 0,
2. mapping_max_folio_order() >= mapping_min_folio_order(),
3. combining 1) and 2) means
mapping_min_folio_order() <= mapping_max_folio_order() == 0, meaning mapping_min_folio_order() == 0.

so a FS without large folio support always has min_order == 0.

Quoted 8 lines

Look forward your insight.

mm/huge_memory.c +0 -0
index dee416b3f6ed..ef05f246df73 100644

mm/huge_memory.c bool folio_split_supported(struct folio *folio, unsigned int new_order, · line 3708

Quoted 7 lines
mm/huge_memory.c +2 -2
@@ -3704,8 +3704,8 @@ bool folio_split_supported(struct folio *folio, unsigned int new_order,
 		if (new_order == 1)
 			return false;
 	} else if (split_type == SPLIT_TYPE_NON_UNIFORM || new_order) {
-		if (IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) &&
-		    !mapping_large_folio_support(folio->mapping)) {
+		unsigned int min_order = mapping_min_folio_order(folio->mapping);
+		if (new_order < min_order) {

This check is good for !CONFIG_READ_ONLY_THP_FOR_FS, but for CONFIG_READ_ONLY_THP_FOR_FS and !mapping_large_folio_support(), min_order is always 0, how can new_order be smaller than min_order to trigger the warning below? You will need to check new_order against mapping_max_folio_order().

OK, basically the check should be:

if (new_order < mapping_min_folio_order() || new_order > mapping_max_folio_order()).

Then, you might want to add a helper function mapping_folio_order_supported() instead and change the warning message below to "Cannot split file folio to unsupported order [%d, %d]", min_order, max_order (showing min/max order is optional since it kinda defeat the purpose of having the helper function). Of course, the comment needs to be changed.

Hmm, but still how could the above check to trigger the warning when split_type == SPLIT_TYPE_NON_UNIFORM and new_order is 0? It will not trigger, since new_order (as 0) is supported by the mapping.

I guess the min_order check code has to be in the else branch along with the existing "if (split_type == SPLIT_TYPE_NON_UNIFORM || new_order)".

Quoted 27 lines
mm/huge_memory.c +0 -7
 			/*
 			 * We can always split a folio down to a single page
 			 * (new_order == 0) uniformly.
@@ -3827,7 +3827,6 @@ static int __folio_split(struct folio *folio, unsigned int new_order,
 		}
 		mapping = NULL;
 	} else {
-		unsigned int min_order;
 		gfp_t gfp;
 
 		mapping = folio->mapping;
@@ -3843,12 +3842,6 @@ static int __folio_split(struct folio *folio, unsigned int new_order,
 			goto out;
 		}
 
-		min_order = mapping_min_folio_order(folio->mapping);
-		if (new_order < min_order) {
-			ret = -EINVAL;
-			goto out;
-		}
-
 		gfp = current_gfp_context(mapping_gfp_mask(mapping) &
 							GFP_RECLAIM_MASK);
 
Signature · 2 lines
Wei Yang
Help you, Help me

--
Best Regards,
Yan, Zi

author
#12 lore raw

Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

Quoted 104 lines · Zi Yan
Quoted 63 lines · Wei Yang
Quoted 54 lines · Zi Yan
Quoted 52 lines · Wei Yang
Quoted 43 lines · Zi Yan
Quoted 36 lines · Wei Yang

The functions uniform_split_supported() and non_uniform_split_supported() share significantly similar logic.

The only functional difference is that uniform_split_supported() includes an additional check on the requested @new_order.

The reason for this check comes from the following two aspects:

* some file system or swap cache just supports order-0 folio
* the behavioral difference between uniform/non-uniform split

The behavioral difference between uniform split and non-uniform:

* uniform split splits folio directly to @new_order
* non-uniform split creates after-split folios with orders from folio_order(folio) - 1 to new_order.

This means for non-uniform split or !new_order split we should check the file system and swap cache respectively.

This commit unifies the logic and merge the two functions into a single combined helper, removing redundant code and simplifying the split support checking mechanism.

Cc Zi Yan <[email protected]>
Cc "David Hildenbrand (Red Hat)" <[email protected]>

---
v3:
* adjust to use split_type
* rebase on Zi Yan fix lkml.kernel.org/r/[email protected]
v2:
* remove need_check
* update comment
* add more explanation in change log

Quoted 5 lines
---
 include/linux/huge_mm.h |  8 ++---
 mm/huge_memory.c        | 71 +++++++++++++++++------------------------
 2 files changed, 33 insertions(+), 46 deletions(-)
Quoted 1 line

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

Hi, Zi

I am thinking whether it is proper to move the check (new_order < min_order) from __folio_split() to folio_split_supported(). So that we could bail out early if file system couldn't split to new_order.

Quoted 7 lines
Quoted 1 line

Not sure you like it or not.

It sounds reasonable. My only concern is that that might add another indentation to the else branch in folio_split_supported().

You can send a patch, so we can see how it looks.

Quoted 7 lines

Here is what come up my mind.

If !CONFIG_READ_ONLY_THP_FOR_FS, we directly compare new_order and min_order.

If CONFIG_READ_ONLY_THP_FOR_FS, one thing I am not sure is for the khugepaged collapsed THP. If its min_order is 0, it looks we can cover it with following check.

1. mapping_large_folio_support() checks if mapping_max_folio_order() > 0, meaning !mapping_large_folio_support() is mapping_max_folio_order() == 0,
2. mapping_max_folio_order() >= mapping_min_folio_order(),
3. combining 1) and 2) means
mapping_min_folio_order() <= mapping_max_folio_order() == 0, meaning mapping_min_folio_order() == 0.

so a FS without large folio support always has min_order == 0.

Quoted 8 lines

Look forward your insight.

mm/huge_memory.c +0 -0
index dee416b3f6ed..ef05f246df73 100644

mm/huge_memory.c bool folio_split_supported(struct folio *folio, unsigned int new_order, · line 3708

Quoted 7 lines
mm/huge_memory.c +2 -2
@@ -3704,8 +3704,8 @@ bool folio_split_supported(struct folio *folio, unsigned int new_order,
 		if (new_order == 1)
 			return false;
 	} else if (split_type == SPLIT_TYPE_NON_UNIFORM || new_order) {
-		if (IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) &&
-		    !mapping_large_folio_support(folio->mapping)) {
+		unsigned int min_order = mapping_min_folio_order(folio->mapping);
+		if (new_order < min_order) {

This check is good for !CONFIG_READ_ONLY_THP_FOR_FS, but for CONFIG_READ_ONLY_THP_FOR_FS and !mapping_large_folio_support(), min_order is always 0, how can new_order be smaller than min_order to trigger the warning below? You will need to check new_order against mapping_max_folio_order().

Quoted 2 lines

OK, basically the check should be:

Thanks for your analysis.

Quoted 2 lines

if (new_order < mapping_min_folio_order() || new_order > mapping_max_folio_order()).

This reminds me one thing, we don't check on max_order now.

For example, the supported split order is [3, 5]. But new_order is set to 6.

In current kernel, we don't do this. try_folio_split_or_unmap() pass min_order. But selftest will split from pmd_order - 1.

Quoted 6 lines

Then, you might want to add a helper function mapping_folio_order_supported() instead and change the warning message below to "Cannot split file folio to unsupported order [%d, %d]", min_order, max_order (showing min/max order is optional since it kinda defeat the purpose of having the helper function). Of course, the comment needs to be changed.

Quoted 7 lines

Hmm, but still how could the above check to trigger the warning when split_type == SPLIT_TYPE_NON_UNIFORM and new_order is 0? It will not trigger, since new_order (as 0) is supported by the mapping.

I guess the min_order check code has to be in the else branch along with the existing "if (split_type == SPLIT_TYPE_NON_UNIFORM || new_order)".

I am trying to think another way.

For uniform split, after-split folio order is new_order.
For non-uniform split, after-split folio order is [new_order, old_order - 1].

So I come up following draft change.

mm/huge_memory.c +11 -21
index dee416b3f6ed..873680ab4cbb 100644
@@ -3703,28 +3703,18 @@ bool folio_split_supported(struct folio *folio, unsigned int new_order,
 				"Cannot split to order-1 folio");
 		if (new_order == 1)
 			return false;
-	} else if (split_type == SPLIT_TYPE_NON_UNIFORM || new_order) {
-		if (IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) &&
-		    !mapping_large_folio_support(folio->mapping)) {
-			/*
-			 * We can always split a folio down to a single page
-			 * (new_order == 0) uniformly.
-			 *
-			 * For any other scenario
-			 *   a) uniform split targeting a large folio
-			 *      (new_order > 0)
-			 *   b) any non-uniform split
-			 * we must confirm that the file system supports large
-			 * folios.
-			 *
-			 * Note that we might still have THPs in such
-			 * mappings, which is created from khugepaged when
-			 * CONFIG_READ_ONLY_THP_FOR_FS is enabled. But in that
-			 * case, the mapping does not actually support large
-			 * folios properly.
-			 */
+	} else {
+		/*
+		 * Some explanation here.
+		 */
+		if (new_order && !mapping_folio_order_supported(new_order)) {
+			VM_WARN_ONCE(warns,
+				"Cannot split file folio to unsupported order: %d", new_order);
+			return false;
+		}
+		if (split_type == SPLIT_TYPE_NON_UNIFORM && !mapping_folio_order_supported(old_order - 1)) {
 			VM_WARN_ONCE(warns,
-				"Cannot split file folio to non-0 order");
+				"Cannot split file folio to unsupported order: %d", old_order - 1);
 			return false;
 		}
 	}
Signature · 2 lines
Wei Yang
Help you, Help me
author
#13 lore raw

Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

Quoted 175 lines · Wei Yang
Quoted 104 lines · Zi Yan
Quoted 63 lines · Wei Yang
Quoted 54 lines · Zi Yan
Quoted 52 lines · Wei Yang
Quoted 43 lines · Zi Yan
Quoted 36 lines · Wei Yang

The functions uniform_split_supported() and non_uniform_split_supported() share significantly similar logic.

The only functional difference is that uniform_split_supported() includes an additional check on the requested @new_order.

The reason for this check comes from the following two aspects:

* some file system or swap cache just supports order-0 folio
* the behavioral difference between uniform/non-uniform split

The behavioral difference between uniform split and non-uniform:

* uniform split splits folio directly to @new_order
* non-uniform split creates after-split folios with orders from folio_order(folio) - 1 to new_order.

This means for non-uniform split or !new_order split we should check the file system and swap cache respectively.

This commit unifies the logic and merge the two functions into a single combined helper, removing redundant code and simplifying the split support checking mechanism.

Cc Zi Yan <[email protected]>
Cc "David Hildenbrand (Red Hat)" <[email protected]>

---
v3:
* adjust to use split_type
* rebase on Zi Yan fix lkml.kernel.org/r/[email protected]
v2:
* remove need_check
* update comment
* add more explanation in change log

Quoted 5 lines
---
 include/linux/huge_mm.h |  8 ++---
 mm/huge_memory.c        | 71 +++++++++++++++++------------------------
 2 files changed, 33 insertions(+), 46 deletions(-)
Quoted 1 line

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

Hi, Zi

I am thinking whether it is proper to move the check (new_order < min_order) from __folio_split() to folio_split_supported(). So that we could bail out early if file system couldn't split to new_order.

Quoted 7 lines
Quoted 1 line

Not sure you like it or not.

It sounds reasonable. My only concern is that that might add another indentation to the else branch in folio_split_supported().

You can send a patch, so we can see how it looks.

Quoted 7 lines

Here is what come up my mind.

If !CONFIG_READ_ONLY_THP_FOR_FS, we directly compare new_order and min_order.

If CONFIG_READ_ONLY_THP_FOR_FS, one thing I am not sure is for the khugepaged collapsed THP. If its min_order is 0, it looks we can cover it with following check.

1. mapping_large_folio_support() checks if mapping_max_folio_order() > 0, meaning !mapping_large_folio_support() is mapping_max_folio_order() == 0,
2. mapping_max_folio_order() >= mapping_min_folio_order(),
3. combining 1) and 2) means
mapping_min_folio_order() <= mapping_max_folio_order() == 0, meaning mapping_min_folio_order() == 0.

so a FS without large folio support always has min_order == 0.

Quoted 8 lines

Look forward your insight.

mm/huge_memory.c +0 -0
index dee416b3f6ed..ef05f246df73 100644

mm/huge_memory.c bool folio_split_supported(struct folio *folio, unsigned int new_order, · line 3708

Quoted 7 lines
mm/huge_memory.c +2 -2
@@ -3704,8 +3704,8 @@ bool folio_split_supported(struct folio *folio, unsigned int new_order,
 		if (new_order == 1)
 			return false;
 	} else if (split_type == SPLIT_TYPE_NON_UNIFORM || new_order) {
-		if (IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) &&
-		    !mapping_large_folio_support(folio->mapping)) {
+		unsigned int min_order = mapping_min_folio_order(folio->mapping);
+		if (new_order < min_order) {

This check is good for !CONFIG_READ_ONLY_THP_FOR_FS, but for CONFIG_READ_ONLY_THP_FOR_FS and !mapping_large_folio_support(), min_order is always 0, how can new_order be smaller than min_order to trigger the warning below? You will need to check new_order against mapping_max_folio_order().

Quoted 2 lines

OK, basically the check should be:

Thanks for your analysis.

Quoted 2 lines

if (new_order < mapping_min_folio_order() || new_order > mapping_max_folio_order()).

This reminds me one thing, we don't check on max_order now.

For example, the supported split order is [3, 5]. But new_order is set to 6.

In current kernel, we don't do this. try_folio_split_or_unmap() pass min_order. But selftest will split from pmd_order - 1.

Quoted 6 lines

Then, you might want to add a helper function mapping_folio_order_supported() instead and change the warning message below to "Cannot split file folio to unsupported order [%d, %d]", min_order, max_order (showing min/max order is optional since it kinda defeat the purpose of having the helper function). Of course, the comment needs to be changed.

Quoted 7 lines

Hmm, but still how could the above check to trigger the warning when split_type == SPLIT_TYPE_NON_UNIFORM and new_order is 0? It will not trigger, since new_order (as 0) is supported by the mapping.

I guess the min_order check code has to be in the else branch along with the existing "if (split_type == SPLIT_TYPE_NON_UNIFORM || new_order)".

I am trying to think another way.

For uniform split, after-split folio order is new_order.
For non-uniform split, after-split folio order is [new_order, old_order - 1].

So I come up following draft change.

mm/huge_memory.c +6 -20
index dee416b3f6ed..873680ab4cbb 100644
@@ -3703,28 +3703,18 @@ bool folio_split_supported(struct folio *folio, unsigned int new_order,
 				"Cannot split to order-1 folio");
 		if (new_order == 1)
 			return false;
-	} else if (split_type == SPLIT_TYPE_NON_UNIFORM || new_order) {
-		if (IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) &&
-		    !mapping_large_folio_support(folio->mapping)) {
-			/*
-			 * We can always split a folio down to a single page
-			 * (new_order == 0) uniformly.
-			 *
-			 * For any other scenario
-			 *   a) uniform split targeting a large folio
-			 *      (new_order > 0)
-			 *   b) any non-uniform split
-			 * we must confirm that the file system supports large
-			 * folios.
-			 *
-			 * Note that we might still have THPs in such
-			 * mappings, which is created from khugepaged when
-			 * CONFIG_READ_ONLY_THP_FOR_FS is enabled. But in that
-			 * case, the mapping does not actually support large
-			 * folios properly.
-			 */
+	} else {
+		/*
+		 * Some explanation here.
+		 */
+		if (new_order && !mapping_folio_order_supported(new_order)) {
+			VM_WARN_ONCE(warns,

mm/huge_memory.c bool folio_split_supported(struct folio *folio, unsigned int new_order, · line 3720

Quoted 10 lines
mm/huge_memory.c +5 -1
+				"Cannot split file folio to unsupported order: %d", new_order);
+			return false;
+		}
+		if (split_type == SPLIT_TYPE_NON_UNIFORM && !mapping_folio_order_supported(old_order - 1)) {
 			VM_WARN_ONCE(warns,
-				"Cannot split file folio to non-0 order");
+				"Cannot split file folio to unsupported order: %d", old_order - 1);
 			return false;
 		}
 	}

Hi, Zi Yan

Does it look good to you?

Signature · 2 lines
Wei Yang
Help you, Help me
author
#14 lore raw

Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

In reply to Wei Yang
Quoted 28 lines · Wei Yang

The functions uniform_split_supported() and non_uniform_split_supported() share significantly similar logic.

The only functional difference is that uniform_split_supported() includes an additional check on the requested @new_order.

The reason for this check comes from the following two aspects:

* some file system or swap cache just supports order-0 folio
* the behavioral difference between uniform/non-uniform split

The behavioral difference between uniform split and non-uniform:

* uniform split splits folio directly to @new_order
* non-uniform split creates after-split folios with orders from folio_order(folio) - 1 to new_order.

This means for non-uniform split or !new_order split we should check the file system and swap cache respectively.

This commit unifies the logic and merge the two functions into a single combined helper, removing redundant code and simplifying the split support checking mechanism.

Cc Zi Yan <[email protected]>
Cc "David Hildenbrand (Red Hat)" <[email protected]>

[...]

Quoted 11 lines
mm/huge_memory.c +1 -10
-/* See comments in non_uniform_split_supported() */
-bool uniform_split_supported(struct folio *folio, unsigned int new_order,
-		bool warns)
-{
-	if (folio_test_anon(folio)) {
-		VM_WARN_ONCE(warns && new_order == 1,
-				"Cannot split to order-1 folio");
-		if (new_order == 1)
-			return false;
-	} else  if (new_order) {
+	} else if (split_type == SPLIT_TYPE_NON_UNIFORM || new_order) {
Quoted 2 lines
		if (IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) &&
		    !mapping_large_folio_support(folio->mapping)) {

After re-scan the code, I found we may have a NULL pointer dereference here.

We bail out if folio->mapping == NULL in __folio_split(), which means it is possible to be NULL. But we access mapping->flags here.

Looks there is no bug report yet, so I am not sure it worth a separate fix to original code.

Quoted 51 lines
mm/huge_memory.c +17 -0
+			/*
+			 * We can always split a folio down to a single page
+			 * (new_order == 0) uniformly.
+			 *
+			 * For any other scenario
+			 *   a) uniform split targeting a large folio
+			 *      (new_order > 0)
+			 *   b) any non-uniform split
+			 * we must confirm that the file system supports large
+			 * folios.
+			 *
+			 * Note that we might still have THPs in such
+			 * mappings, which is created from khugepaged when
+			 * CONFIG_READ_ONLY_THP_FOR_FS is enabled. But in that
+			 * case, the mapping does not actually support large
+			 * folios properly.
+			 */
			VM_WARN_ONCE(warns,
				"Cannot split file folio to non-0 order");
			return false;
		}
	}
mm/huge_memory.c +9 -1
-	if (new_order && folio_test_swapcache(folio)) {
+	/*
+	 * swapcache folio could only be split to order 0
+	 *
+	 * non-uniform split creates after-split folios with orders from
+	 * folio_order(folio) - 1 to new_order, making it not suitable for any
+	 * swapcache folio split. Only uniform split to order-0 can be used
+	 * here.
+	 */
+	if ((split_type == SPLIT_TYPE_NON_UNIFORM || new_order) && folio_test_swapcache(folio)) {
		VM_WARN_ONCE(warns,
			"Cannot split swapcache folio to non-0 order");
		return false;
mm/huge_memory.c +1 -5
@@ -3794,11 +3787,7 @@ static int __folio_split(struct folio *folio, unsigned int new_order,
 	if (new_order >= old_order)
 		return -EINVAL;
 
-	if (split_type == SPLIT_TYPE_UNIFORM && !uniform_split_supported(folio, new_order, true))
-		return -EINVAL;
-
-	if (split_type == SPLIT_TYPE_NON_UNIFORM &&
-	    !non_uniform_split_supported(folio, new_order, true))
+	if (!folio_split_supported(folio, new_order, split_type, /* warn = */ true))
 		return -EINVAL;
 
 	is_hzp = is_huge_zero_folio(folio);
Signature · 1 line
2.34.1
Signature · 2 lines
Wei Yang
Help you, Help me
reviewer
#15 lore raw

Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

Quoted 46 lines · Wei Yang
Quoted 28 lines · Wei Yang

The functions uniform_split_supported() and non_uniform_split_supported() share significantly similar logic.

The only functional difference is that uniform_split_supported() includes an additional check on the requested @new_order.

The reason for this check comes from the following two aspects:

* some file system or swap cache just supports order-0 folio
* the behavioral difference between uniform/non-uniform split

The behavioral difference between uniform split and non-uniform:

* uniform split splits folio directly to @new_order
* non-uniform split creates after-split folios with orders from folio_order(folio) - 1 to new_order.

This means for non-uniform split or !new_order split we should check the file system and swap cache respectively.

This commit unifies the logic and merge the two functions into a single combined helper, removing redundant code and simplifying the split support checking mechanism.

Cc Zi Yan <[email protected]>
Cc "David Hildenbrand (Red Hat)" <[email protected]>

[...]

Quoted 11 lines
mm/huge_memory.c +1 -10
-/* See comments in non_uniform_split_supported() */
-bool uniform_split_supported(struct folio *folio, unsigned int new_order,
-		bool warns)
-{
-	if (folio_test_anon(folio)) {
-		VM_WARN_ONCE(warns && new_order == 1,
-				"Cannot split to order-1 folio");
-		if (new_order == 1)
-			return false;
-	} else  if (new_order) {
+	} else if (split_type == SPLIT_TYPE_NON_UNIFORM || new_order) {
Quoted 2 lines
		if (IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) &&
		    !mapping_large_folio_support(folio->mapping)) {

After re-scan the code, I found we may have a NULL pointer dereference here.

Quoted 5 lines

We bail out if folio->mapping == NULL in __folio_split(), which means it is possible to be NULL. But we access mapping->flags here.

Looks there is no bug report yet, so I am not sure it worth a separate fix to original code.

Probably because the race is small, but a fix is still needed. Likely commit 6a50c9b512f7 ("mm: huge_memory: fix misused mapping_large_folio_support() for anon folios") introduced it, but please double check.

Quoted 49 lines
Quoted 49 lines
mm/huge_memory.c +17 -0
+			/*
+			 * We can always split a folio down to a single page
+			 * (new_order == 0) uniformly.
+			 *
+			 * For any other scenario
+			 *   a) uniform split targeting a large folio
+			 *      (new_order > 0)
+			 *   b) any non-uniform split
+			 * we must confirm that the file system supports large
+			 * folios.
+			 *
+			 * Note that we might still have THPs in such
+			 * mappings, which is created from khugepaged when
+			 * CONFIG_READ_ONLY_THP_FOR_FS is enabled. But in that
+			 * case, the mapping does not actually support large
+			 * folios properly.
+			 */
			VM_WARN_ONCE(warns,
				"Cannot split file folio to non-0 order");
			return false;
		}
	}
mm/huge_memory.c +9 -1
-	if (new_order && folio_test_swapcache(folio)) {
+	/*
+	 * swapcache folio could only be split to order 0
+	 *
+	 * non-uniform split creates after-split folios with orders from
+	 * folio_order(folio) - 1 to new_order, making it not suitable for any
+	 * swapcache folio split. Only uniform split to order-0 can be used
+	 * here.
+	 */
+	if ((split_type == SPLIT_TYPE_NON_UNIFORM || new_order) && folio_test_swapcache(folio)) {
		VM_WARN_ONCE(warns,
			"Cannot split swapcache folio to non-0 order");
		return false;
mm/huge_memory.c +1 -5
@@ -3794,11 +3787,7 @@ static int __folio_split(struct folio *folio, unsigned int new_order,
 	if (new_order >= old_order)
 		return -EINVAL;
 
-	if (split_type == SPLIT_TYPE_UNIFORM && !uniform_split_supported(folio, new_order, true))
-		return -EINVAL;
-
-	if (split_type == SPLIT_TYPE_NON_UNIFORM &&
-	    !non_uniform_split_supported(folio, new_order, true))
+	if (!folio_split_supported(folio, new_order, split_type, /* warn = */ true))
 		return -EINVAL;
 
Quoted 7 lines
Quoted 3 lines
mm/huge_memory.c +0 -0
 	is_hzp = is_huge_zero_folio(folio);
Signature · 1 line
2.34.1
Signature · 2 lines
Wei Yang
Help you, Help me

Best Regards,
Yan, Zi

author
#16 lore raw

Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

Quoted 51 lines · Zi Yan
Quoted 49 lines · Wei Yang
Quoted 28 lines · Wei Yang

The functions uniform_split_supported() and non_uniform_split_supported() share significantly similar logic.

The only functional difference is that uniform_split_supported() includes an additional check on the requested @new_order.

The reason for this check comes from the following two aspects:

* some file system or swap cache just supports order-0 folio
* the behavioral difference between uniform/non-uniform split

The behavioral difference between uniform split and non-uniform:

* uniform split splits folio directly to @new_order
* non-uniform split creates after-split folios with orders from folio_order(folio) - 1 to new_order.

This means for non-uniform split or !new_order split we should check the file system and swap cache respectively.

This commit unifies the logic and merge the two functions into a single combined helper, removing redundant code and simplifying the split support checking mechanism.

Cc Zi Yan <[email protected]>
Cc "David Hildenbrand (Red Hat)" <[email protected]>

[...]

Quoted 11 lines
mm/huge_memory.c +1 -10
-/* See comments in non_uniform_split_supported() */
-bool uniform_split_supported(struct folio *folio, unsigned int new_order,
-		bool warns)
-{
-	if (folio_test_anon(folio)) {
-		VM_WARN_ONCE(warns && new_order == 1,
-				"Cannot split to order-1 folio");
-		if (new_order == 1)
-			return false;
-	} else  if (new_order) {
+	} else if (split_type == SPLIT_TYPE_NON_UNIFORM || new_order) {
Quoted 2 lines
		if (IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) &&
		    !mapping_large_folio_support(folio->mapping)) {

After re-scan the code, I found we may have a NULL pointer dereference here.

We bail out if folio->mapping == NULL in __folio_split(), which means it is possible to be NULL. But we access mapping->flags here.

Quoted 8 lines
Quoted 2 lines

Looks there is no bug report yet, so I am not sure it worth a separate fix to original code.

Probably because the race is small, but a fix is still needed. Likely commit 6a50c9b512f7 ("mm: huge_memory: fix misused mapping_large_folio_support() for anon folios") introduced it, but please double check.

Thanks, I will check which one introduced this issue.

@Andrew,

I will prepare a stand-alone fix for this issue and rebase this patch set on top of it.

Signature · 2 lines
Wei Yang
Help you, Help me
author
#17 lore raw

Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

In reply to Zi Yan
Quoted 51 lines · Zi Yan
Quoted 49 lines · Wei Yang
Quoted 28 lines · Wei Yang

The functions uniform_split_supported() and non_uniform_split_supported() share significantly similar logic.

The only functional difference is that uniform_split_supported() includes an additional check on the requested @new_order.

The reason for this check comes from the following two aspects:

* some file system or swap cache just supports order-0 folio
* the behavioral difference between uniform/non-uniform split

The behavioral difference between uniform split and non-uniform:

* uniform split splits folio directly to @new_order
* non-uniform split creates after-split folios with orders from folio_order(folio) - 1 to new_order.

This means for non-uniform split or !new_order split we should check the file system and swap cache respectively.

This commit unifies the logic and merge the two functions into a single combined helper, removing redundant code and simplifying the split support checking mechanism.

Cc Zi Yan <[email protected]>
Cc "David Hildenbrand (Red Hat)" <[email protected]>

[...]

Quoted 11 lines
mm/huge_memory.c +1 -10
-/* See comments in non_uniform_split_supported() */
-bool uniform_split_supported(struct folio *folio, unsigned int new_order,
-		bool warns)
-{
-	if (folio_test_anon(folio)) {
-		VM_WARN_ONCE(warns && new_order == 1,
-				"Cannot split to order-1 folio");
-		if (new_order == 1)
-			return false;
-	} else  if (new_order) {
+	} else if (split_type == SPLIT_TYPE_NON_UNIFORM || new_order) {
Quoted 2 lines
		if (IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) &&
		    !mapping_large_folio_support(folio->mapping)) {

After re-scan the code, I found we may have a NULL pointer dereference here.

We bail out if folio->mapping == NULL in __folio_split(), which means it is possible to be NULL. But we access mapping->flags here.

Quoted 8 lines
Quoted 2 lines

Looks there is no bug report yet, so I am not sure it worth a separate fix to original code.

Probably because the race is small, but a fix is still needed. Likely commit 6a50c9b512f7 ("mm: huge_memory: fix misused mapping_large_folio_support() for anon folios") introduced it, but please double check.

After searching the history, it has four related commits.

I listed here in timeline.

[1] commit c010d47f107f609b9f4d6a103b6dfc53889049e9
Author: Zi Yan <[email protected]>
Date: Mon Feb 26 15:55:33 2024 -0500

mm: thp: split huge page to any lower order pages

[2] commit 6a50c9b512f7734bc356f4bd47885a6f7c98491a (HEAD -> tmp)
Author: Ran Xiaokai <[email protected]>
Date: Fri Jun 7 17:40:48 2024 +0800

mm: huge_memory: fix misused mapping_large_folio_support() for anon folios

[3] commit 9b2f764933eb5e3ac9ebba26e3341529219c4401 (refs/bisect/bad)
Author: Zi Yan <[email protected]>
Date: Wed Jan 22 11:19:27 2025 -0500

mm/huge_memory: allow split shmem large folio to any lower order

[4] commit 58729c04cf1092b87aeef0bf0998c9e2e4771133 (HEAD -> tmp)
Author: Zi Yan <[email protected]>
Date: Fri Mar 7 12:39:57 2025 -0500

mm/huge_memory: add buddy allocator like (non-uniform) folio_split()

So I think the fix tag should be [1], right?

And do we need cc stable?

Signature · 2 lines
Wei Yang
Help you, Help me
reviewer
#18 lore raw

Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

Quoted 83 lines · Wei Yang
Quoted 51 lines · Zi Yan
Quoted 49 lines · Wei Yang
Quoted 28 lines · Wei Yang

The functions uniform_split_supported() and non_uniform_split_supported() share significantly similar logic.

The only functional difference is that uniform_split_supported() includes an additional check on the requested @new_order.

The reason for this check comes from the following two aspects:

* some file system or swap cache just supports order-0 folio
* the behavioral difference between uniform/non-uniform split

The behavioral difference between uniform split and non-uniform:

* uniform split splits folio directly to @new_order
* non-uniform split creates after-split folios with orders from folio_order(folio) - 1 to new_order.

This means for non-uniform split or !new_order split we should check the file system and swap cache respectively.

This commit unifies the logic and merge the two functions into a single combined helper, removing redundant code and simplifying the split support checking mechanism.

Cc Zi Yan <[email protected]>
Cc "David Hildenbrand (Red Hat)" <[email protected]>

[...]

Quoted 11 lines
mm/huge_memory.c +1 -10
-/* See comments in non_uniform_split_supported() */
-bool uniform_split_supported(struct folio *folio, unsigned int new_order,
-		bool warns)
-{
-	if (folio_test_anon(folio)) {
-		VM_WARN_ONCE(warns && new_order == 1,
-				"Cannot split to order-1 folio");
-		if (new_order == 1)
-			return false;
-	} else  if (new_order) {
+	} else if (split_type == SPLIT_TYPE_NON_UNIFORM || new_order) {
Quoted 2 lines
		if (IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) &&
		    !mapping_large_folio_support(folio->mapping)) {

After re-scan the code, I found we may have a NULL pointer dereference here.

We bail out if folio->mapping == NULL in __folio_split(), which means it is possible to be NULL. But we access mapping->flags here.

Quoted 8 lines
Quoted 2 lines

Looks there is no bug report yet, so I am not sure it worth a separate fix to original code.

Probably because the race is small, but a fix is still needed. Likely commit 6a50c9b512f7 ("mm: huge_memory: fix misused mapping_large_folio_support() for anon folios") introduced it, but please double check.

After searching the history, it has four related commits.

I listed here in timeline.

[1] commit c010d47f107f609b9f4d6a103b6dfc53889049e9
Author: Zi Yan <[email protected]>
Date: Mon Feb 26 15:55:33 2024 -0500

mm: thp: split huge page to any lower order pages

[2] commit 6a50c9b512f7734bc356f4bd47885a6f7c98491a (HEAD -> tmp)
Author: Ran Xiaokai <[email protected]>
Date: Fri Jun 7 17:40:48 2024 +0800

mm: huge_memory: fix misused mapping_large_folio_support() for anon folios

[3] commit 9b2f764933eb5e3ac9ebba26e3341529219c4401 (refs/bisect/bad)
Author: Zi Yan <[email protected]>
Date: Wed Jan 22 11:19:27 2025 -0500

mm/huge_memory: allow split shmem large folio to any lower order

Quoted 7 lines

[4] commit 58729c04cf1092b87aeef0bf0998c9e2e4771133 (HEAD -> tmp)
Author: Zi Yan <[email protected]>
Date: Fri Mar 7 12:39:57 2025 -0500

mm/huge_memory: add buddy allocator like (non-uniform) folio_split()

So I think the fix tag should be [1], right?

I think so.

Quoted 2 lines

And do we need cc stable?

Yes, please.

Thanks.

Best Regards,
Yan, Zi

maintainer
#19 lore raw

Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

Quoted 6 lines · On Mon, 17 Nov 2025 23:10:26 -0500 Zi Yan <[email protected]> wrote:
Quoted 6 lines

[4] commit 58729c04cf1092b87aeef0bf0998c9e2e4771133 (HEAD -> tmp)
Author: Zi Yan <[email protected]>
Date: Fri Mar 7 12:39:57 2025 -0500

mm/huge_memory: add buddy allocator like (non-uniform) folio_split()

Quoted 8 lines
Quoted 1 line

So I think the fix tag should be [1], right?

I think so.

Quoted 2 lines

And do we need cc stable?

Yes, please.

I added:

Fixes c010d47f107f ("mm: thp: split huge page to any lower order pages")
reviewer
#20 lore raw

Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

Quoted 13 lines · Andrew Morton
Quoted 11 lines · On Mon, 17 Nov 2025 23:10:26 -0500 Zi Yan <[email protected]> wrote:
Quoted 7 lines

[4] commit 58729c04cf1092b87aeef0bf0998c9e2e4771133 (HEAD -> tmp)
Author: Zi Yan <[email protected]>
Date: Fri Mar 7 12:39:57 2025 -0500

mm/huge_memory: add buddy allocator like (non-uniform) folio_split()

So I think the fix tag should be [1], right?

I think so.

Quoted 1 line
Quoted 8 lines
Quoted 3 lines
Quoted 1 line

And do we need cc stable?

Yes, please.

I added:

Fixes c010d47f107f ("mm: thp: split huge page to any lower order pages")

Hi Andrew,

This patch does not fix the NULL dereferencing issue yet. Wei is going to
1. send a patch to fix the bug on top of mm-stable,
2. resend this patchset on top of the fix in 1.

This might be easier for back porting the fix. Maybe you can drop this series for now.

Wei, do you agree?

Best Regards,
Yan, Zi

maintainer
#21 lore raw

Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

Quoted 11 lines · On Tue, 18 Nov 2025 13:55:15 -0500 Zi Yan <[email protected]> wrote:
Quoted 8 lines
Quoted 3 lines
Quoted 1 line

And do we need cc stable?

Yes, please.

I added:

Fixes c010d47f107f ("mm: thp: split huge page to any lower order pages")

Hi Andrew,

Quoted 8 lines

This patch does not fix the NULL dereferencing issue yet. Wei is going to
1. send a patch to fix the bug on top of mm-stable,
2. resend this patchset on top of the fix in 1.

This might be easier for back porting the fix. Maybe you can drop this series for now.

Wei, do you agree?

Dropping this series messes up later patches. I could of course redo things but would prefer a fixed up version of this patchset asap, please.

author
#22 lore raw

Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

Quoted 17 lines · Andrew Morton
Quoted 15 lines · On Tue, 18 Nov 2025 13:55:15 -0500 Zi Yan <[email protected]> wrote:
Quoted 8 lines
Quoted 3 lines
Quoted 1 line

And do we need cc stable?

Yes, please.

I added:

Fixes c010d47f107f ("mm: thp: split huge page to any lower order pages")

Hi Andrew,

This patch does not fix the NULL dereferencing issue yet. Wei is going to
1. send a patch to fix the bug on top of mm-stable,
2. resend this patchset on top of the fix in 1.

Quoted 7 lines
Quoted 4 lines

This might be easier for back porting the fix. Maybe you can drop this series for now.

Wei, do you agree?

Dropping this series messes up later patches. I could of course redo things but would prefer a fixed up version of this patchset asap, please.

Ok, i will prepare a fixed on top of this.

Signature · 2 lines
Wei Yang
Help you, Help me
maintainer
#23 lore raw

Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

Quoted 9 lines · On Wed, 19 Nov 2025 00:52:48 +0000 Wei Yang <[email protected]> wrote:
Quoted 9 lines
Quoted 9 lines

Hi Andrew,

This patch does not fix the NULL dereferencing issue yet. Wei is going to
1. send a patch to fix the bug on top of mm-stable,
2. resend this patchset on top of the fix in 1.

This might be easier for back porting the fix. Maybe you can drop this series for now.

Quoted 6 lines
Quoted 4 lines
Quoted 1 line

Wei, do you agree?

Dropping this series messes up later patches. I could of course redo things but would prefer a fixed up version of this patchset asap, please.

Ok, i will prepare a fixed on top of this.

Did this happen?

I remain unclear on the status of this small series. Issues which I have flagged are:

https://lkml.kernel.org/r/20251118021047.uyldr7aay6fb5evt@master
https://lkml.kernel.org/r/[email protected]
https://lkml.kernel.org/r/20251117012239.lqm33uu4vl4y5zqc@master
https://lkml.kernel.org/r/[email protected]

and a couple of comments from yourself indicating that updates are required.

Have all these things now been addressed?

reviewer
#24 lore raw

Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

Quoted 28 lines · Andrew Morton
Quoted 9 lines · On Wed, 19 Nov 2025 00:52:48 +0000 Wei Yang <[email protected]> wrote:
Quoted 9 lines
Quoted 9 lines

Hi Andrew,

This patch does not fix the NULL dereferencing issue yet. Wei is going to
1. send a patch to fix the bug on top of mm-stable,
2. resend this patchset on top of the fix in 1.

This might be easier for back porting the fix. Maybe you can drop this series for now.

Quoted 6 lines
Quoted 4 lines
Quoted 1 line

Wei, do you agree?

Dropping this series messes up later patches. I could of course redo things but would prefer a fixed up version of this patchset asap, please.

Ok, i will prepare a fixed on top of this.

Did this happen?

I remain unclear on the status of this small series. Issues which I have flagged are:

https://lkml.kernel.org/r/20251118021047.uyldr7aay6fb5evt@master
https://lkml.kernel.org/r/[email protected]
https://lkml.kernel.org/r/20251117012239.lqm33uu4vl4y5zqc@master
https://lkml.kernel.org/r/[email protected]

Quoted 4 lines

and a couple of comments from yourself indicating that updates are required.

Have all these things now been addressed?

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

It seems that you already picked it up.

Best Regards,
Yan, Zi

author
#25 lore raw

Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

In reply to Andrew Morton
Quoted 20 lines · Andrew Morton
Quoted 9 lines · On Wed, 19 Nov 2025 00:52:48 +0000 Wei Yang <[email protected]> wrote:
Quoted 9 lines
Quoted 9 lines

Hi Andrew,

This patch does not fix the NULL dereferencing issue yet. Wei is going to
1. send a patch to fix the bug on top of mm-stable,
2. resend this patchset on top of the fix in 1.

This might be easier for back porting the fix. Maybe you can drop this series for now.

Quoted 6 lines
Quoted 4 lines
Quoted 1 line

Wei, do you agree?

Dropping this series messes up later patches. I could of course redo things but would prefer a fixed up version of this patchset asap, please.

Ok, i will prepare a fixed on top of this.

Did this happen?

Quoted 8 lines

I remain unclear on the status of this small series. Issues which I have flagged are:

https://lkml.kernel.org/r/20251118021047.uyldr7aay6fb5evt@master
https://lkml.kernel.org/r/[email protected]
https://lkml.kernel.org/r/20251117012239.lqm33uu4vl4y5zqc@master
https://lkml.kernel.org/r/[email protected]

There are two related topic:

1. A null pointer dereference bug:

    https://lkml.kernel.org/r/20251118021047.uyldr7aay6fb5evt@master
    https://lkml.kernel.org/r/20251117012239.lqm33uu4vl4y5zqc@master
    https://lkml.kernel.org/r/[email protected]

This three mail are related to the bug, which is fixed in :

    http://lkml.kernel.org/r/[email protected]

Currently looks good, and will do backport when necessary.

2. A further cleanup attempt:

    https://lkml.kernel.org/r/[email protected]

This one is the related mail.

I proposed one version in

    http://lkml.kernel.org/r/[email protected]

But it is not proper, will do follow up work later.

Quoted 4 lines

and a couple of comments from yourself indicating that updates are required.

Have all these things now been addressed?

Hope it is clear now :-)

Signature · 2 lines
Wei Yang
Help you, Help me
reviewer
#26 lore raw

Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

Quoted 38 lines · Wei Yang
Quoted 20 lines · Andrew Morton
Quoted 9 lines · On Wed, 19 Nov 2025 00:52:48 +0000 Wei Yang <[email protected]> wrote:
Quoted 9 lines
Quoted 9 lines

Hi Andrew,

This patch does not fix the NULL dereferencing issue yet. Wei is going to
1. send a patch to fix the bug on top of mm-stable,
2. resend this patchset on top of the fix in 1.

This might be easier for back porting the fix. Maybe you can drop this series for now.

Quoted 6 lines
Quoted 4 lines
Quoted 1 line

Wei, do you agree?

Dropping this series messes up later patches. I could of course redo things but would prefer a fixed up version of this patchset asap, please.

Ok, i will prepare a fixed on top of this.

Did this happen?

Quoted 8 lines

I remain unclear on the status of this small series. Issues which I have flagged are:

https://lkml.kernel.org/r/20251118021047.uyldr7aay6fb5evt@master
https://lkml.kernel.org/r/[email protected]
https://lkml.kernel.org/r/20251117012239.lqm33uu4vl4y5zqc@master
https://lkml.kernel.org/r/[email protected]

There are two related topic:

1. A null pointer dereference bug:

   https://lkml.kernel.org/r/20251118021047.uyldr7aay6fb5evt@master
   https://lkml.kernel.org/r/20251117012239.lqm33uu4vl4y5zqc@master
   https://lkml.kernel.org/r/[email protected]
Quoted 5 lines

This three mail are related to the bug, which is fixed in :

   http://lkml.kernel.org/r/[email protected]

Currently looks good, and will do backport when necessary.

This one is picked up by Andrew.

Quoted 5 lines

2. A further cleanup attempt:

   https://lkml.kernel.org/r/[email protected]
Quoted 7 lines

This one is the related mail.

I proposed one version in

   http://lkml.kernel.org/r/[email protected]

But it is not proper, will do follow up work later.

Please refrain from sending more patches related to __folio_split() and its related functions until the above hotfix is merged. I also have an ongoing cleanup patchset[1] and want to get it in before any other changes.

Thanks.

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

Quoted 11 lines
Quoted 5 lines

and a couple of comments from yourself indicating that updates are required.

Have all these things now been addressed?

Hope it is clear now :-)

Signature · 2 lines
Wei Yang
Help you, Help me

--
Best Regards,
Yan, Zi

maintainer
#27 lore raw

Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

Quoted 7 lines · On Fri, 21 Nov 2025 09:59:42 -0500 Zi Yan <[email protected]> wrote:
Quoted 7 lines

2. A further cleanup attempt:

   https://lkml.kernel.org/r/[email protected]

This one is the related mail.

Quoted 8 lines
Quoted 5 lines

I proposed one version in

   http://lkml.kernel.org/r/[email protected]

But it is not proper, will do follow up work later.

Please refrain from sending more patches related to __folio_split() and its related functions until the above hotfix is merged.

You're referring to
https://lkml.kernel.org/r/[email protected]?

Quoted 2 lines

I also have an ongoing
cleanup patchset[1] and want to get it in before any other changes.

I remain unclear on the status of this patchset. Is it considered good to upstream or is additional work required?

reviewer
#28 lore raw

Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

Quoted 13 lines · Andrew Morton
Quoted 11 lines · On Fri, 21 Nov 2025 09:59:42 -0500 Zi Yan <[email protected]> wrote:
Quoted 11 lines

2. A further cleanup attempt:

https://lkml.kernel.org/r/[email protected]

This one is the related mail.

I proposed one version in

http://lkml.kernel.org/r/[email protected]

Quoted 7 lines
Quoted 4 lines
Quoted 1 line

But it is not proper, will do follow up work later.

Please refrain from sending more patches related to __folio_split() and its related functions until the above hotfix is merged.

You're referring to
https://lkml.kernel.org/r/[email protected]?

Yes.

Quoted 6 lines
Quoted 3 lines

I also have an ongoing
cleanup patchset[1] and want to get it in before any other changes.

I remain unclear on the status of this patchset. Is it considered good to upstream or is additional work required?

I am still having a discussion with David Hildenbrand about it and hopefully get it sorted out soon. The reason is that the above hotfix is good for backport but future user of folio_split_supported() can still dereference a NULL folio->mapping unless they check folio->mapping != NULL beforehand. I would like to avoid that by refactoring folio_split_support().

Wei’s further cleanup patch can come after my refactoring by just moving a code hunk above.

Best Regards,
Yan, Zi

maintainer
#29 lore raw

Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

Quoted 32 lines · On Fri, 21 Nov 2025 12:00:51 -0500 Zi Yan <[email protected]> wrote:
Quoted 13 lines · Andrew Morton
Quoted 11 lines · On Fri, 21 Nov 2025 09:59:42 -0500 Zi Yan <[email protected]> wrote:
Quoted 11 lines

2. A further cleanup attempt:

https://lkml.kernel.org/r/[email protected]

This one is the related mail.

I proposed one version in

http://lkml.kernel.org/r/[email protected]

Quoted 7 lines
Quoted 4 lines
Quoted 1 line

But it is not proper, will do follow up work later.

Please refrain from sending more patches related to __folio_split() and its related functions until the above hotfix is merged.

You're referring to
https://lkml.kernel.org/r/[email protected]?

Yes.

Quoted 6 lines
Quoted 3 lines

I also have an ongoing
cleanup patchset[1] and want to get it in before any other changes.

I remain unclear on the status of this patchset. Is it considered good to upstream or is additional work required?

Quoted 9 lines

I am still having a discussion with David Hildenbrand about it and hopefully get it sorted out soon. The reason is that the above hotfix is good for backport but future user of folio_split_supported() can still dereference a NULL folio->mapping unless they check folio->mapping != NULL beforehand. I would like to avoid that by refactoring folio_split_support().

Wei’s further cleanup patch can come after my refactoring by just moving a code hunk above.

This is coming down to the wire. I'm considering dropping

mm-huge_memory-introduce-enum-split_type-for-clarity.patch mm-huge_memory-introduce-enum-split_type-for-clarity-fix.patch mm-huge_memory-merge-uniform_split_supported-and-non_uniform_split_supported.patch

and

mm-huge_memoryc-introduce-folio_split_unmapped.patch mm-huge_memoryc-introduce-folio_split_unmapped-v2.patch mm-huge_memoryc-introduce-folio_split_unmapped-v2-fix.patch mm-huge_memoryc-introduce-folio_split_unmapped-v2-fix-fix.patch

and we can revisit after the upcoming merge window. Thoughts?

reviewer
#30 lore raw

Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

Quoted 50 lines · Andrew Morton
Quoted 32 lines · On Fri, 21 Nov 2025 12:00:51 -0500 Zi Yan <[email protected]> wrote:
Quoted 13 lines · Andrew Morton
Quoted 11 lines · On Fri, 21 Nov 2025 09:59:42 -0500 Zi Yan <[email protected]> wrote:
Quoted 11 lines

2. A further cleanup attempt:

https://lkml.kernel.org/r/[email protected]

This one is the related mail.

I proposed one version in

http://lkml.kernel.org/r/[email protected]

Quoted 7 lines
Quoted 4 lines
Quoted 1 line

But it is not proper, will do follow up work later.

Please refrain from sending more patches related to __folio_split() and its related functions until the above hotfix is merged.

You're referring to
https://lkml.kernel.org/r/[email protected]?

Yes.

Quoted 6 lines
Quoted 3 lines

I also have an ongoing
cleanup patchset[1] and want to get it in before any other changes.

I remain unclear on the status of this patchset. Is it considered good to upstream or is additional work required?

Quoted 9 lines

I am still having a discussion with David Hildenbrand about it and hopefully get it sorted out soon. The reason is that the above hotfix is good for backport but future user of folio_split_supported() can still dereference a NULL folio->mapping unless they check folio->mapping != NULL beforehand. I would like to avoid that by refactoring folio_split_support().

Wei’s further cleanup patch can come after my refactoring by just moving a code hunk above.

This is coming down to the wire. I'm considering dropping

mm-huge_memory-introduce-enum-split_type-for-clarity.patch mm-huge_memory-introduce-enum-split_type-for-clarity-fix.patch mm-huge_memory-merge-uniform_split_supported-and-non_uniform_split_supported.patch

Quoted 8 lines

and

mm-huge_memoryc-introduce-folio_split_unmapped.patch mm-huge_memoryc-introduce-folio_split_unmapped-v2.patch mm-huge_memoryc-introduce-folio_split_unmapped-v2-fix.patch mm-huge_memoryc-introduce-folio_split_unmapped-v2-fix-fix.patch

and we can revisit after the upcoming merge window. Thoughts?

These patches are fine as is. The patch I asked Wei to hold on sending is “[PATCH] mm/huge_memory: consolidate order-related checks into folio_split_supported()”[1]. The current mm-new, mm-unstable trees look good to me. Sorry if it was not clear.

[1] https://lore.kernel.org/linux-mm/[email protected]/

Best Regards,
Yan, Zi

maintainer
#31 lore raw

Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()

Quoted 12 lines · On Fri, 21 Nov 2025 14:09:39 -0500 Zi Yan <[email protected]> wrote:
Quoted 12 lines
Quoted 3 lines

Wei’s further cleanup patch can come after my refactoring by just moving a code hunk above.

This is coming down to the wire. I'm considering dropping

mm-huge_memory-introduce-enum-split_type-for-clarity.patch mm-huge_memory-introduce-enum-split_type-for-clarity-fix.patch mm-huge_memory-merge-uniform_split_supported-and-non_uniform_split_supported.patch

and

Quoted 8 lines
Quoted 6 lines

mm-huge_memoryc-introduce-folio_split_unmapped.patch mm-huge_memoryc-introduce-folio_split_unmapped-v2.patch mm-huge_memoryc-introduce-folio_split_unmapped-v2-fix.patch mm-huge_memoryc-introduce-folio_split_unmapped-v2-fix-fix.patch

and we can revisit after the upcoming merge window. Thoughts?

These patches are fine as is.

Well that's good news.

Quoted 7 lines

The patch I asked Wei to hold on sending
is “[PATCH] mm/huge_memory: consolidate order-related checks into folio_split_supported()”[1]. The current mm-new, mm-unstable trees look good to me. Sorry if it was not clear.

[1] https://lore.kernel.org/linux-mm/[email protected]/

OK.