mm/huge_memory: Define split_type and consolidate split support checks
Subsystems (2)
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
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.
--- 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
@@ -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
@@ -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
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 splitDifferentiating between these types using a simple boolean variable is not obvious and can harm code readability.
This commit introduces enum
split_typeto 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.
Signed-off-by Wei Yang <[email protected]>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
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 splitDifferentiating between these types using a simple boolean variable is not obvious and can harm code readability.
This commit introduces enum
split_typeto 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.
Signed-off-by Wei Yang <[email protected]>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
Zi Yan
reviewerRe: [Patch v3 1/2] mm/huge_memory: introduce enum split_type for clarity
In reply to Wei YangQuoted 14 lines · Wei Yang
We currently handle two distinct types of large folio splitting:
* uniform split
* non-uniform splitDifferentiating between these types using a simple boolean variable is not obvious and can harm code readability.
This commit introduces enum
split_typeto 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
Signed-off-by Wei Yang <[email protected]>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
PATCH v3 2/2 mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()
In reply to Wei YangThe 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.
---
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
@@ -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_ostatic 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
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()andnon_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 splitThe 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 fromfolio_order(folio)- 1 tonew_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.
Signed-off-by Wei Yang <[email protected]>Cc Zi Yan <[email protected]>Cc "David Hildenbrand (Red Hat)" <[email protected]>
Signature · 3 lines
Cheers David
Zi Yan
reviewerRe: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()
In reply to Wei YangQuoted 36 lines · Wei Yang
The functions
uniform_split_supported()andnon_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 splitThe 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 fromfolio_order(folio)- 1 tonew_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.
Signed-off-by Wei Yang <[email protected]>Cc Zi Yan <[email protected]>Cc "David Hildenbrand (Red Hat)" <[email protected]>---
v3:
* adjust to usesplit_type
* rebase on Zi Yan fix lkml.kernel.org/r/[email protected]
v2:
* removeneed_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
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()andnon_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 splitThe 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 fromfolio_order(folio)- 1 tonew_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.
Signed-off-by Wei Yang <[email protected]>Cc Zi Yan <[email protected]>Cc "David Hildenbrand (Red Hat)" <[email protected]>---
v3:
* adjust to usesplit_type
* rebase on Zi Yan fix lkml.kernel.org/r/[email protected]
v2:
* removeneed_check
* update comment
* add more explanation in change logQuoted 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
Zi Yan
reviewerRe: [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()andnon_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 splitThe 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 fromfolio_order(folio)- 1 tonew_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.
Signed-off-by Wei Yang <[email protected]>Cc Zi Yan <[email protected]>Cc "David Hildenbrand (Red Hat)" <[email protected]>---
v3:
* adjust to usesplit_type
* rebase on Zi Yan fix lkml.kernel.org/r/[email protected]
v2:
* removeneed_check
* update comment
* add more explanation in change logQuoted 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()tofolio_split_supported(). So that we could bail out early if file system couldn't split tonew_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
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()andnon_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 splitThe 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 fromfolio_order(folio)- 1 tonew_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.
Signed-off-by Wei Yang <[email protected]>Cc Zi Yan <[email protected]>Cc "David Hildenbrand (Red Hat)" <[email protected]>---
v3:
* adjust to usesplit_type
* rebase on Zi Yan fix lkml.kernel.org/r/[email protected]
v2:
* removeneed_check
* update comment
* add more explanation in change logQuoted 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()tofolio_split_supported(). So that we could bail out early if file system couldn't split tonew_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
@@ -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
Zi Yan
reviewerRe: [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()andnon_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 splitThe 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 fromfolio_order(folio)- 1 tonew_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.
Signed-off-by Wei Yang <[email protected]>Cc Zi Yan <[email protected]>Cc "David Hildenbrand (Red Hat)" <[email protected]>---
v3:
* adjust to usesplit_type
* rebase on Zi Yan fix lkml.kernel.org/r/[email protected]
v2:
* removeneed_check
* update comment
* add more explanation in change logQuoted 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()tofolio_split_supported(). So that we could bail out early if file system couldn't split tonew_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_orderandmin_order.If
CONFIG_READ_ONLY_THP_FOR_FS, one thing I am not sure is for the khugepaged collapsed THP. If itsmin_orderis 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
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
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()andnon_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 splitThe 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 fromfolio_order(folio)- 1 tonew_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.
Signed-off-by Wei Yang <[email protected]>Cc Zi Yan <[email protected]>Cc "David Hildenbrand (Red Hat)" <[email protected]>---
v3:
* adjust to usesplit_type
* rebase on Zi Yan fix lkml.kernel.org/r/[email protected]
v2:
* removeneed_check
* update comment
* add more explanation in change logQuoted 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()tofolio_split_supported(). So that we could bail out early if file system couldn't split tonew_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_orderandmin_order.If
CONFIG_READ_ONLY_THP_FOR_FS, one thing I am not sure is for the khugepaged collapsed THP. If itsmin_orderis 0, it looks we can cover it with following check.1.
mapping_large_folio_support()checks ifmapping_max_folio_order()> 0, meaning !mapping_large_folio_support() ismapping_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, meaningmapping_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
-0mm/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_FSand !mapping_large_folio_support(),min_orderis always 0, how cannew_orderbe smaller thanmin_orderto trigger the warning below? You will need to checknew_orderagainstmapping_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_UNIFORMandnew_orderis 0? It will not trigger, sincenew_order(as 0) is supported by the mapping.I guess the
min_ordercheck 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
@@ -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
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()andnon_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 splitThe 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 fromfolio_order(folio)- 1 tonew_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.
Signed-off-by Wei Yang <[email protected]>Cc Zi Yan <[email protected]>Cc "David Hildenbrand (Red Hat)" <[email protected]>---
v3:
* adjust to usesplit_type
* rebase on Zi Yan fix lkml.kernel.org/r/[email protected]
v2:
* removeneed_check
* update comment
* add more explanation in change logQuoted 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()tofolio_split_supported(). So that we could bail out early if file system couldn't split tonew_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_orderandmin_order.If
CONFIG_READ_ONLY_THP_FOR_FS, one thing I am not sure is for the khugepaged collapsed THP. If itsmin_orderis 0, it looks we can cover it with following check.1.
mapping_large_folio_support()checks ifmapping_max_folio_order()> 0, meaning !mapping_large_folio_support() ismapping_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, meaningmapping_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
-0mm/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_FSand !mapping_large_folio_support(),min_orderis always 0, how cannew_orderbe smaller thanmin_orderto trigger the warning below? You will need to checknew_orderagainstmapping_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_ordernow.For example, the supported split order is [3, 5]. But
new_orderis set to 6.In current kernel, we don't do this.
try_folio_split_or_unmap()passmin_order. But selftest will split frompmd_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_UNIFORMandnew_orderis 0? It will not trigger, sincenew_order(as 0) is supported by the mapping.I guess the
min_ordercheck 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@@ -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
Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()
In reply to Wei YangQuoted 28 lines · Wei Yang
The functions
uniform_split_supported()andnon_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 splitThe 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 fromfolio_order(folio)- 1 tonew_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.
Signed-off-by Wei Yang <[email protected]>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
Zi Yan
reviewerRe: [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()andnon_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 splitThe 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 fromfolio_order(folio)- 1 tonew_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.
Signed-off-by Wei Yang <[email protected]>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 accessmapping->flagshere.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
-0is_hzp =is_huge_zero_folio (folio);Signature · 1 line
2.34.1Signature · 2 lines
Wei Yang Help you, Help me
Best Regards,
Yan, Zi
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()andnon_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 splitThe 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 fromfolio_order(folio)- 1 tonew_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.
Signed-off-by Wei Yang <[email protected]>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 accessmapping->flagshere.
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 misusedmapping_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
Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()
In reply to Zi YanQuoted 51 lines · Zi Yan
Quoted 49 lines · Wei Yang
Quoted 28 lines · Wei Yang
The functions
uniform_split_supported()andnon_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 splitThe 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 fromfolio_order(folio)- 1 tonew_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.
Signed-off-by Wei Yang <[email protected]>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 accessmapping->flagshere.
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 misusedmapping_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
Zi Yan
reviewerRe: [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()andnon_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 splitThe 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 fromfolio_order(folio)- 1 tonew_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.
Signed-off-by Wei Yang <[email protected]>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 accessmapping->flagshere.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 misusedmapping_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 -0500mm: 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 +0800mm:
huge_memory: fix misusedmapping_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
Andrew Morton
maintainerRe: [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:
Zi Yan
reviewerRe: [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")Cc <[email protected]>
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
Andrew Morton
maintainerRe: [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")Cc <[email protected]>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.
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")Cc <[email protected]>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
Andrew Morton
maintainerRe: [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?
Zi Yan
reviewerRe: [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
Re: [Patch v3 2/2] mm/huge_memory: merge uniform_split_supported() and non_uniform_split_supported()
In reply to Andrew MortonQuoted 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
Zi Yan
reviewerRe: [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
Andrew Morton
maintainerRe: [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?
Zi Yan
reviewerRe: [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
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
Andrew Morton
maintainerRe: [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
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 NULLfolio->mappingunless they checkfolio->mapping!= NULL beforehand. I would like to avoid that by refactoringfolio_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?
Zi Yan
reviewerRe: [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
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 NULLfolio->mappingunless they checkfolio->mapping!= NULL beforehand. I would like to avoid that by refactoringfolio_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
Andrew Morton
maintainerRe: [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.
OK.