Skip to contentSkip to conversation

Remove read-only THP support for FSes without large folio support

PATCH Superseded Zi Yan 5 participants 65 messages Apr 13 – Apr 17

Subsystems (8)

v2 of 6 Superseded Latest is v6 →

lore
Share & tools
lore

Zi Yan

author reviewer
#0 lore raw

v2 cover Remove read-only THP support for FSes without large folio support

Hi all,

This patchset removes READ_ONLY_THP_FOR_FS Kconfig and enables creating read-only THPs for FSes with large folio support (the supported orders need to include PMD_ORDER) by default.

Before the patchset, the status of creating read-only THPs is below:

                            |    PF     | MADV_COLLAPSE | khugepaged |
                            |-----------|---------------|------------|
 large folio FSes only      |     ✓     |       x       |      x     |
 READ_ONLY_THP_FOR_FS only  |     x     |       ✓       |      ✓     |
 both                       |     ✓     |       ✓       |      ✓     |

where READ_ONLY_THP_FOR_FS implies no large folio FSes.

Now without READ_ONLY_THP_FOR_FS:

                           |    PF     | MADV_COLLAPSE | khugepaged |
                           |-----------|---------------|------------|
 large folio FSes          |     ✓     |       ✓       |      ✓     |
 no large folio FSes       |     x     |       x       |      x     |

This means no large folio FSes need to add large folio support (the supported orders need to include PMD_ORDER), so that they can leverage read-only THP creation function.

To prevent breaking read-only THP support for large folio FSes,
1. first 3 patches enables the support, so that without READ_ONLY_THP_FOR_FS, read-only THP still works for large folio FSes,
2. Patch 4 removes READ_ONLY_THP_FOR_FS Kconfig,
3. the rest of patches remove code related to READ_ONLY_THP_FOR_FS.

The overview of the changes is:

1. collapse_file() checks for to-be-collapsed folio dirtiness after they are locked, unmapped, and corresponding mappings are flushed from TLBs to prevent writes to candidate folios. Before, mapping->nr_thps and inode->i_writecount are used to cause read-only THP truncation before a fd becomes writable.

2. hugepage_pmd_enabled() no longer always returned true if CONFIG_READ_ONLY_THP_FOR_FS was enabaled. This affects whether khugepaged will be on or not. It now depends on anon and shmem configurations. Namely, if a user who has set /sys/kernel/mm/transparent_hugepage/enabled to always or madvise but explicitly disabled anon PMD THP and shmem THP via the per-order sysfs controls, read-only THP support will be disabled.

3. collapse_file() from mm/khugepaged.c, instead of checking CONFIG_READ_ONLY_THP_FOR_FS, makes sure the mapping_max_folio_order() of struct address_space of the file is at least PMD_ORDER.

4. file_thp_enabled() also checks mapping_max_folio_order() instead.

5. truncate_inode_partial_folio() calls folio_split() directly instead of the removed try_folio_split_to_order(), since large folios can only show up on a FS with large folio support.

6. nr_thps is removed from struct address_space, since it is no longer needed to drop all read-only THPs from a FS without large folio support when the fd becomes writable. Its related filemap_nr_thps*() are removed too.

7. folio_check_splittable() no longer checks READ_ONLY_THP_FOR_FS.

8. Updated comments in various places.

Changelog
===
From V1[2]:
1. removed inode_is_open_for_write() check in collapse_file(), since the added folio dirtiness check after try_to_unmap_flush() should be sufficient to prevent writes to candidate folios.

2. removed READ_ONLY_THP_FOR_FS check in hugepage_pmd_enabled(), please see Patch 5 and item 2 in the overview for more details.

3. moved the patch removing READ_ONLY_THP_FOR_FS Kconfig after enabling khugepaged and MADV_COLLAPSE to create read-only THPs.

4. added mapping_pmd_thp_support() helper function.

5. used VM_WARN_ON_ONCE() in collapse_file() for mapping eligibility check and address alignment check instead of if + return error code. Always allow shmem, since MADV_COLLAPSE ignore shmem huge config.

6. added mapping eligibility check in collapse_scan_file().

7. removed trailing ; for folio_split() in the !CONFIG_TRANSPARENT_HUGEPAGE.

8. simplified code in folio_check_splittable() after removing READ_ONLY_THP_FOR_FS code.

9. clarified that read-only THP works for FSes with PMD THP support by default.

From RFC[1]:
1. instead of removing READ_ONLY_THP_FOR_FS function entirely, turn it on by default for all FSes with large folio support and the supported orders includes PMD_ORDER.

Suggestions and comments are welcome.

Zi Yan (12):
mm/khugepaged: remove READ_ONLY_THP_FOR_FS check mm/khugepaged: add folio dirty check after try_to_unmap_flush() mm/huge_memory: remove READ_ONLY_THP_FOR_FS from file_thp_enabled()
mm: remove READ_ONLY_THP_FOR_FS Kconfig option mm/khugepaged: remove READ_ONLY_THP_FOR_FS check in
hugepage_pmd_enabled()
mm: fs: remove filemap_nr_thps*() functions and their users
fs: remove nr_thps from struct address_space mm/huge_memory: remove folio split check for READ_ONLY_THP_FOR_FS mm/truncate: use folio_split() in truncate_inode_partial_folio() fs/btrfs: remove a comment referring to READ_ONLY_THP_FOR_FS selftests/mm: remove READ_ONLY_THP_FOR_FS in khugepaged selftests/mm: remove READ_ONLY_THP_FOR_FS from comments in
guard-regions

 fs/btrfs/defrag.c                          |  3 -
 fs/inode.c                                 |  3 -
 fs/open.c                                  | 27 ---------
 include/linux/fs.h                         |  5 --
 include/linux/huge_mm.h                    | 25 +--------
 include/linux/pagemap.h                    | 29 ----------
 mm/Kconfig                                 | 11 ----
 mm/filemap.c                               |  1 -
 mm/huge_memory.c                           | 37 ++----------
 mm/khugepaged.c                            | 65 ++++++++++------------
 mm/truncate.c                              |  8 +--
 tools/testing/selftests/mm/guard-regions.c |  9 +--
 tools/testing/selftests/mm/khugepaged.c    |  4 +-
 13 files changed, 49 insertions(+), 178 deletions(-)
Signature · 1 line
2.43.0
author reviewer
#1 lore raw

PATCH v2 1/12 mm/khugepaged: remove READ_ONLY_THP_FOR_FS check

collapse_file() requires FSes supporting large folio with at least PMD_ORDER, so replace the READ_ONLY_THP_FOR_FS check with that. MADV_COLLAPSE ignores shmem huge config, so exclude the check for shmem.

While at it, replace VM_BUG_ON with VM_WARN_ON_ONCE.

In collapse_scan_file(), add FS eligibility check to avoid redundant scans.

---
 mm/khugepaged.c | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)
mm/khugepaged.c +10 -2
index b8452dbdb043..d2f0acd2dac2 100644
@@ -1892,8 +1892,9 @@ static enum scan_result collapse_file(struct mm_struct *mm, unsigned long addr,
 	int nr_none = 0;
 	bool is_shmem = shmem_file(file);
 
-	VM_BUG_ON(!IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) && !is_shmem);
-	VM_BUG_ON(start & (HPAGE_PMD_NR - 1));
+	/* MADV_COLLAPSE ignores shmem huge config, so do not check shmem */
+	VM_WARN_ON_ONCE(!is_shmem && mapping_max_folio_order(mapping) < PMD_ORDER);
+	VM_WARN_ON_ONCE(start & (HPAGE_PMD_NR - 1));
 
 	result = alloc_charge_folio(&new_folio, mm, cc);
 	if (result != SCAN_SUCCEED)
@@ -2321,6 +2322,13 @@ static enum scan_result collapse_scan_file(struct mm_struct *mm,
 	int node = NUMA_NO_NODE;
 	enum scan_result result = SCAN_SUCCEED;
 
+	/*
+	 * skip files without PMD-order folio support
+	 * do not check shmem, since MADV_COLLAPSE ignores shmem huge config
+	 */
+	if (!shmem_file(file) && mapping_max_folio_order(mapping) < PMD_ORDER)
+		return SCAN_FAIL;
+
 	present = 0;
 	swap = 0;
 	memset(cc->node_load, 0, sizeof(cc->node_load));
Signature · 1 line
2.43.0
maintainer
#2 lore raw

Re: [PATCH 7.2 v2 01/12] mm/khugepaged: remove READ_ONLY_THP_FOR_FS check

Quoted 5 lines · Zi Yan

collapse_file() requires FSes supporting large folio with at least PMD_ORDER, so replace the READ_ONLY_THP_FOR_FS check with that. MADV_COLLAPSE ignores shmem huge config, so exclude the check for shmem.

While at it, replace VM_BUG_ON with VM_WARN_ON_ONCE.

Why? These are bugs. I don't think we gain anything from continuing.

mm/khugepaged.c static enum scan_result collapse_scan_file(struct mm_struct *mm, · line 2330

Quoted 6 lines
mm/khugepaged.c +6 -0
+	/*
+	 * skip files without PMD-order folio support
+	 * do not check shmem, since MADV_COLLAPSE ignores shmem huge config
+	 */
+	if (!shmem_file(file) && mapping_max_folio_order(mapping) < PMD_ORDER)
+		return SCAN_FAIL;

I wonder if it should. If the commit message to 5a90c155defa is to be believed,

Since 'deny' is for emergencies and 'force' is for testing, performance issues should not be a problem in real production environments, so don't call mapping_set_large_folios() in __shmem_get_inode() when large folio is disabled with mount huge=never option (default policy).

so maybe MADV_COLLAPSE should honour huge=never? Documentation/filesystems/tmpfs.rst implies that we do!

huge=never Do not allocate huge pages. This is the default.
huge=always Attempt to allocate huge page every time a new page is needed.
huge=within_size Only allocate huge page if it will be fully within i_size.
Also respect madvise(2) hints.
huge=advise Only allocate huge page if requested with madvise(2).

so what's the difference between huge=never and huge=madvise?

author reviewer
#3 lore raw

Re: [PATCH 7.2 v2 01/12] mm/khugepaged: remove READ_ONLY_THP_FOR_FS check

Quoted 8 lines · Matthew Wilcox
Quoted 5 lines · Zi Yan

collapse_file() requires FSes supporting large folio with at least PMD_ORDER, so replace the READ_ONLY_THP_FOR_FS check with that. MADV_COLLAPSE ignores shmem huge config, so exclude the check for shmem.

While at it, replace VM_BUG_ON with VM_WARN_ON_ONCE.

Why? These are bugs. I don't think we gain anything from continuing.

The goal is to catch these issues during development. VM_BUG_ON crashes the system and that is too much for such issues in collapse_file().

Quoted 19 lines

mm/khugepaged.c static enum scan_result collapse_scan_file(struct mm_struct *mm, · line 2330

Quoted 7 lines
mm/khugepaged.c +6 -0
+	/*
+	 * skip files without PMD-order folio support
+	 * do not check shmem, since MADV_COLLAPSE ignores shmem huge config
+	 */
+	if (!shmem_file(file) && mapping_max_folio_order(mapping) < PMD_ORDER)
+		return SCAN_FAIL;

I wonder if it should. If the commit message to 5a90c155defa is to be believed,

Since 'deny' is for emergencies and 'force' is for testing, performance issues should not be a problem in real production environments, so don't call mapping_set_large_folios() in __shmem_get_inode() when large folio is disabled with mount huge=never option (default policy).

so maybe MADV_COLLAPSE should honour huge=never? Documentation/filesystems/tmpfs.rst implies that we do!

Quoted 7 lines

huge=never Do not allocate huge pages. This is the default.
huge=always Attempt to allocate huge page every time a new page is needed.
huge=within_size Only allocate huge page if it will be fully within i_size.
Also respect madvise(2) hints.
huge=advise Only allocate huge page if requested with madvise(2).

so what's the difference between huge=never and huge=madvise?

I think madvise means MADV_HUGEPAGE for the region, not MADV_COLLAPSE.

In v1, I did the check for shmem, but that regressed MADV_COLLAPSE, which always can collapse THPs on shmem. I know it sounds unreasonable, but that ship has sailed.

Best Regards,
Yan, Zi

#4 lore raw

Re: [PATCH 7.2 v2 01/12] mm/khugepaged: remove READ_ONLY_THP_FOR_FS check

Quoted 7 lines · Zi Yan
Quoted 5 lines · Matthew Wilcox
Quoted 4 lines · Zi Yan

collapse_file() requires FSes supporting large folio with at least PMD_ORDER, so replace the READ_ONLY_THP_FOR_FS check with that. MADV_COLLAPSE ignores shmem huge config, so exclude the check for shmem.

Quoted 6 lines
Quoted 3 lines
Quoted 1 line

While at it, replace VM_BUG_ON with VM_WARN_ON_ONCE.

Why? These are bugs. I don't think we gain anything from continuing.

The goal is to catch these issues during development. VM_BUG_ON crashes the system and that is too much for such issues in collapse_file().

VM_BUG_ON should have never been added to the kernel.

Signature · 3 lines
Cheers,

David
#5 lore raw

Re: [PATCH 7.2 v2 01/12] mm/khugepaged: remove READ_ONLY_THP_FOR_FS check

In reply to Zi Yan
Quoted 9 lines
Quoted 7 lines

huge=never Do not allocate huge pages. This is the default.
huge=always Attempt to allocate huge page every time a new page is needed.
huge=within_size Only allocate huge page if it will be fully within i_size.
Also respect madvise(2) hints.
huge=advise Only allocate huge page if requested with madvise(2).

so what's the difference between huge=never and huge=madvise?

I think madvise means MADV_HUGEPAGE for the region, not MADV_COLLAPSE.

Yes, most likely. The doc is quite old.

Signature · 3 lines
Cheers,

David
reviewer
#6 lore raw

Re: [PATCH 7.2 v2 01/12] mm/khugepaged: remove READ_ONLY_THP_FOR_FS check

In reply to Zi Yan
Quoted 39 lines · Zi Yan
Quoted 8 lines · Matthew Wilcox
Quoted 5 lines · Zi Yan

collapse_file() requires FSes supporting large folio with at least PMD_ORDER, so replace the READ_ONLY_THP_FOR_FS check with that. MADV_COLLAPSE ignores shmem huge config, so exclude the check for shmem.

While at it, replace VM_BUG_ON with VM_WARN_ON_ONCE.

Why? These are bugs. I don't think we gain anything from continuing.

The goal is to catch these issues during development. VM_BUG_ON crashes the system and that is too much for such issues in collapse_file().

Quoted 25 lines

mm/khugepaged.c static enum scan_result collapse_scan_file(struct mm_struct *mm, · line 2330

Quoted 7 lines
mm/khugepaged.c +6 -0
+	/*
+	 * skip files without PMD-order folio support
+	 * do not check shmem, since MADV_COLLAPSE ignores shmem huge config
+	 */
+	if (!shmem_file(file) && mapping_max_folio_order(mapping) < PMD_ORDER)
+		return SCAN_FAIL;

I wonder if it should. If the commit message to 5a90c155defa is to be believed,

Since 'deny' is for emergencies and 'force' is for testing, performance issues should not be a problem in real production environments, so don't call mapping_set_large_folios() in __shmem_get_inode() when large folio is disabled with mount huge=never option (default policy).

so maybe MADV_COLLAPSE should honour huge=never? Documentation/filesystems/tmpfs.rst implies that we do!

huge=never Do not allocate huge pages. This is the default.
huge=always Attempt to allocate huge page every time a new page is needed.
huge=within_size Only allocate huge page if it will be fully within i_size.
Also respect madvise(2) hints.
huge=advise Only allocate huge page if requested with madvise(2).

Quoted 3 lines
Quoted 1 line

so what's the difference between huge=never and huge=madvise?

I think madvise means MADV_HUGEPAGE for the region, not MADV_COLLAPSE.

Right.

Quoted 3 lines

In v1, I did the check for shmem, but that regressed MADV_COLLAPSE, which always can collapse THPs on shmem. I know it sounds unreasonable, but that ship has sailed.

Previously, I tried to make MADV_COLLAPSE also honour the THP configuration of shmem/tmpfs[1], but Hugh strongly objected and explained the original intent of MADV_COLLAPSE[2]. I’ll quote Hugh’s comments:

"
Seldom has a feature been so thorougly documented as MADV_COLLAPSE, in its 6.1 commits and in the "man 2 madvise" page: which are explicit about MADV_COLLAPSE providing a way to get THPs where the sysfs setting governing automatic behaviour does not insert them.

We would all prefer a less messy world of THP tunables. I certainly find plenty to dislike there too; and wish that a less assertive name than "never" had been chosen originally for the default off position.

But please don't break the accepted and documented behaviour of MADV_COLLAPSE now.

If you want to exclude all possibility of THPs, then please use the prctl(PR_SET_THP_DISABLE); or shmem_enabled=deny (I think it was me who insisted that be respected by MADV_COLLAPSE back then). "

Afterwards, we reached an agreement to keep the current logic, and Lorenzo helped update the docs, see commit a27848a03504 (“docs: update THP documentation to clarify sysfs ‘never’ setting”).

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

#7 lore raw

Re: [PATCH 7.2 v2 01/12] mm/khugepaged: remove READ_ONLY_THP_FOR_FS check

In reply to Zi Yan
Quoted 30 lines · Zi Yan

collapse_file() requires FSes supporting large folio with at least PMD_ORDER, so replace the READ_ONLY_THP_FOR_FS check with that. MADV_COLLAPSE ignores shmem huge config, so exclude the check for shmem.

While at it, replace VM_BUG_ON with VM_WARN_ON_ONCE.

In collapse_scan_file(), add FS eligibility check to avoid redundant scans.

---
 mm/khugepaged.c | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)
mm/khugepaged.c +3 -2
index b8452dbdb043..d2f0acd2dac2 100644
@@ -1892,8 +1892,9 @@ static enum scan_result collapse_file(struct mm_struct *mm, unsigned long addr,
 	int nr_none = 0;
 	bool is_shmem = shmem_file(file);
 
-	VM_BUG_ON(!IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) && !is_shmem);
-	VM_BUG_ON(start & (HPAGE_PMD_NR - 1));
+	/* MADV_COLLAPSE ignores shmem huge config, so do not check shmem */
+	VM_WARN_ON_ONCE(!is_shmem && mapping_max_folio_order(mapping) < PMD_ORDER);
+	VM_WARN_ON_ONCE(start & (HPAGE_PMD_NR - 1));
 
 	result = alloc_charge_folio(&new_folio, mm, cc);
 	if (result != SCAN_SUCCEED)

mm/khugepaged.c static enum scan_result collapse_scan_file(struct mm_struct *mm, · line 2328

Quoted 7 lines
mm/khugepaged.c +4 -0
@@ -2321,6 +2322,13 @@ static enum scan_result collapse_scan_file(struct mm_struct *mm,
 	int node = NUMA_NO_NODE;
 	enum scan_result result = SCAN_SUCCEED;
 
+	/*
+	 * skip files without PMD-order folio support
+	 * do not check shmem, since MADV_COLLAPSE ignores shmem huge config
+	 */

How is the !collapse path handled? Through thp_vma_allowable_order() in collapse_scan_mm_slot()?

Wouldn't it be better to have that check exactly there?

Signature · 3 lines
Cheers,

David
reviewer
#8 lore raw

Re: [PATCH 7.2 v2 01/12] mm/khugepaged: remove READ_ONLY_THP_FOR_FS check

Quoted 42 lines · David Hildenbrand (Arm)
Quoted 30 lines · Zi Yan

collapse_file() requires FSes supporting large folio with at least PMD_ORDER, so replace the READ_ONLY_THP_FOR_FS check with that. MADV_COLLAPSE ignores shmem huge config, so exclude the check for shmem.

While at it, replace VM_BUG_ON with VM_WARN_ON_ONCE.

In collapse_scan_file(), add FS eligibility check to avoid redundant scans.

---
 mm/khugepaged.c | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)
mm/khugepaged.c +3 -2
index b8452dbdb043..d2f0acd2dac2 100644
@@ -1892,8 +1892,9 @@ static enum scan_result collapse_file(struct mm_struct *mm, unsigned long addr,
 	int nr_none = 0;
 	bool is_shmem = shmem_file(file);
 
-	VM_BUG_ON(!IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) && !is_shmem);
-	VM_BUG_ON(start & (HPAGE_PMD_NR - 1));
+	/* MADV_COLLAPSE ignores shmem huge config, so do not check shmem */
+	VM_WARN_ON_ONCE(!is_shmem && mapping_max_folio_order(mapping) < PMD_ORDER);
+	VM_WARN_ON_ONCE(start & (HPAGE_PMD_NR - 1));
 
 	result = alloc_charge_folio(&new_folio, mm, cc);
 	if (result != SCAN_SUCCEED)

mm/khugepaged.c static enum scan_result collapse_scan_file(struct mm_struct *mm, · line 2328

Quoted 7 lines
mm/khugepaged.c +4 -0
@@ -2321,6 +2322,13 @@ static enum scan_result collapse_scan_file(struct mm_struct *mm,
 	int node = NUMA_NO_NODE;
 	enum scan_result result = SCAN_SUCCEED;
 
+	/*
+	 * skip files without PMD-order folio support
+	 * do not check shmem, since MADV_COLLAPSE ignores shmem huge config
+	 */

How is the !collapse path handled? Through thp_vma_allowable_order() in collapse_scan_mm_slot()?

Quoted 1 line

Wouldn't it be better to have that check exactly there?

Right! Looks like patch #03[1] already does that, as David also pointed out there :)

With that in place, regular files should end up in file_thp_enabled(), which checks that mapping_max_folio_order() >= PMD_ORDER.

For khugepaged, collapse_scan_mm_slot() calls thp_vma_allowable_order() before entering the per-PMD scan loop, so ineligible regular file VMAs should already get filtered there.

madvise_collapse() also calls thp_vma_allowable_order() early, so it should get the same filtering before reaching collapse_scan_file().

So the extra check here looks redundant :)

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

Cheers,
Lance

reviewer
#9 lore raw

Re: [PATCH 7.2 v2 01/12] mm/khugepaged: remove READ_ONLY_THP_FOR_FS check

Quoted 44 lines · Lance Yang
Quoted 42 lines · David Hildenbrand (Arm)
Quoted 30 lines · Zi Yan

collapse_file() requires FSes supporting large folio with at least PMD_ORDER, so replace the READ_ONLY_THP_FOR_FS check with that. MADV_COLLAPSE ignores shmem huge config, so exclude the check for shmem.

While at it, replace VM_BUG_ON with VM_WARN_ON_ONCE.

In collapse_scan_file(), add FS eligibility check to avoid redundant scans.

---
 mm/khugepaged.c | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)
mm/khugepaged.c +3 -2
index b8452dbdb043..d2f0acd2dac2 100644
@@ -1892,8 +1892,9 @@ static enum scan_result collapse_file(struct mm_struct *mm, unsigned long addr,
 	int nr_none = 0;
 	bool is_shmem = shmem_file(file);
 
-	VM_BUG_ON(!IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) && !is_shmem);
-	VM_BUG_ON(start & (HPAGE_PMD_NR - 1));
+	/* MADV_COLLAPSE ignores shmem huge config, so do not check shmem */
+	VM_WARN_ON_ONCE(!is_shmem && mapping_max_folio_order(mapping) < PMD_ORDER);
+	VM_WARN_ON_ONCE(start & (HPAGE_PMD_NR - 1));
 
 	result = alloc_charge_folio(&new_folio, mm, cc);
 	if (result != SCAN_SUCCEED)

mm/khugepaged.c static enum scan_result collapse_scan_file(struct mm_struct *mm, · line 2328

Quoted 7 lines
mm/khugepaged.c +4 -0
@@ -2321,6 +2322,13 @@ static enum scan_result collapse_scan_file(struct mm_struct *mm,
 	int node = NUMA_NO_NODE;
 	enum scan_result result = SCAN_SUCCEED;
 
+	/*
+	 * skip files without PMD-order folio support
+	 * do not check shmem, since MADV_COLLAPSE ignores shmem huge config
+	 */

How is the !collapse path handled? Through thp_vma_allowable_order() in collapse_scan_mm_slot()?

Quoted 7 lines
Quoted 1 line

Wouldn't it be better to have that check exactly there?

Right! Looks like patch #03[1] already does that, as David also pointed out there :)

With that in place, regular files should end up in file_thp_enabled(), which checks that mapping_max_folio_order() >= PMD_ORDER.

Forgot to add:

thp_vma_allowable_order()

	-> file_thp_enabled()
	-> mapping_max_folio_order() check
Quoted 14 lines

For khugepaged, collapse_scan_mm_slot() calls thp_vma_allowable_order() before entering the per-PMD scan loop, so ineligible regular file VMAs should already get filtered there.

madvise_collapse() also calls thp_vma_allowable_order() early, so it should get the same filtering before reaching collapse_scan_file().

So the extra check here looks redundant :)

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

Cheers,
Lance

author reviewer
#10 lore raw

Re: [PATCH 7.2 v2 01/12] mm/khugepaged: remove READ_ONLY_THP_FOR_FS check

Quoted 50 lines · Lance Yang
Quoted 49 lines · Lance Yang
Quoted 42 lines · David Hildenbrand (Arm)
Quoted 30 lines · Zi Yan

collapse_file() requires FSes supporting large folio with at least PMD_ORDER, so replace the READ_ONLY_THP_FOR_FS check with that. MADV_COLLAPSE ignores shmem huge config, so exclude the check for shmem.

While at it, replace VM_BUG_ON with VM_WARN_ON_ONCE.

In collapse_scan_file(), add FS eligibility check to avoid redundant scans.

---
 mm/khugepaged.c | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)
mm/khugepaged.c +3 -2
index b8452dbdb043..d2f0acd2dac2 100644
@@ -1892,8 +1892,9 @@ static enum scan_result collapse_file(struct mm_struct *mm, unsigned long addr,
 	int nr_none = 0;
 	bool is_shmem = shmem_file(file);
 
-	VM_BUG_ON(!IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) && !is_shmem);
-	VM_BUG_ON(start & (HPAGE_PMD_NR - 1));
+	/* MADV_COLLAPSE ignores shmem huge config, so do not check shmem */
+	VM_WARN_ON_ONCE(!is_shmem && mapping_max_folio_order(mapping) < PMD_ORDER);
+	VM_WARN_ON_ONCE(start & (HPAGE_PMD_NR - 1));
 
 	result = alloc_charge_folio(&new_folio, mm, cc);
 	if (result != SCAN_SUCCEED)

mm/khugepaged.c static enum scan_result collapse_scan_file(struct mm_struct *mm, · line 2328

Quoted 7 lines
mm/khugepaged.c +4 -0
@@ -2321,6 +2322,13 @@ static enum scan_result collapse_scan_file(struct mm_struct *mm,
 	int node = NUMA_NO_NODE;
 	enum scan_result result = SCAN_SUCCEED;
 
+	/*
+	 * skip files without PMD-order folio support
+	 * do not check shmem, since MADV_COLLAPSE ignores shmem huge config
+	 */

How is the !collapse path handled? Through thp_vma_allowable_order() in collapse_scan_mm_slot()?

Quoted 1 line

Wouldn't it be better to have that check exactly there?

Right! Looks like patch #03[1] already does that, as David also pointed out there :)

Quoted 20 lines
Quoted 2 lines

With that in place, regular files should end up in file_thp_enabled(), which checks that mapping_max_folio_order() >= PMD_ORDER.

Forgot to add:

thp_vma_allowable_order()

	-> file_thp_enabled()
	-> mapping_max_folio_order() check
Quoted 11 lines

For khugepaged, collapse_scan_mm_slot() calls thp_vma_allowable_order() before entering the per-PMD scan loop, so ineligible regular file VMAs should already get filtered there.

madvise_collapse() also calls thp_vma_allowable_order() early, so it should get the same filtering before reaching collapse_scan_file().

So the extra check here looks redundant :)

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

Right. Will remove the extra check from collapse_scan_file().

Best Regards,
Yan, Zi

author reviewer
#11 lore raw

PATCH v2 2/12 mm/khugepaged: add folio dirty check after try_to_unmap_flush()

In reply to Zi Yan

This check ensures the correctness of collapse read-only THPs for FSes after READ_ONLY_THP_FOR_FS is enabled by default for all FSes supporting PMD THP pagecache.

READ_ONLY_THP_FOR_FS only supports read-only fd and uses mapping->nr_thps and inode->i_writecount to prevent any write to read-only to-be-collapsed folios. In upcoming commits, READ_ONLY_THP_FOR_FS will be removed and the aforementioned mechanism will go away too. To ensure khugepaged functions as expected after the changes, rollback if any folio is dirty after try_to_unmap_flush() to , since a dirty folio means this read-only folio got some writes via mmap can happen between try_to_unmap() and try_to_unmap_flush() via cached TLB entries and khugepaged does not support collapse writable pagecache folios.

---
 mm/khugepaged.c | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
mm/khugepaged.c +18 -0
index d2f0acd2dac2..ec609e53082e 100644
@@ -2121,6 +2121,24 @@ static enum scan_result collapse_file(struct mm_struct *mm, unsigned long addr,
 	 */
 	try_to_unmap_flush();
 
+	/*
+	 * At this point, all folios are locked, unmapped, and all cached
+	 * mappings in TLBs are flushed. No one else is able to write to these
+	 * folios, since
+	 * 1. writes via FS ops require folio locks (see write_begin_get_folio());
+	 * 2. writes via mmap require taking a fault and locking folio locks.
+	 *
+	 * khugepaged only works for read-only fd, make sure all folios are
+	 * clean, since writes via mmap can happen between try_to_unmap() and
+	 * try_to_unmap_flush() via cached TLB entries.
+	 */
+	list_for_each_entry(folio, &pagelist, lru) {
+		if (!is_shmem && (folio_test_dirty(folio))) {
+			result = SCAN_PAGE_DIRTY_OR_WRITEBACK;
+			goto rollback;
+		}
+	}
+
 	if (result == SCAN_SUCCEED && nr_none &&
 	    !shmem_charge(mapping->host, nr_none))
 		result = SCAN_FAIL;
Signature · 1 line
2.43.0
maintainer
#12 lore raw

Re: [PATCH 7.2 v2 02/12] mm/khugepaged: add folio dirty check after try_to_unmap_flush()

mm/khugepaged.c static enum scan_result collapse_file(struct mm_struct *mm, unsigned long addr, · line 2136

Quoted 1 line · Zi Yan
mm/khugepaged.c +1 -0
+		if (!is_shmem && (folio_test_dirty(folio))) {

seems like a spurious pair of brackets?

		if (!is_shmem && folio_test_dirty(folio)) {

should be fine

author reviewer
#13 lore raw

Re: [PATCH 7.2 v2 02/12] mm/khugepaged: add folio dirty check after try_to_unmap_flush()

Quoted 8 lines · Matthew Wilcox

mm/khugepaged.c static enum scan_result collapse_file(struct mm_struct *mm, unsigned long addr, · line 2136

Quoted 1 line · Zi Yan
mm/khugepaged.c +1 -0
+		if (!is_shmem && (folio_test_dirty(folio))) {

seems like a spurious pair of brackets?

		if (!is_shmem && folio_test_dirty(folio)) {

should be fine

Will remove them.

Best Regards,
Yan, Zi

#14 lore raw

Re: [PATCH 7.2 v2 02/12] mm/khugepaged: add folio dirty check after try_to_unmap_flush()

In reply to Zi Yan
Quoted 24 lines · Zi Yan

This check ensures the correctness of collapse read-only THPs for FSes after READ_ONLY_THP_FOR_FS is enabled by default for all FSes supporting PMD THP pagecache.

READ_ONLY_THP_FOR_FS only supports read-only fd and uses mapping->nr_thps and inode->i_writecount to prevent any write to read-only to-be-collapsed folios. In upcoming commits, READ_ONLY_THP_FOR_FS will be removed and the aforementioned mechanism will go away too. To ensure khugepaged functions as expected after the changes, rollback if any folio is dirty after try_to_unmap_flush() to , since a dirty folio means this read-only folio got some writes via mmap can happen between try_to_unmap() and try_to_unmap_flush() via cached TLB entries and khugepaged does not support collapse writable pagecache folios.

---
 mm/khugepaged.c | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
mm/khugepaged.c +0 -0
index d2f0acd2dac2..ec609e53082e 100644

mm/khugepaged.c static enum scan_result collapse_file(struct mm_struct *mm, unsigned long addr, · line 2130

Quoted 10 lines
mm/khugepaged.c +7 -0
@@ -2121,6 +2121,24 @@ static enum scan_result collapse_file(struct mm_struct *mm, unsigned long addr,
 	 */
 	try_to_unmap_flush();
 
+	/*
+	 * At this point, all folios are locked, unmapped, and all cached
+	 * mappings in TLBs are flushed. No one else is able to write to these
+	 * folios, since
+	 * 1. writes via FS ops require folio locks (see write_begin_get_folio());
+	 * 2. writes via mmap require taking a fault and locking folio locks.
+	 *

maybe simplify to "folios, since that would require taking the folio lock first."

mm/khugepaged.c static enum scan_result collapse_file(struct mm_struct *mm, unsigned long addr, · line 2133

Quoted 3 lines
mm/khugepaged.c +3 -0
+	 * khugepaged only works for read-only fd, make sure all folios are
+	 * clean, since writes via mmap can happen between try_to_unmap() and
+	 * try_to_unmap_flush() via cached TLB entries.

IIRC, after successful try_to_unmap() the PTE dirty bit would be synced to the folio. That's what you care about, not about any stale TLB entries.

The important part is that the

So can't we simply test for dirty folios after the refcount check (where we made sure the folio is no longer mapped)?

mm/khugepaged.c +8 -0
index b2ac28ddd480..920e16067134 100644
@@ -2089,6 +2089,14 @@ static enum scan_result collapse_file(struct mm_struct *mm, unsigned long addr,
                        goto out_unlock;
                }
 
+               /* ... */
+               if (!is_shmem && folio_test_dirty(folio)) {
+                       result = SCAN_PAGE_DIRTY_OR_WRITEBACK;
+                       xas_unlock_irq(&xas);
+                       folio_putback_lru(folio);
+                       goto out_unlock;
+               }
+
                /*
                 * Accumulate the folios that are being collapsed.
 

I guess we don't have to recheck folio_test_writeback() ?

Signature · 3 lines
Cheers,

David
author reviewer
#15 lore raw

Re: [PATCH 7.2 v2 02/12] mm/khugepaged: add folio dirty check after try_to_unmap_flush()

Quoted 28 lines · David Hildenbrand (Arm)
Quoted 27 lines · Zi Yan

This check ensures the correctness of collapse read-only THPs for FSes after READ_ONLY_THP_FOR_FS is enabled by default for all FSes supporting PMD THP pagecache.

READ_ONLY_THP_FOR_FS only supports read-only fd and uses mapping->nr_thps and inode->i_writecount to prevent any write to read-only to-be-collapsed folios. In upcoming commits, READ_ONLY_THP_FOR_FS will be removed and the aforementioned mechanism will go away too. To ensure khugepaged functions as expected after the changes, rollback if any folio is dirty after try_to_unmap_flush() to , since a dirty folio means this read-only folio got some writes via mmap can happen between try_to_unmap() and try_to_unmap_flush() via cached TLB entries and khugepaged does not support collapse writable pagecache folios.

---
 mm/khugepaged.c | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
mm/khugepaged.c +0 -0
index d2f0acd2dac2..ec609e53082e 100644
@@ -2121,6 +2121,24 @@ static enum scan_result collapse_file(struct mm_struct *mm, unsigned long addr,
 	 */
 	try_to_unmap_flush();
 
Quoted 9 lines

mm/khugepaged.c static enum scan_result collapse_file(struct mm_struct *mm, unsigned long addr, · line 2130

Quoted 7 lines
mm/khugepaged.c +7 -0
+	/*
+	 * At this point, all folios are locked, unmapped, and all cached
+	 * mappings in TLBs are flushed. No one else is able to write to these
+	 * folios, since
+	 * 1. writes via FS ops require folio locks (see write_begin_get_folio());
+	 * 2. writes via mmap require taking a fault and locking folio locks.
+	 *

maybe simplify to "folios, since that would require taking the folio lock first."

Sure.

Quoted 8 lines

mm/khugepaged.c static enum scan_result collapse_file(struct mm_struct *mm, unsigned long addr, · line 2133

Quoted 4 lines
mm/khugepaged.c +3 -0
+	 * khugepaged only works for read-only fd, make sure all folios are
+	 * clean, since writes via mmap can happen between try_to_unmap() and
+	 * try_to_unmap_flush() via cached TLB entries.

IIRC, after successful try_to_unmap() the PTE dirty bit would be synced to the folio. That's what you care about, not about any stale TLB entries.

Right. I missed the PTE dirty bit to folio dirtiness part.

Quoted 6 lines

The important part is that the

So can't we simply test for dirty folios after the refcount check (where we made sure the folio is no longer mapped)?

I think so.

Quoted 21 lines
mm/khugepaged.c +8 -0
index b2ac28ddd480..920e16067134 100644
@@ -2089,6 +2089,14 @@ static enum scan_result collapse_file(struct mm_struct *mm, unsigned long addr,
                        goto out_unlock;
                }
 
+               /* ... */
+               if (!is_shmem && folio_test_dirty(folio)) {
+                       result = SCAN_PAGE_DIRTY_OR_WRITEBACK;
+                       xas_unlock_irq(&xas);
+                       folio_putback_lru(folio);
+                       goto out_unlock;
+               }
+
                /*
                 * Accumulate the folios that are being collapsed.
 
Quoted 1 line

I guess we don't have to recheck folio_test_writeback() ?

Right, writeback needs to take folio lock and we are holding it, so others can only dirty the folio but are not able to initiate write backs.

Best Regards,
Yan, Zi

author reviewer
#16 lore raw

Re: [PATCH 7.2 v2 02/12] mm/khugepaged: add folio dirty check after try_to_unmap_flush()

Quoted 54 lines · Zi Yan
Quoted 28 lines · David Hildenbrand (Arm)
Quoted 27 lines · Zi Yan

This check ensures the correctness of collapse read-only THPs for FSes after READ_ONLY_THP_FOR_FS is enabled by default for all FSes supporting PMD THP pagecache.

READ_ONLY_THP_FOR_FS only supports read-only fd and uses mapping->nr_thps and inode->i_writecount to prevent any write to read-only to-be-collapsed folios. In upcoming commits, READ_ONLY_THP_FOR_FS will be removed and the aforementioned mechanism will go away too. To ensure khugepaged functions as expected after the changes, rollback if any folio is dirty after try_to_unmap_flush() to , since a dirty folio means this read-only folio got some writes via mmap can happen between try_to_unmap() and try_to_unmap_flush() via cached TLB entries and khugepaged does not support collapse writable pagecache folios.

---
 mm/khugepaged.c | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
mm/khugepaged.c +0 -0
index d2f0acd2dac2..ec609e53082e 100644
@@ -2121,6 +2121,24 @@ static enum scan_result collapse_file(struct mm_struct *mm, unsigned long addr,
 	 */
 	try_to_unmap_flush();
 
Quoted 9 lines

mm/khugepaged.c static enum scan_result collapse_file(struct mm_struct *mm, unsigned long addr, · line 2130

Quoted 7 lines
mm/khugepaged.c +7 -0
+	/*
+	 * At this point, all folios are locked, unmapped, and all cached
+	 * mappings in TLBs are flushed. No one else is able to write to these
+	 * folios, since
+	 * 1. writes via FS ops require folio locks (see write_begin_get_folio());
+	 * 2. writes via mmap require taking a fault and locking folio locks.
+	 *

maybe simplify to "folios, since that would require taking the folio lock first."

Sure.

Quoted 8 lines

mm/khugepaged.c static enum scan_result collapse_file(struct mm_struct *mm, unsigned long addr, · line 2133

Quoted 4 lines
mm/khugepaged.c +3 -0
+	 * khugepaged only works for read-only fd, make sure all folios are
+	 * clean, since writes via mmap can happen between try_to_unmap() and
+	 * try_to_unmap_flush() via cached TLB entries.

IIRC, after successful try_to_unmap() the PTE dirty bit would be synced to the folio. That's what you care about, not about any stale TLB entries.

Right. I missed the PTE dirty bit to folio dirtiness part.

Quoted 1 line
Quoted 7 lines
Quoted 5 lines

The important part is that the

So can't we simply test for dirty folios after the refcount check (where we made sure the folio is no longer mapped)?

I think so.

After more thoughts, this still works but the reasoning is more complicated.

After try_to_unmap(), PTE dirty bit is transferred to folio dirty flag if exists. The code bails out if the folio is dirty. A clean folio means the removed PTEs were clean, thus TLB entries caching these PTEs have dirty bit not set. Any write to the folio after try_to_unmap() causes a page table walk and a page fault due to invalid PTEs, and they cannot proceed since collapse_file() is holding the folio lock. As a result, we can skip marking folio dirty after the collapse.

If we allow a dirty folio after try_to_unmap(), we need to mark the folio dirty after the collapse like shmem. And a potential optimization is that we only mark the after-collapse folio dirty if any old folio is dirty after try_to_unmap().

Quoted 22 lines
Quoted 22 lines
mm/khugepaged.c +8 -0
index b2ac28ddd480..920e16067134 100644
@@ -2089,6 +2089,14 @@ static enum scan_result collapse_file(struct mm_struct *mm, unsigned long addr,
                        goto out_unlock;
                }
 
+               /* ... */
+               if (!is_shmem && folio_test_dirty(folio)) {
+                       result = SCAN_PAGE_DIRTY_OR_WRITEBACK;
+                       xas_unlock_irq(&xas);
+                       folio_putback_lru(folio);
+                       goto out_unlock;
+               }
+
                /*
                 * Accumulate the folios that are being collapsed.
 
Quoted 7 lines
Quoted 1 line

I guess we don't have to recheck folio_test_writeback() ?

Right, writeback needs to take folio lock and we are holding it, so others can only dirty the folio but are not able to initiate write backs.

Best Regards,
Yan, Zi

--
Best Regards,
Yan, Zi

#17 lore raw

Re: [PATCH 7.2 v2 02/12] mm/khugepaged: add folio dirty check after try_to_unmap_flush()

Quoted 24 lines · Zi Yan
Quoted 22 lines · Zi Yan
Quoted 2 lines · David Hildenbrand (Arm)

maybe simplify to "folios, since that would require taking the folio lock first."

Sure.

Quoted 5 lines

IIRC, after successful try_to_unmap() the PTE dirty bit would be synced to the folio. That's what you care about, not about any stale TLB entries.

Right. I missed the PTE dirty bit to folio dirtiness part.

Quoted 6 lines

The important part is that the

So can't we simply test for dirty folios after the refcount check (where we made sure the folio is no longer mapped)?

Quoted 7 lines
Quoted 1 line

I think so.

After more thoughts, this still works but the reasoning is more complicated.

After try_to_unmap(), PTE dirty bit is transferred to folio dirty flag if exists. The code bails out if the folio is dirty. A clean folio means the removed PTEs were clean, thus TLB entries caching these PTEs have dirty bit not set.

Right.

Quoted 3 lines

Any write to the folio after try_to_unmap() causes a page table walk and a page fault due to invalid PTEs, and they cannot proceed since collapse_file() is holding the folio lock.

Right.

Quoted 2 lines

As a result, we can skip marking folio dirty
after the collapse.

Exactly.

Quoted 4 lines

If we allow a dirty folio after try_to_unmap(), we need to mark the folio dirty after the collapse like shmem. And a potential optimization is that we only mark the after-collapse folio dirty if any old folio is dirty after try_to_unmap().

That was my thinking as well, but it would be something we'd try to handle separately.

Folios that are under writeback cannot be collapsed IIUC.

Signature · 3 lines
Cheers,

David
author reviewer
#18 lore raw

PATCH v2 3/12 mm/huge_memory: remove READ_ONLY_THP_FOR_FS from file_thp_enabled()

In reply to Zi Yan

Replace it with a check on the max folio order of the file's address space mapping, making sure PMD_ORDER is supported.

---
 mm/huge_memory.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
mm/huge_memory.c +3 -3
index 970e077019b7..a22bb2364bdc 100644
@@ -86,9 +86,6 @@ static inline bool file_thp_enabled(struct vm_area_struct *vma)
 {
 	struct inode *inode;
 
-	if (!IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS))
-		return false;
-
 	if (!vma->vm_file)
 		return false;
 
@@ -97,6 +94,9 @@ static inline bool file_thp_enabled(struct vm_area_struct *vma)
 	if (IS_ANON_FILE(inode))
 		return false;
 
+	if (mapping_max_folio_order(inode->i_mapping) < PMD_ORDER)
+		return false;
+
 	return !inode_is_open_for_write(inode) && S_ISREG(inode->i_mode);
 }
 
Signature · 1 line
2.43.0
#19 lore raw

Re: [PATCH 7.2 v2 03/12] mm/huge_memory: remove READ_ONLY_THP_FOR_FS from file_thp_enabled()

Quoted 23 lines · Zi Yan

Replace it with a check on the max folio order of the file's address space mapping, making sure PMD_ORDER is supported.

---
 mm/huge_memory.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
mm/huge_memory.c +0 -3
index 970e077019b7..a22bb2364bdc 100644
@@ -86,9 +86,6 @@ static inline bool file_thp_enabled(struct vm_area_struct *vma)
 {
 	struct inode *inode;
 
-	if (!IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS))
-		return false;
-
 	if (!vma->vm_file)
 		return false;
 

mm/huge_memory.c static inline bool file_thp_enabled(struct vm_area_struct *vma) · line 102

Quoted 9 lines
mm/huge_memory.c +3 -0
@@ -97,6 +94,9 @@ static inline bool file_thp_enabled(struct vm_area_struct *vma)
 	if (IS_ANON_FILE(inode))
 		return false;
 
+	if (mapping_max_folio_order(inode->i_mapping) < PMD_ORDER)
+		return false;
+
 	return !inode_is_open_for_write(inode) && S_ISREG(inode->i_mode);
 }
 

I assume this change itself should be sufficient and the SCAN_FAIL check in patch #1 is not required?

Signature · 3 lines
Cheers,

David
author reviewer
#20 lore raw

Re: [PATCH 7.2 v2 03/12] mm/huge_memory: remove READ_ONLY_THP_FOR_FS from file_thp_enabled()

Quoted 27 lines · David Hildenbrand (Arm)
Quoted 26 lines · Zi Yan

Replace it with a check on the max folio order of the file's address space mapping, making sure PMD_ORDER is supported.

---
 mm/huge_memory.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
mm/huge_memory.c +0 -3
index 970e077019b7..a22bb2364bdc 100644
@@ -86,9 +86,6 @@ static inline bool file_thp_enabled(struct vm_area_struct *vma)
 {
 	struct inode *inode;
 
-	if (!IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS))
-		return false;
-
 	if (!vma->vm_file)
 		return false;
 
@@ -97,6 +94,9 @@ static inline bool file_thp_enabled(struct vm_area_struct *vma)
 	if (IS_ANON_FILE(inode))
 		return false;
 
Quoted 10 lines

mm/huge_memory.c static inline bool file_thp_enabled(struct vm_area_struct *vma) · line 102

Quoted 6 lines
mm/huge_memory.c +3 -0
+	if (mapping_max_folio_order(inode->i_mapping) < PMD_ORDER)
+		return false;
+
 	return !inode_is_open_for_write(inode) && S_ISREG(inode->i_mode);
 }
 

I assume this change itself should be sufficient and the SCAN_FAIL check in patch #1 is not required?

Sure, I will remove that one.

Best Regards,
Yan, Zi

author reviewer
#22 lore raw

PATCH v2 4/12 mm: remove READ_ONLY_THP_FOR_FS Kconfig option

In reply to Zi Yan

After removing READ_ONLY_THP_FOR_FS check in file_thp_enabled(), khugepaged and MADV_COLLAPSE can run on FSes with PMD THP pagecache support even without READ_ONLY_THP_FOR_FS enabled. Remove the Kconfig first so that no one can use READ_ONLY_THP_FOR_FS as upcoming commits remove mapping->nr_thps, which its safe guard mechanism relies on.

---
 mm/Kconfig | 11 -----------
 1 file changed, 11 deletions(-)
mm/Kconfig +0 -11
index bd283958d675..408fc7b82233 100644
@@ -937,17 +937,6 @@ config THP_SWAP
 
 	  For selection by architectures with reasonable THP sizes.
 
-config READ_ONLY_THP_FOR_FS
-	bool "Read-only THP for filesystems (EXPERIMENTAL)"
-	depends on TRANSPARENT_HUGEPAGE
-
-	help
-	  Allow khugepaged to put read-only file-backed pages in THP.
-
-	  This is marked experimental because it is a new feature. Write
-	  support of file THPs will be developed in the next few release
-	  cycles.
-
 config NO_PAGE_MAPCOUNT
 	bool "No per-page mapcount (EXPERIMENTAL)"
 	help
Signature · 1 line
2.43.0
maintainer Acked-by on v2 4/12
#23 lore raw

Re: [PATCH 7.2 v2 04/12] mm: remove READ_ONLY_THP_FOR_FS Kconfig option

Quoted 9 lines · Zi Yan

After removing READ_ONLY_THP_FOR_FS check in file_thp_enabled(), khugepaged and MADV_COLLAPSE can run on FSes with PMD THP pagecache support even without READ_ONLY_THP_FOR_FS enabled. Remove the Kconfig first so that no one can use READ_ONLY_THP_FOR_FS as upcoming commits remove mapping->nr_thps, which its safe guard mechanism relies on.

---

Signature · 3 lines
Cheers,

David
reviewer Reviewed-by on v2 4/12
#24 lore raw

Re: [PATCH 7.2 v2 04/12] mm: remove READ_ONLY_THP_FOR_FS Kconfig option

In reply to Zi Yan
Quoted 9 lines · Zi Yan

After removing READ_ONLY_THP_FOR_FS check in file_thp_enabled(), khugepaged and MADV_COLLAPSE can run on FSes with PMD THP pagecache support even without READ_ONLY_THP_FOR_FS enabled. Remove the Kconfig first so that no one can use READ_ONLY_THP_FOR_FS as upcoming commits remove mapping->nr_thps, which its safe guard mechanism relies on.

---

LGTM.

author reviewer
#25 lore raw

PATCH v2 5/12 mm/khugepaged: remove READ_ONLY_THP_FOR_FS check in hugepage_pmd_enabled()

In reply to Zi Yan

After READ_ONLY_THP_FOR_FS Kconfig is removed, this check becomes dead code.

This changes hugepage_pmd_enabled() semantics. Previously, with READ_ONLY_THP_FOR_FS enabled, hugepage_pmd_enabled() returned true whenever /sys/kernel/mm/transparent_hugepage/enabled was set to "always" or "madvise".

After this change, hugepage_pmd_enabled() is governed only by the anon and shmem PMD THP controls. As a result, khugepaged collapse for file-backed folios no longer runs unconditionally under the top-level THP setting, and now depends on the anon/shmem PMD configuration.

---
 mm/khugepaged.c | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)
mm/khugepaged.c +2 -5
index ec609e53082e..79c985d7fa03 100644
@@ -409,15 +409,12 @@ static inline int collapse_test_exit_or_disable(struct mm_struct *mm)
 static bool hugepage_pmd_enabled(void)
 {
 	/*
-	 * We cover the anon, shmem and the file-backed case here; file-backed
-	 * hugepages, when configured in, are determined by the global control.
+	 * We cover the anon and shmem cases here.
 	 * Anon pmd-sized hugepages are determined by the pmd-size control.
 	 * Shmem pmd-sized hugepages are also determined by its pmd-size control,
 	 * except when the global shmem_huge is set to SHMEM_HUGE_DENY.
+	 * The file-backed case is determined by the anon and shmem cases.
 	 */
-	if (IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) &&
-	    hugepage_global_enabled())
-		return true;
 	if (test_bit(PMD_ORDER, &huge_anon_orders_always))
 		return true;
 	if (test_bit(PMD_ORDER, &huge_anon_orders_madvise))
Signature · 1 line
2.43.0
maintainer
#26 lore raw

Re: [PATCH 7.2 v2 05/12] mm/khugepaged: remove READ_ONLY_THP_FOR_FS check in hugepage_pmd_enabled()

Quoted 8 lines · Zi Yan

After READ_ONLY_THP_FOR_FS Kconfig is removed, this check becomes dead code.

This changes hugepage_pmd_enabled() semantics. Previously, with READ_ONLY_THP_FOR_FS enabled, hugepage_pmd_enabled() returned true whenever /sys/kernel/mm/transparent_hugepage/enabled was set to "always" or "madvise".

Quoted 4 lines

After this change, hugepage_pmd_enabled() is governed only by the anon and shmem PMD THP controls. As a result, khugepaged collapse for file-backed folios no longer runs unconditionally under the top-level THP setting, and now depends on the anon/shmem PMD configuration.

This seems like it'll turn off khugepaged too easily. I would have thought we'd want:

- if (IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) &&
- hugepage_global_enabled())
+ if (hugepage_global_enabled())
return true;

... or maybe this whole thing could be simplified?

author reviewer
#27 lore raw

Re: [PATCH 7.2 v2 05/12] mm/khugepaged: remove READ_ONLY_THP_FOR_FS check in hugepage_pmd_enabled()

Quoted 17 lines · Matthew Wilcox
Quoted 8 lines · Zi Yan

After READ_ONLY_THP_FOR_FS Kconfig is removed, this check becomes dead code.

This changes hugepage_pmd_enabled() semantics. Previously, with READ_ONLY_THP_FOR_FS enabled, hugepage_pmd_enabled() returned true whenever /sys/kernel/mm/transparent_hugepage/enabled was set to "always" or "madvise".

Quoted 4 lines

After this change, hugepage_pmd_enabled() is governed only by the anon and shmem PMD THP controls. As a result, khugepaged collapse for file-backed folios no longer runs unconditionally under the top-level THP setting, and now depends on the anon/shmem PMD configuration.

This seems like it'll turn off khugepaged too easily. I would have thought we'd want:

mm/khugepaged.c static inline int collapse_test_exit_or_disable(struct mm_struct *mm) · line 419

Quoted 4 lines
mm/khugepaged.c +1 -2
-	if (IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) &&
-	    hugepage_global_enabled())
+	if (hugepage_global_enabled())
 		return true;

I thought about this, but it means khugepaged is turned on regardless of anon and shmem configs. I tend to think the original code was a bug, since enabling CONFIG_READ_ONLY_THP_FOR_FS would enable khugepaged all the time.

Quoted 2 lines

... or maybe this whole thing could be simplified?

Alternatives could be:
1. to add a file-backed khhugepaged config, but another sysfs?
2. to replace hugepage_pmd_enabled() with hugepage_global_enabled() and let thp_vma_allowable_order() in collapse_scan_mm_slot() skip not qualified VMAs, but that would waste extra CPU cycles for scanning. Maybe not too much waste.

Best Regards,
Yan, Zi

#28 lore raw

Re: [PATCH 7.2 v2 05/12] mm/khugepaged: remove READ_ONLY_THP_FOR_FS check in hugepage_pmd_enabled()

Quoted 16 lines · Zi Yan
Quoted 14 lines · Matthew Wilcox
Quoted 12 lines · Zi Yan

After READ_ONLY_THP_FOR_FS Kconfig is removed, this check becomes dead code.

This changes hugepage_pmd_enabled() semantics. Previously, with READ_ONLY_THP_FOR_FS enabled, hugepage_pmd_enabled() returned true whenever /sys/kernel/mm/transparent_hugepage/enabled was set to "always" or "madvise".

After this change, hugepage_pmd_enabled() is governed only by the anon and shmem PMD THP controls. As a result, khugepaged collapse for file-backed folios no longer runs unconditionally under the top-level THP setting, and now depends on the anon/shmem PMD configuration.

Quoted 8 lines

Review

Quoted 7 lines

This seems like it'll turn off khugepaged too easily. I would have thought we'd want:

(quoted diff) +1 -2
-	if (IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) &&
-	    hugepage_global_enabled())
+	if (hugepage_global_enabled())
 		return true;

I assume such a change should come before patch #4, as it seems to affect the functionality that depended on CONFIG_READ_ONLY_THP_FOR_FS.

Quoted 4 lines

I thought about this, but it means khugepaged is turned on regardless of anon and shmem configs. I tend to think the original code was a bug, since enabling CONFIG_READ_ONLY_THP_FOR_FS would enable khugepaged all the time.

There might be some FS mapping to collapse? So that makes sense to some degree.

I really don't like the side-effects of "/sys/kernel/mm/transparent_hugepage/enabled". Like, enabling khugepaged+PMD for files.

Quoted 6 lines
Quoted 3 lines

... or maybe this whole thing could be simplified?

Alternatives could be:
1. to add a file-backed khhugepaged config, but another sysfs?

Maybe that would be the time to decouple file THP logic from hugepage_global_enabled()/hugepage_global_always().

In particular, as pagecache folio allocation doesn't really care about __thp_vma_allowable_orders() IIRC.

I'm thinking about something like the following:

mm/huge_memory.c +0 -9
index b2a6060b3c20..fb3a4fd84fe0 100644
@@ -184,15 +184,6 @@ unsigned long __thp_vma_allowable_orders(struct vm_area_struct *vma,
                                                   forced_collapse);
 
        if (!vma_is_anonymous(vma)) {
-               /*
-                * Enforce THP collapse requirements as necessary. Anonymous vmas
-                * were already handled in thp_vma_allowable_orders().
-                */
-               if (!forced_collapse &&
-                   (!hugepage_global_enabled() || (!(vm_flags & VM_HUGEPAGE) &&
-                                                   !hugepage_global_always())))
-                       return 0;
-
                /*
                 * Trust that ->huge_fault() handlers know what they are doing
                 * in fault path.

Then, we might indeed just want a khugepaged toggle whether to enable it at all in files. (or just a toggle to disable khugeapged entirely?)

Signature · 3 lines
Cheers,

David
author reviewer
#29 lore raw

Re: [PATCH 7.2 v2 05/12] mm/khugepaged: remove READ_ONLY_THP_FOR_FS check in hugepage_pmd_enabled()

Quoted 20 lines · David Hildenbrand (Arm)
Quoted 19 lines · Zi Yan
Quoted 17 lines · Matthew Wilcox
Quoted 8 lines · Zi Yan

After READ_ONLY_THP_FOR_FS Kconfig is removed, this check becomes dead code.

This changes hugepage_pmd_enabled() semantics. Previously, with READ_ONLY_THP_FOR_FS enabled, hugepage_pmd_enabled() returned true whenever /sys/kernel/mm/transparent_hugepage/enabled was set to "always" or "madvise".

Quoted 4 lines

After this change, hugepage_pmd_enabled() is governed only by the anon and shmem PMD THP controls. As a result, khugepaged collapse for file-backed folios no longer runs unconditionally under the top-level THP setting, and now depends on the anon/shmem PMD configuration.

This seems like it'll turn off khugepaged too easily. I would have thought we'd want:

Quoted 8 lines
Quoted 5 lines

Review

Quoted 4 lines
(quoted diff) +1 -2
-	if (IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) &&
-	    hugepage_global_enabled())
+	if (hugepage_global_enabled())
 		return true;

I assume such a change should come before patch #4, as it seems to affect the functionality that depended on CONFIG_READ_ONLY_THP_FOR_FS.

If the goal is to have a knob of khugepaged for all files, yes I will move the change before Patch 4.

Quoted 6 lines
Quoted 5 lines

I thought about this, but it means khugepaged is turned on regardless of anon and shmem configs. I tend to think the original code was a bug, since enabling CONFIG_READ_ONLY_THP_FOR_FS would enable khugepaged all the time.

Quoted 6 lines

There might be some FS mapping to collapse? So that makes sense to some degree.

I really don't like the side-effects of "/sys/kernel/mm/transparent_hugepage/enabled". Like, enabling khugepaged+PMD for files.

I am not a fan either, but I was not sure about another sysfs knob.

Quoted 24 lines
Quoted 6 lines
Quoted 3 lines

... or maybe this whole thing could be simplified?

Alternatives could be:
1. to add a file-backed khhugepaged config, but another sysfs?

Maybe that would be the time to decouple file THP logic from hugepage_global_enabled()/hugepage_global_always().

In particular, as pagecache folio allocation doesn't really care about __thp_vma_allowable_orders() IIRC.

I'm thinking about something like the following:

mm/huge_memory.c +0 -2
index b2a6060b3c20..fb3a4fd84fe0 100644
@@ -184,15 +184,6 @@ unsigned long __thp_vma_allowable_orders(struct vm_area_struct *vma,
                                                   forced_collapse);
 
        if (!vma_is_anonymous(vma)) {
-               /*
-                * Enforce THP collapse requirements as necessary. Anonymous vmas

mm/huge_memory.c unsigned long __thp_vma_allowable_orders(struct vm_area_struct *vma, · line 189

Quoted 10 lines
mm/huge_memory.c +0 -7
-                * were already handled in thp_vma_allowable_orders().
-                */
-               if (!forced_collapse &&
-                   (!hugepage_global_enabled() || (!(vm_flags & VM_HUGEPAGE) &&
-                                                   !hugepage_global_always())))
-                       return 0;
-
                /*
                 * Trust that ->huge_fault() handlers know what they are doing
                 * in fault path.

Looks reasonable.

Quoted 4 lines

Then, we might indeed just want a khugepaged toggle whether to enable it at all in files. (or just a toggle to disable khugeapged entirely?)

I think hugepage_global_enabled() should be enough to decide whether khugepaged should run or not.

Currently, we have thp_vma_allowable_orders() to filter each VMAs and I do not see a reason to use hugepage_pmd_enabled() to guard khugepaged daemon. I am going to just remove hugepage_pmd_enabled() and replace it with hugepage_global_enabled(). Let me know your thoughts.

BTW, this conflicts with Patch 12 from Nico’s khugepaged for mTHP patchset.

Best Regards,
Yan, Zi

#30 lore raw

Re: [PATCH 7.2 v2 05/12] mm/khugepaged: remove READ_ONLY_THP_FOR_FS check in hugepage_pmd_enabled()

Quoted 18 lines · Zi Yan
Quoted 6 lines · David Hildenbrand (Arm)
Quoted 2 lines · Zi Yan

I assume such a change should come before patch #4, as it seems to affect the functionality that depended on CONFIG_READ_ONLY_THP_FOR_FS.

If the goal is to have a knob of khugepaged for all files, yes I will move the change before Patch 4.

Quoted 6 lines
Quoted 5 lines

I thought about this, but it means khugepaged is turned on regardless of anon and shmem configs. I tend to think the original code was a bug, since enabling CONFIG_READ_ONLY_THP_FOR_FS would enable khugepaged all the time.

Quoted 9 lines
Quoted 6 lines

There might be some FS mapping to collapse? So that makes sense to some degree.

I really don't like the side-effects of "/sys/kernel/mm/transparent_hugepage/enabled". Like, enabling khugepaged+PMD for files.

I am not a fan either, but I was not sure about another sysfs knob.

Yeah, it would be better if we could avoid it. But the dependency on the global toggle as it is today is a bit weird.

Quoted 19 lines
Quoted 19 lines
Quoted 4 lines

Alternatives could be:
1. to add a file-backed khhugepaged config, but another sysfs?

Maybe that would be the time to decouple file THP logic from hugepage_global_enabled()/hugepage_global_always().

In particular, as pagecache folio allocation doesn't really care about __thp_vma_allowable_orders() IIRC.

I'm thinking about something like the following:

mm/huge_memory.c +0 -0
index b2a6060b3c20..fb3a4fd84fe0 100644
@@ -184,15 +184,6 @@ unsigned long __thp_vma_allowable_orders(struct vm_area_struct *vma,
                                                   forced_collapse);
 
Quoted 15 lines

mm/huge_memory.c unsigned long __thp_vma_allowable_orders(struct vm_area_struct *vma, · line 189

Quoted 13 lines
mm/huge_memory.c +0 -9
        if (!vma_is_anonymous(vma)) {
-               /*
-                * Enforce THP collapse requirements as necessary. Anonymous vmas
-                * were already handled in thp_vma_allowable_orders().
-                */
-               if (!forced_collapse &&
-                   (!hugepage_global_enabled() || (!(vm_flags & VM_HUGEPAGE) &&
-                                                   !hugepage_global_always())))
-                       return 0;
-
                /*
                 * Trust that ->huge_fault() handlers know what they are doing
                 * in fault path.

Looks reasonable.

I don't think there is other interaction with FS and the global toggle besides this and the one you are adjusting, right?

Quoted 8 lines
Quoted 5 lines

Then, we might indeed just want a khugepaged toggle whether to enable it at all in files. (or just a toggle to disable khugeapged entirely?)

I think hugepage_global_enabled() should be enough to decide whether khugepaged should run or not.

That would also be an option and would likely avoid other toggles.

So __thp_vma_allowable_orders() would allows THPs in any case for FS, but hugepage_global_enabled() would control whether khugepaged runs (for fs).

It gives less flexibility, but likely that's ok.

Quoted 5 lines

Currently, we have thp_vma_allowable_orders() to filter each VMAs and I do not see a reason to use hugepage_pmd_enabled() to guard khugepaged daemon. I am going to just remove hugepage_pmd_enabled() and replace it with hugepage_global_enabled(). Let me know your thoughts.

Can you send a quick draft of what you have in mind?

Quoted 2 lines

BTW, this conflicts with Patch 12 from Nico’s khugepaged for mTHP patchset.

Right. I guess it can be handled.

Signature · 3 lines
Cheers,

David
author reviewer
#31 lore raw

Re: [PATCH 7.2 v2 05/12] mm/khugepaged: remove READ_ONLY_THP_FOR_FS check in hugepage_pmd_enabled()

Quoted 88 lines · David Hildenbrand (Arm)
Quoted 18 lines · Zi Yan
Quoted 6 lines · David Hildenbrand (Arm)
Quoted 2 lines · Zi Yan

I assume such a change should come before patch #4, as it seems to affect the functionality that depended on CONFIG_READ_ONLY_THP_FOR_FS.

If the goal is to have a knob of khugepaged for all files, yes I will move the change before Patch 4.

Quoted 6 lines
Quoted 5 lines

I thought about this, but it means khugepaged is turned on regardless of anon and shmem configs. I tend to think the original code was a bug, since enabling CONFIG_READ_ONLY_THP_FOR_FS would enable khugepaged all the time.

Quoted 9 lines
Quoted 6 lines

There might be some FS mapping to collapse? So that makes sense to some degree.

I really don't like the side-effects of "/sys/kernel/mm/transparent_hugepage/enabled". Like, enabling khugepaged+PMD for files.

I am not a fan either, but I was not sure about another sysfs knob.

Yeah, it would be better if we could avoid it. But the dependency on the global toggle as it is today is a bit weird.

Quoted 19 lines
Quoted 19 lines
Quoted 4 lines

Alternatives could be:
1. to add a file-backed khhugepaged config, but another sysfs?

Maybe that would be the time to decouple file THP logic from hugepage_global_enabled()/hugepage_global_always().

In particular, as pagecache folio allocation doesn't really care about __thp_vma_allowable_orders() IIRC.

I'm thinking about something like the following:

mm/huge_memory.c +0 -0
index b2a6060b3c20..fb3a4fd84fe0 100644
@@ -184,15 +184,6 @@ unsigned long __thp_vma_allowable_orders(struct vm_area_struct *vma,
                                                   forced_collapse);
 
Quoted 15 lines

mm/huge_memory.c unsigned long __thp_vma_allowable_orders(struct vm_area_struct *vma, · line 189

Quoted 13 lines
mm/huge_memory.c +0 -9
        if (!vma_is_anonymous(vma)) {
-               /*
-                * Enforce THP collapse requirements as necessary. Anonymous vmas
-                * were already handled in thp_vma_allowable_orders().
-                */
-               if (!forced_collapse &&
-                   (!hugepage_global_enabled() || (!(vm_flags & VM_HUGEPAGE) &&
-                                                   !hugepage_global_always())))
-                       return 0;
-
                /*
                 * Trust that ->huge_fault() handlers know what they are doing
                 * in fault path.

Looks reasonable.

I don't think there is other interaction with FS and the global toggle besides this and the one you are adjusting, right?

Quoted 8 lines
Quoted 5 lines

Then, we might indeed just want a khugepaged toggle whether to enable it at all in files. (or just a toggle to disable khugeapged entirely?)

I think hugepage_global_enabled() should be enough to decide whether khugepaged should run or not.

That would also be an option and would likely avoid other toggles.

So __thp_vma_allowable_orders() would allows THPs in any case for FS, but hugepage_global_enabled() would control whether khugepaged runs (for fs).

It gives less flexibility, but likely that's ok.

Quoted 1 line
Quoted 6 lines
Quoted 4 lines

Currently, we have thp_vma_allowable_orders() to filter each VMAs and I do not see a reason to use hugepage_pmd_enabled() to guard khugepaged daemon. I am going to just remove hugepage_pmd_enabled() and replace it with hugepage_global_enabled(). Let me know your thoughts.

Can you send a quick draft of what you have in mind?

From ee9e1c18b41111db7248db7fb64693b91e32255d Mon Sep 17 00:00:00 2001
From: Zi Yan <[email protected]>
Date: Tue, 14 Apr 2026 14:17:31 -0400
Subject: [PATCH] mm/khugepaged: replace hugepage_pmd_enabled with
hugepage_global_enabled

thp_vma_allowable_orders() is used to guard khugepaged scanning logic in collapse_scan_mm_slot() based on enabled THP/mTHP orders by only allowing PMD_ORDER. hugepage_pmd_enabled() is a duplication of it for khugepaged start/stop control. Simplify the control by checking hugepage_global_enabled() instead and let thp_vma_allowable_orders() filter khugepaged scanning.

---
 mm/khugepaged.c | 36 ++++++------------------------------
 1 file changed, 6 insertions(+), 30 deletions(-)
mm/khugepaged.c +6 -30
index b8452dbdb043..459c486a5a75 100644
@@ -406,30 +406,6 @@ static inline int collapse_test_exit_or_disable(struct mm_struct *mm)
 		mm_flags_test(MMF_DISABLE_THP_COMPLETELY, mm);
 }
 
-static bool hugepage_pmd_enabled(void)
-{
-	/*
-	 * We cover the anon, shmem and the file-backed case here; file-backed
-	 * hugepages, when configured in, are determined by the global control.
-	 * Anon pmd-sized hugepages are determined by the pmd-size control.
-	 * Shmem pmd-sized hugepages are also determined by its pmd-size control,
-	 * except when the global shmem_huge is set to SHMEM_HUGE_DENY.
-	 */
-	if (IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) &&
-	    hugepage_global_enabled())
-		return true;
-	if (test_bit(PMD_ORDER, &huge_anon_orders_always))
-		return true;
-	if (test_bit(PMD_ORDER, &huge_anon_orders_madvise))
-		return true;
-	if (test_bit(PMD_ORDER, &huge_anon_orders_inherit) &&
-	    hugepage_global_enabled())
-		return true;
-	if (IS_ENABLED(CONFIG_SHMEM) && shmem_hpage_pmd_enabled())
-		return true;
-	return false;
-}
-
 void __khugepaged_enter(struct mm_struct *mm)
 {
 	struct mm_slot *slot;
@@ -463,7 +439,7 @@ void khugepaged_enter_vma(struct vm_area_struct *vma,
 			  vm_flags_t vm_flags)
 {
 	if (!mm_flags_test(MMF_VM_HUGEPAGE, vma->vm_mm) &&
-	    hugepage_pmd_enabled()) {
+	    hugepage_global_enabled()) {
 		if (thp_vma_allowable_order(vma, vm_flags, TVA_KHUGEPAGED, PMD_ORDER))
 			__khugepaged_enter(vma->vm_mm);
 	}
@@ -2599,7 +2575,7 @@ static void collapse_scan_mm_slot(unsigned int progress_max,
 
 static int khugepaged_has_work(void)
 {
-	return !list_empty(&khugepaged_scan.mm_head) && hugepage_pmd_enabled();
+	return !list_empty(&khugepaged_scan.mm_head) && hugepage_global_enabled();
 }
 
 static int khugepaged_wait_event(void)
@@ -2672,7 +2648,7 @@ static void khugepaged_wait_work(void)
 		return;
 	}
 
-	if (hugepage_pmd_enabled())
+	if (hugepage_global_enabled())
 		wait_event_freezable(khugepaged_wait, khugepaged_wait_event());
 }
 
@@ -2703,7 +2679,7 @@ void set_recommended_min_free_kbytes(void)
 	int nr_zones = 0;
 	unsigned long recommended_min;
 
-	if (!hugepage_pmd_enabled()) {
+	if (!hugepage_global_enabled()) {
 		calculate_min_free_kbytes();
 		goto update_wmarks;
 	}
@@ -2753,7 +2729,7 @@ int start_stop_khugepaged(void)
 	int err = 0;
 
 	mutex_lock(&khugepaged_mutex);
-	if (hugepage_pmd_enabled()) {
+	if (hugepage_global_enabled()) {
 		if (!khugepaged_thread)
 			khugepaged_thread = kthread_run(khugepaged, NULL,
 							"khugepaged");
@@ -2779,7 +2755,7 @@ int start_stop_khugepaged(void)
 void khugepaged_min_free_kbytes_update(void)
 {
 	mutex_lock(&khugepaged_mutex);
-	if (hugepage_pmd_enabled() && khugepaged_thread)
+	if (hugepage_global_enabled() && khugepaged_thread)
 		set_recommended_min_free_kbytes();
 	mutex_unlock(&khugepaged_mutex);
 }
Signature · 1 line
2.43.0
Quoted 10 lines
Quoted 3 lines

BTW, this conflicts with Patch 12 from Nico’s khugepaged for mTHP patchset.

Right. I guess it can be handled.

Signature · 3 lines
Cheers,

David

Best Regards,
Yan, Zi

reviewer
#32 lore raw

Re: [PATCH 7.2 v2 05/12] mm/khugepaged: remove READ_ONLY_THP_FOR_FS check in hugepage_pmd_enabled()

Quoted 74 lines · Zi Yan
Quoted 72 lines · David Hildenbrand (Arm)
Quoted 18 lines · Zi Yan
Quoted 6 lines · David Hildenbrand (Arm)
Quoted 2 lines · Zi Yan

I assume such a change should come before patch #4, as it seems to affect the functionality that depended on CONFIG_READ_ONLY_THP_FOR_FS.

If the goal is to have a knob of khugepaged for all files, yes I will move the change before Patch 4.

Quoted 6 lines
Quoted 5 lines

I thought about this, but it means khugepaged is turned on regardless of anon and shmem configs. I tend to think the original code was a bug, since enabling CONFIG_READ_ONLY_THP_FOR_FS would enable khugepaged all the time.

Quoted 9 lines
Quoted 6 lines

There might be some FS mapping to collapse? So that makes sense to some degree.

I really don't like the side-effects of "/sys/kernel/mm/transparent_hugepage/enabled". Like, enabling khugepaged+PMD for files.

I am not a fan either, but I was not sure about another sysfs knob.

Yeah, it would be better if we could avoid it. But the dependency on the global toggle as it is today is a bit weird.

Quoted 19 lines
Quoted 19 lines
Quoted 4 lines

Alternatives could be:
1. to add a file-backed khhugepaged config, but another sysfs?

Maybe that would be the time to decouple file THP logic from hugepage_global_enabled()/hugepage_global_always().

In particular, as pagecache folio allocation doesn't really care about __thp_vma_allowable_orders() IIRC.

I'm thinking about something like the following:

mm/huge_memory.c +0 -0
index b2a6060b3c20..fb3a4fd84fe0 100644
@@ -184,15 +184,6 @@ unsigned long __thp_vma_allowable_orders(struct vm_area_struct *vma,
                                                    forced_collapse);
 
Quoted 15 lines

mm/huge_memory.c unsigned long __thp_vma_allowable_orders(struct vm_area_struct *vma, · line 189

Quoted 13 lines
mm/huge_memory.c +0 -9
         if (!vma_is_anonymous(vma)) {
-               /*
-                * Enforce THP collapse requirements as necessary. Anonymous vmas
-                * were already handled in thp_vma_allowable_orders().
-                */
-               if (!forced_collapse &&
-                   (!hugepage_global_enabled() || (!(vm_flags & VM_HUGEPAGE) &&
-                                                   !hugepage_global_always())))
-                       return 0;
-
                 /*
                  * Trust that ->huge_fault() handlers know what they are doing
                  * in fault path.

Looks reasonable.

I don't think there is other interaction with FS and the global toggle besides this and the one you are adjusting, right?

Quoted 2 lines
Quoted 2 lines
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
Quoted 3 lines

Then, we might indeed just want a khugepaged toggle whether to enable it at all in files. (or just a toggle to disable khugeapged entirely?)

I think hugepage_global_enabled() should be enough to decide whether khugepaged should run or not.

I'm afraid not. Please also consider the per-size mTHP interfaces. It's possible that hugepage_global_enabled() returns false, but hugepages-2048kB/enabled is set to "always", which would still allow khugepaged to collapse folios.

Quoted 22 lines
Quoted 9 lines

That would also be an option and would likely avoid other toggles.

So __thp_vma_allowable_orders() would allows THPs in any case for FS, but hugepage_global_enabled() would control whether khugepaged runs (for fs).

It gives less flexibility, but likely that's ok.

Quoted 1 line
Quoted 6 lines
Quoted 4 lines

Currently, we have thp_vma_allowable_orders() to filter each VMAs and I do not see a reason to use hugepage_pmd_enabled() to guard khugepaged daemon. I am going to just remove hugepage_pmd_enabled() and replace it with hugepage_global_enabled(). Let me know your thoughts.

Can you send a quick draft of what you have in mind?

From ee9e1c18b41111db7248db7fb64693b91e32255d Mon Sep 17 00:00:00 2001
From: Zi Yan <[email protected]>
Date: Tue, 14 Apr 2026 14:17:31 -0400
Subject: [PATCH] mm/khugepaged: replace hugepage_pmd_enabled with
hugepage_global_enabled

Quoted 6 lines

thp_vma_allowable_orders() is used to guard khugepaged scanning logic in collapse_scan_mm_slot() based on enabled THP/mTHP orders by only allowing PMD_ORDER. hugepage_pmd_enabled() is a duplication of it for khugepaged start/stop control. Simplify the control by checking hugepage_global_enabled() instead and let thp_vma_allowable_orders() filter khugepaged scanning.

It appears this would prevent shmem collapse, since hugepage_global_enabled() doesn’t consider the THP settings for shmem/tmpfs (only for anonymous memory).

Quoted 94 lines
---
  mm/khugepaged.c | 36 ++++++------------------------------
  1 file changed, 6 insertions(+), 30 deletions(-)
mm/khugepaged.c +6 -30
index b8452dbdb043..459c486a5a75 100644
@@ -406,30 +406,6 @@ static inline int collapse_test_exit_or_disable(struct mm_struct *mm)
  		mm_flags_test(MMF_DISABLE_THP_COMPLETELY, mm);
  }
 
-static bool hugepage_pmd_enabled(void)
-{
-	/*
-	 * We cover the anon, shmem and the file-backed case here; file-backed
-	 * hugepages, when configured in, are determined by the global control.
-	 * Anon pmd-sized hugepages are determined by the pmd-size control.
-	 * Shmem pmd-sized hugepages are also determined by its pmd-size control,
-	 * except when the global shmem_huge is set to SHMEM_HUGE_DENY.
-	 */
-	if (IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) &&
-	    hugepage_global_enabled())
-		return true;
-	if (test_bit(PMD_ORDER, &huge_anon_orders_always))
-		return true;
-	if (test_bit(PMD_ORDER, &huge_anon_orders_madvise))
-		return true;
-	if (test_bit(PMD_ORDER, &huge_anon_orders_inherit) &&
-	    hugepage_global_enabled())
-		return true;
-	if (IS_ENABLED(CONFIG_SHMEM) && shmem_hpage_pmd_enabled())
-		return true;
-	return false;
-}
-
  void __khugepaged_enter(struct mm_struct *mm)
  {
  	struct mm_slot *slot;
@@ -463,7 +439,7 @@ void khugepaged_enter_vma(struct vm_area_struct *vma,
  			  vm_flags_t vm_flags)
  {
  	if (!mm_flags_test(MMF_VM_HUGEPAGE, vma->vm_mm) &&
-	    hugepage_pmd_enabled()) {
+	    hugepage_global_enabled()) {
  		if (thp_vma_allowable_order(vma, vm_flags, TVA_KHUGEPAGED, PMD_ORDER))
  			__khugepaged_enter(vma->vm_mm);
  	}
@@ -2599,7 +2575,7 @@ static void collapse_scan_mm_slot(unsigned int progress_max,
 
  static int khugepaged_has_work(void)
  {
-	return !list_empty(&khugepaged_scan.mm_head) && hugepage_pmd_enabled();
+	return !list_empty(&khugepaged_scan.mm_head) && hugepage_global_enabled();
  }
 
  static int khugepaged_wait_event(void)
@@ -2672,7 +2648,7 @@ static void khugepaged_wait_work(void)
  		return;
  	}
 
-	if (hugepage_pmd_enabled())
+	if (hugepage_global_enabled())
  		wait_event_freezable(khugepaged_wait, khugepaged_wait_event());
  }
 
@@ -2703,7 +2679,7 @@ void set_recommended_min_free_kbytes(void)
  	int nr_zones = 0;
  	unsigned long recommended_min;
 
-	if (!hugepage_pmd_enabled()) {
+	if (!hugepage_global_enabled()) {
  		calculate_min_free_kbytes();
  		goto update_wmarks;
  	}
@@ -2753,7 +2729,7 @@ int start_stop_khugepaged(void)
  	int err = 0;
 
  	mutex_lock(&khugepaged_mutex);
-	if (hugepage_pmd_enabled()) {
+	if (hugepage_global_enabled()) {
  		if (!khugepaged_thread)
  			khugepaged_thread = kthread_run(khugepaged, NULL,
  							"khugepaged");
@@ -2779,7 +2755,7 @@ int start_stop_khugepaged(void)
  void khugepaged_min_free_kbytes_update(void)
  {
  	mutex_lock(&khugepaged_mutex);
-	if (hugepage_pmd_enabled() && khugepaged_thread)
+	if (hugepage_global_enabled() && khugepaged_thread)
  		set_recommended_min_free_kbytes();
  	mutex_unlock(&khugepaged_mutex);
  }
#33 lore raw

Re: [PATCH 7.2 v2 05/12] mm/khugepaged: remove READ_ONLY_THP_FOR_FS check in hugepage_pmd_enabled()

Quoted 10 lines · Baolin Wang
Quoted 7 lines · Zi Yan
Quoted 5 lines · David Hildenbrand (Arm)

Yeah, it would be better if we could avoid it. But the dependency on the global toggle as it is today is a bit weird.

Quoted 8 lines
Quoted 3 lines
Quoted 3 lines

I don't think there is other interaction with FS and the global toggle besides this and the one you are adjusting, right?

I'm afraid not. Please also consider the per-size mTHP interfaces. It's possible that hugepage_global_enabled() returns false, but hugepages-2048kB/enabled is set to "always", which would still allow khugepaged to collapse folios.

The question is really which semantics we want.

Right now, there is no way to disable khugepaged for anon pages, to just get them during page faults.

And we are now talking about the same problem for FS: to only get them during page faults (like we did so far without CONFIG_READ_ONLY_THP_FOR_FS).

Signature · 3 lines
Cheers,

David
reviewer
#34 lore raw

Re: [PATCH 7.2 v2 05/12] mm/khugepaged: remove READ_ONLY_THP_FOR_FS check in hugepage_pmd_enabled()

Quoted 11 lines · David Hildenbrand (Arm)
Quoted 10 lines · Baolin Wang
Quoted 7 lines · Zi Yan
Quoted 5 lines · David Hildenbrand (Arm)

Yeah, it would be better if we could avoid it. But the dependency on the global toggle as it is today is a bit weird.

Quoted 8 lines
Quoted 8 lines
Quoted 3 lines
Quoted 3 lines

I don't think there is other interaction with FS and the global toggle besides this and the one you are adjusting, right?

I'm afraid not. Please also consider the per-size mTHP interfaces. It's possible that hugepage_global_enabled() returns false, but hugepages-2048kB/enabled is set to "always", which would still allow khugepaged to collapse folios.

My comments are in reply to Zi’s comment:

"I think hugepage_global_enabled() should be enough to decide whether khugepaged should run or not. "

I’m concerned that only relying on hugepage_global_enabled() to decide whether khugepaged should run would cause a regression for anonymous and shmem memory collapse, as it ignores per-size mTHP configuration.

Quoted 4 lines

The question is really which semantics we want.

Right now, there is no way to disable khugepaged for anon pages, to just get them during page faults.

Right.

Quoted 2 lines

And we are now talking about the same problem for FS: to only get them during page faults (like we did so far without CONFIG_READ_ONLY_THP_FOR_FS).

OK. I’m fine with using hugepage_global_enabled() to determine whether khugepaged scans file folios.

My concern is that for anonymous memory and shmem, the per-size mTHP settings should be considered.

author reviewer
#35 lore raw

Re: [PATCH 7.2 v2 05/12] mm/khugepaged: remove READ_ONLY_THP_FOR_FS check in hugepage_pmd_enabled()

Quoted 32 lines · Baolin Wang
Quoted 11 lines · David Hildenbrand (Arm)
Quoted 10 lines · Baolin Wang
Quoted 7 lines · Zi Yan
Quoted 5 lines · David Hildenbrand (Arm)

Yeah, it would be better if we could avoid it. But the dependency on the global toggle as it is today is a bit weird.

Quoted 8 lines
Quoted 8 lines
Quoted 3 lines
Quoted 3 lines

I don't think there is other interaction with FS and the global toggle besides this and the one you are adjusting, right?

I'm afraid not. Please also consider the per-size mTHP interfaces. It's possible that hugepage_global_enabled() returns false, but hugepages-2048kB/enabled is set to "always", which would still allow khugepaged to collapse folios.

My comments are in reply to Zi’s comment:

"I think hugepage_global_enabled() should be enough to decide whether khugepaged should run or not. "

I’m concerned that only relying on hugepage_global_enabled() to decide whether khugepaged should run would cause a regression for anonymous and shmem memory collapse, as it ignores per-size mTHP configuration.

Quoted 4 lines

The question is really which semantics we want.

Right now, there is no way to disable khugepaged for anon pages, to just get them during page faults.

Quoted 8 lines

Right.

Quoted 2 lines

And we are now talking about the same problem for FS: to only get them during page faults (like we did so far without CONFIG_READ_ONLY_THP_FOR_FS).

OK. I’m fine with using hugepage_global_enabled() to determine whether khugepaged scans file folios.

My concern is that for anonymous memory and shmem, the per-size mTHP settings should be considered.

OK, I misunderstood the meaning of hugepage_global_enabled(), since per-size mTHP settings could also enable khugepaged if PMD_SIZE is set.

I will take willy’s original suggestion and make khugepaged on if the global setting is enabled. The below is the new version of this patch. I moved anon pmd huge page code to a separate anon_hpage_pmd_enabled() like shmem_hpage_pmd_enabled() and cleaned up the comment. Let me know your thoughts.

Thanks.

From 92b92f2b2ab41c70b41dd304ce648786ee6a1603 Mon Sep 17 00:00:00 2001
From: Zi Yan <[email protected]>
Date: Wed, 15 Apr 2026 13:52:50 -0400
Subject: [PATCH] mm/khugepaged: remove READ_ONLY_THP_FOR_FS check in
hugepage_pmd_enabled()

Remove READ_ONLY_THP_FOR_FS and khugepaged for file-backed pmd-sized hugepages are enabled by the global transparent hugepage control. khugepaged can still be enabled by per-size control for anon and shmem when the global control is off.

---
 mm/khugepaged.c | 26 +++++++++++++++-----------
 1 file changed, 15 insertions(+), 11 deletions(-)
mm/khugepaged.c +15 -11
index b8452dbdb043..586d27ce896e 100644
@@ -406,18 +406,8 @@ static inline int collapse_test_exit_or_disable(struct mm_struct *mm)
 		mm_flags_test(MMF_DISABLE_THP_COMPLETELY, mm);
 }
 
-static bool hugepage_pmd_enabled(void)
+static inline bool anon_hpage_pmd_enabled()
 {
-	/*
-	 * We cover the anon, shmem and the file-backed case here; file-backed
-	 * hugepages, when configured in, are determined by the global control.
-	 * Anon pmd-sized hugepages are determined by the pmd-size control.
-	 * Shmem pmd-sized hugepages are also determined by its pmd-size control,
-	 * except when the global shmem_huge is set to SHMEM_HUGE_DENY.
-	 */
-	if (IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) &&
-	    hugepage_global_enabled())
-		return true;
 	if (test_bit(PMD_ORDER, &huge_anon_orders_always))
 		return true;
 	if (test_bit(PMD_ORDER, &huge_anon_orders_madvise))
@@ -425,6 +415,20 @@ static bool hugepage_pmd_enabled(void)
 	if (test_bit(PMD_ORDER, &huge_anon_orders_inherit) &&
 	    hugepage_global_enabled())
 		return true;
+	return false;
+}
+
+static bool hugepage_pmd_enabled(void)
+{
+	/*
+	 * Anon, shmem and file-backed pmd-sized hugepages are all determined by
+	 * the global control. If the global control is off, anon and shmem
+	 * pmd-sized hugepages are also determined by its per-size control.
+	 */
+	if (hugepage_global_enabled())
+		return true;
+	if (anon_hpage_pmd_enabled())
+		return true;
 	if (IS_ENABLED(CONFIG_SHMEM) && shmem_hpage_pmd_enabled())
 		return true;
 	return false;
Signature · 6 lines
2.43.0



Best Regards,
Yan, Zi
reviewer
#36 lore raw

Re: [PATCH 7.2 v2 05/12] mm/khugepaged: remove READ_ONLY_THP_FOR_FS check in hugepage_pmd_enabled()

Quoted 104 lines · Zi Yan
Quoted 32 lines · Baolin Wang
Quoted 11 lines · David Hildenbrand (Arm)
Quoted 10 lines · Baolin Wang
Quoted 7 lines · Zi Yan
Quoted 5 lines · David Hildenbrand (Arm)

Yeah, it would be better if we could avoid it. But the dependency on the global toggle as it is today is a bit weird.

Quoted 8 lines
Quoted 8 lines
Quoted 3 lines
Quoted 3 lines

I don't think there is other interaction with FS and the global toggle besides this and the one you are adjusting, right?

I'm afraid not. Please also consider the per-size mTHP interfaces. It's possible that hugepage_global_enabled() returns false, but hugepages-2048kB/enabled is set to "always", which would still allow khugepaged to collapse folios.

My comments are in reply to Zi’s comment:

"I think hugepage_global_enabled() should be enough to decide whether khugepaged should run or not."

I’m concerned that only relying on hugepage_global_enabled() to decide whether khugepaged should run would cause a regression for anonymous and shmem memory collapse, as it ignores per-size mTHP configuration.

Quoted 4 lines

The question is really which semantics we want.

Right now, there is no way to disable khugepaged for anon pages, to just get them during page faults.

Quoted 8 lines

Right.

Quoted 2 lines

And we are now talking about the same problem for FS: to only get them during page faults (like we did so far without CONFIG_READ_ONLY_THP_FOR_FS).

OK. I’m fine with using hugepage_global_enabled() to determine whether khugepaged scans file folios.

My concern is that for anonymous memory and shmem, the per-size mTHP settings should be considered.

OK, I misunderstood the meaning of hugepage_global_enabled(), since per-size mTHP settings could also enable khugepaged if PMD_SIZE is set.

I will take willy’s original suggestion and make khugepaged on if the global setting is enabled. The below is the new version of this patch. I moved anon pmd huge page code to a separate anon_hpage_pmd_enabled() like shmem_hpage_pmd_enabled() and cleaned up the comment. Let me know your thoughts.

Thanks.

From 92b92f2b2ab41c70b41dd304ce648786ee6a1603 Mon Sep 17 00:00:00 2001
From: Zi Yan <[email protected]>
Date: Wed, 15 Apr 2026 13:52:50 -0400
Subject: [PATCH] mm/khugepaged: remove READ_ONLY_THP_FOR_FS check in
hugepage_pmd_enabled()

Remove READ_ONLY_THP_FOR_FS and khugepaged for file-backed pmd-sized hugepages are enabled by the global transparent hugepage control. khugepaged can still be enabled by per-size control for anon and shmem when the global control is off.

---
  mm/khugepaged.c | 26 +++++++++++++++-----------
  1 file changed, 15 insertions(+), 11 deletions(-)
mm/khugepaged.c +8 -11
index b8452dbdb043..586d27ce896e 100644
@@ -406,18 +406,8 @@ static inline int collapse_test_exit_or_disable(struct mm_struct *mm)
  		mm_flags_test(MMF_DISABLE_THP_COMPLETELY, mm);
  }
 
-static bool hugepage_pmd_enabled(void)
+static inline bool anon_hpage_pmd_enabled()
  {
-	/*
-	 * We cover the anon, shmem and the file-backed case here; file-backed
-	 * hugepages, when configured in, are determined by the global control.
-	 * Anon pmd-sized hugepages are determined by the pmd-size control.
-	 * Shmem pmd-sized hugepages are also determined by its pmd-size control,
-	 * except when the global shmem_huge is set to SHMEM_HUGE_DENY.
-	 */
-	if (IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) &&
-	    hugepage_global_enabled())
-		return true;
  	if (test_bit(PMD_ORDER, &huge_anon_orders_always))
  		return true;
  	if (test_bit(PMD_ORDER, &huge_anon_orders_madvise))
@@ -425,6 +415,20 @@ static bool hugepage_pmd_enabled(void)
  	if (test_bit(PMD_ORDER, &huge_anon_orders_inherit) &&
  	    hugepage_global_enabled())
  		return true;
+	return false;
+}
+
+static bool hugepage_pmd_enabled(void)
+{
+	/*
+	 * Anon, shmem and file-backed pmd-sized hugepages are all determined by

mm/khugepaged.c static bool hugepage_pmd_enabled(void) · line 434

Quoted 10 lines
mm/khugepaged.c +7 -0
+	 * the global control. If the global control is off, anon and shmem
+	 * pmd-sized hugepages are also determined by its per-size control.
+	 */
+	if (hugepage_global_enabled())
+		return true;
+	if (anon_hpage_pmd_enabled())
+		return true;
  	if (IS_ENABLED(CONFIG_SHMEM) && shmem_hpage_pmd_enabled())
  		return true;
  	return false;

Thanks. Looks reasonable to me. Let’s also see what David thinks.

#37 lore raw

Re: [PATCH 7.2 v2 05/12] mm/khugepaged: remove READ_ONLY_THP_FOR_FS check in hugepage_pmd_enabled()

In reply to Zi Yan
Quoted 75 lines · Zi Yan
Quoted 13 lines · Baolin Wang

On 4/15/26 4:00 PM, David Hildenbrand (Arm) wrote:

My comments are in reply to Zi’s comment:

"I think hugepage_global_enabled() should be enough to decide whether khugepaged should run or not. "

I’m concerned that only relying on hugepage_global_enabled() to decide whether khugepaged should run would cause a regression for anonymous and shmem memory collapse, as it ignores per-size mTHP configuration.

Quoted 4 lines

The question is really which semantics we want.

Right now, there is no way to disable khugepaged for anon pages, to just get them during page faults.

Quoted 8 lines

Right.

Quoted 2 lines

And we are now talking about the same problem for FS: to only get them during page faults (like we did so far without CONFIG_READ_ONLY_THP_FOR_FS).

OK. I’m fine with using hugepage_global_enabled() to determine whether khugepaged scans file folios.

My concern is that for anonymous memory and shmem, the per-size mTHP settings should be considered.

OK, I misunderstood the meaning of hugepage_global_enabled(), since per-size mTHP settings could also enable khugepaged if PMD_SIZE is set.

I will take willy’s original suggestion and make khugepaged on if the global setting is enabled. The below is the new version of this patch. I moved anon pmd huge page code to a separate anon_hpage_pmd_enabled() like shmem_hpage_pmd_enabled() and cleaned up the comment. Let me know your thoughts.

Thanks.

From 92b92f2b2ab41c70b41dd304ce648786ee6a1603 Mon Sep 17 00:00:00 2001
From: Zi Yan <[email protected]>
Date: Wed, 15 Apr 2026 13:52:50 -0400
Subject: [PATCH] mm/khugepaged: remove READ_ONLY_THP_FOR_FS check in
hugepage_pmd_enabled()

Remove READ_ONLY_THP_FOR_FS and khugepaged for file-backed pmd-sized hugepages are enabled by the global transparent hugepage control. khugepaged can still be enabled by per-size control for anon and shmem when the global control is off.

---
 mm/khugepaged.c | 26 +++++++++++++++-----------
 1 file changed, 15 insertions(+), 11 deletions(-)
mm/khugepaged.c +1 -11
index b8452dbdb043..586d27ce896e 100644
@@ -406,18 +406,8 @@ static inline int collapse_test_exit_or_disable(struct mm_struct *mm)
 		mm_flags_test(MMF_DISABLE_THP_COMPLETELY, mm);
 }
 
-static bool hugepage_pmd_enabled(void)
+static inline bool anon_hpage_pmd_enabled()
 {
-	/*
-	 * We cover the anon, shmem and the file-backed case here; file-backed
-	 * hugepages, when configured in, are determined by the global control.
-	 * Anon pmd-sized hugepages are determined by the pmd-size control.
-	 * Shmem pmd-sized hugepages are also determined by its pmd-size control,
-	 * except when the global shmem_huge is set to SHMEM_HUGE_DENY.
-	 */
-	if (IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) &&
-	    hugepage_global_enabled())
-		return true;
 	if (test_bit(PMD_ORDER, &huge_anon_orders_always))
 		return true;
 	if (test_bit(PMD_ORDER, &huge_anon_orders_madvise))

mm/khugepaged.c static bool hugepage_pmd_enabled(void) · line 420

Quoted 6 lines
mm/khugepaged.c +3 -0
@@ -425,6 +415,20 @@ static bool hugepage_pmd_enabled(void)
 	if (test_bit(PMD_ORDER, &huge_anon_orders_inherit) &&
 	    hugepage_global_enabled())
 		return true;
+	return false;
+}
+

Works for me.

mm/khugepaged.c static bool hugepage_pmd_enabled(void) · line 432

Quoted 12 lines
mm/khugepaged.c +11 -0
+static bool hugepage_pmd_enabled(void)
+{
+	/*
+	 * Anon, shmem and file-backed pmd-sized hugepages are all determined by
+	 * the global control. If the global control is off, anon and shmem
+	 * pmd-sized hugepages are also determined by its per-size control.
+	 */
+	if (hugepage_global_enabled())
+		return true;
+	if (anon_hpage_pmd_enabled())
+		return true;
 	if (IS_ENABLED(CONFIG_SHMEM) && shmem_hpage_pmd_enabled())

BTW, can we please provide a stub for shmem_hpage_pmd_enabled() in shmem_fs.h such that we can remove the IS_ENABLED here?

Signature · 3 lines
Cheers,

David
author reviewer
#38 lore raw

Re: [PATCH 7.2 v2 05/12] mm/khugepaged: remove READ_ONLY_THP_FOR_FS check in hugepage_pmd_enabled()

Quoted 85 lines · David Hildenbrand (Arm)
Quoted 75 lines · Zi Yan
Quoted 13 lines · Baolin Wang

On 4/15/26 4:00 PM, David Hildenbrand (Arm) wrote:

My comments are in reply to Zi’s comment:

"I think hugepage_global_enabled() should be enough to decide whether khugepaged should run or not. "

I’m concerned that only relying on hugepage_global_enabled() to decide whether khugepaged should run would cause a regression for anonymous and shmem memory collapse, as it ignores per-size mTHP configuration.

Quoted 4 lines

The question is really which semantics we want.

Right now, there is no way to disable khugepaged for anon pages, to just get them during page faults.

Quoted 8 lines

Right.

Quoted 2 lines

And we are now talking about the same problem for FS: to only get them during page faults (like we did so far without CONFIG_READ_ONLY_THP_FOR_FS).

OK. I’m fine with using hugepage_global_enabled() to determine whether khugepaged scans file folios.

My concern is that for anonymous memory and shmem, the per-size mTHP settings should be considered.

OK, I misunderstood the meaning of hugepage_global_enabled(), since per-size mTHP settings could also enable khugepaged if PMD_SIZE is set.

I will take willy’s original suggestion and make khugepaged on if the global setting is enabled. The below is the new version of this patch. I moved anon pmd huge page code to a separate anon_hpage_pmd_enabled() like shmem_hpage_pmd_enabled() and cleaned up the comment. Let me know your thoughts.

Thanks.

From 92b92f2b2ab41c70b41dd304ce648786ee6a1603 Mon Sep 17 00:00:00 2001
From: Zi Yan <[email protected]>
Date: Wed, 15 Apr 2026 13:52:50 -0400
Subject: [PATCH] mm/khugepaged: remove READ_ONLY_THP_FOR_FS check in
hugepage_pmd_enabled()

Remove READ_ONLY_THP_FOR_FS and khugepaged for file-backed pmd-sized hugepages are enabled by the global transparent hugepage control. khugepaged can still be enabled by per-size control for anon and shmem when the global control is off.

---
 mm/khugepaged.c | 26 +++++++++++++++-----------
 1 file changed, 15 insertions(+), 11 deletions(-)
mm/khugepaged.c +1 -11
index b8452dbdb043..586d27ce896e 100644
@@ -406,18 +406,8 @@ static inline int collapse_test_exit_or_disable(struct mm_struct *mm)
 		mm_flags_test(MMF_DISABLE_THP_COMPLETELY, mm);
 }
 
-static bool hugepage_pmd_enabled(void)
+static inline bool anon_hpage_pmd_enabled()
 {
-	/*
-	 * We cover the anon, shmem and the file-backed case here; file-backed
-	 * hugepages, when configured in, are determined by the global control.
-	 * Anon pmd-sized hugepages are determined by the pmd-size control.
-	 * Shmem pmd-sized hugepages are also determined by its pmd-size control,
-	 * except when the global shmem_huge is set to SHMEM_HUGE_DENY.
-	 */
-	if (IS_ENABLED(CONFIG_READ_ONLY_THP_FOR_FS) &&
-	    hugepage_global_enabled())
-		return true;
 	if (test_bit(PMD_ORDER, &huge_anon_orders_always))
 		return true;
 	if (test_bit(PMD_ORDER, &huge_anon_orders_madvise))

mm/khugepaged.c static bool hugepage_pmd_enabled(void) · line 420

Quoted 6 lines
mm/khugepaged.c +3 -0
@@ -425,6 +415,20 @@ static bool hugepage_pmd_enabled(void)
 	if (test_bit(PMD_ORDER, &huge_anon_orders_inherit) &&
 	    hugepage_global_enabled())
 		return true;
+	return false;
+}
+

Works for me.

Quoted 16 lines

mm/khugepaged.c static bool hugepage_pmd_enabled(void) · line 432

Quoted 12 lines
mm/khugepaged.c +11 -0
+static bool hugepage_pmd_enabled(void)
+{
+	/*
+	 * Anon, shmem and file-backed pmd-sized hugepages are all determined by
+	 * the global control. If the global control is off, anon and shmem
+	 * pmd-sized hugepages are also determined by its per-size control.
+	 */
+	if (hugepage_global_enabled())
+		return true;
+	if (anon_hpage_pmd_enabled())
+		return true;
 	if (IS_ENABLED(CONFIG_SHMEM) && shmem_hpage_pmd_enabled())

BTW, can we please provide a stub for shmem_hpage_pmd_enabled() in shmem_fs.h such that we can remove the IS_ENABLED here?

Sure.

Best Regards,
Yan, Zi

author reviewer
#39 lore raw

PATCH v2 6/12 mm: fs: remove filemap_nr_thps*() functions and their users

In reply to Zi Yan

They are used by READ_ONLY_THP_FOR_FS to handle writes to FSes without large folio support, so that read-only THPs created in these FSes are not seen by the FSes when the underlying fd becomes writable. Now read-only PMD THPs only appear in a FS with large folio support and the supported orders include PMD_ORDRE.

READ_ONLY_THP_FOR_FS was using mapping->nr_thps, inode->i_writecount, and smp_mb() to prevent writes to a read-only THP and collapsing writable folios into a THP. In collapse_file(), mapping->nr_thps is increased, then smp_mb(), and if inode->i_writecount > 0, collapse is stopped, while do_dentry_open() first increases inode->i_writecount, then a full memory fence, and if mapping->nr_thps > 0, all read-only THPs are truncated.

Now this mechanism can be removed along with READ_ONLY_THP_FOR_FS code, since a dirty folio check has been added after try_to_unmap() and try_to_unmap_flush() in collapse_file() to make sure no writable folio can be collapsed.

---
 fs/open.c               | 27 ---------------------------
 include/linux/pagemap.h | 29 -----------------------------
 mm/filemap.c            |  1 -
 mm/huge_memory.c        |  1 -
 mm/khugepaged.c         | 28 ----------------------------
 5 files changed, 86 deletions(-)
fs/open.c +0 -27
index 91f1139591ab..cef382d9d8b8 100644
@@ -970,33 +970,6 @@ static int do_dentry_open(struct file *f,
 	if ((f->f_flags & O_DIRECT) && !(f->f_mode & FMODE_CAN_ODIRECT))
 		return -EINVAL;
 
-	/*
-	 * XXX: Huge page cache doesn't support writing yet. Drop all page
-	 * cache for this file before processing writes.
-	 */
-	if (f->f_mode & FMODE_WRITE) {
-		/*
-		 * Depends on full fence from get_write_access() to synchronize
-		 * against collapse_file() regarding i_writecount and nr_thps
-		 * updates. Ensures subsequent insertion of THPs into the page
-		 * cache will fail.
-		 */
-		if (filemap_nr_thps(inode->i_mapping)) {
-			struct address_space *mapping = inode->i_mapping;
-
-			filemap_invalidate_lock(inode->i_mapping);
-			/*
-			 * unmap_mapping_range just need to be called once
-			 * here, because the private pages is not need to be
-			 * unmapped mapping (e.g. data segment of dynamic
-			 * shared libraries here).
-			 */
-			unmap_mapping_range(mapping, 0, 0, 0);
-			truncate_inode_pages(mapping, 0);
-			filemap_invalidate_unlock(inode->i_mapping);
-		}
-	}
-
 	return 0;
 
 cleanup_all:
include/linux/pagemap.h +0 -29
index ec442af3f886..dad3f8846cdc 100644
@@ -530,35 +530,6 @@ static inline size_t mapping_max_folio_size(const struct address_space *mapping)
 	return PAGE_SIZE << mapping_max_folio_order(mapping);
 }
 
-static inline int filemap_nr_thps(const struct address_space *mapping)
-{
-#ifdef CONFIG_READ_ONLY_THP_FOR_FS
-	return atomic_read(&mapping->nr_thps);
-#else
-	return 0;
-#endif
-}
-
-static inline void filemap_nr_thps_inc(struct address_space *mapping)
-{
-#ifdef CONFIG_READ_ONLY_THP_FOR_FS
-	if (!mapping_large_folio_support(mapping))
-		atomic_inc(&mapping->nr_thps);
-#else
-	WARN_ON_ONCE(mapping_large_folio_support(mapping) == 0);
-#endif
-}
-
-static inline void filemap_nr_thps_dec(struct address_space *mapping)
-{
-#ifdef CONFIG_READ_ONLY_THP_FOR_FS
-	if (!mapping_large_folio_support(mapping))
-		atomic_dec(&mapping->nr_thps);
-#else
-	WARN_ON_ONCE(mapping_large_folio_support(mapping) == 0);
-#endif
-}
-
 struct address_space *folio_mapping(const struct folio *folio);
 
 /**
mm/filemap.c +0 -1
index c568d9058ff8..e7da925ae310 100644
@@ -189,7 +189,6 @@ static void filemap_unaccount_folio(struct address_space *mapping,
 			lruvec_stat_mod_folio(folio, NR_SHMEM_THPS, -nr);
 	} else if (folio_test_pmd_mappable(folio)) {
 		lruvec_stat_mod_folio(folio, NR_FILE_THPS, -nr);
-		filemap_nr_thps_dec(mapping);
 	}
 	if (test_bit(AS_KERNEL_FILE, &folio->mapping->flags))
 		mod_node_page_state(folio_pgdat(folio),
mm/huge_memory.c +0 -1
index a22bb2364bdc..5c9ee900ed90 100644
@@ -3926,7 +3926,6 @@ static int __folio_freeze_and_split_unmapped(struct folio *folio, unsigned int n
 				} else {
 					lruvec_stat_mod_folio(folio,
 							NR_FILE_THPS, -nr);
-					filemap_nr_thps_dec(mapping);
 				}
 			}
 		}
mm/khugepaged.c +0 -28
index 79c985d7fa03..afd52e4c7ccd 100644
@@ -2092,21 +2092,6 @@ static enum scan_result collapse_file(struct mm_struct *mm, unsigned long addr,
 		goto xa_unlocked;
 	}
 
-	if (!is_shmem) {
-		filemap_nr_thps_inc(mapping);
-		/*
-		 * Paired with the fence in do_dentry_open() -> get_write_access()
-		 * to ensure i_writecount is up to date and the update to nr_thps
-		 * is visible. Ensures the page cache will be truncated if the
-		 * file is opened writable.
-		 */
-		smp_mb();
-		if (inode_is_open_for_write(mapping->host)) {
-			result = SCAN_FAIL;
-			filemap_nr_thps_dec(mapping);
-		}
-	}
-
 xa_locked:
 	xas_unlock_irq(&xas);
 xa_unlocked:
@@ -2302,19 +2287,6 @@ static enum scan_result collapse_file(struct mm_struct *mm, unsigned long addr,
 		folio_putback_lru(folio);
 		folio_put(folio);
 	}
-	/*
-	 * Undo the updates of filemap_nr_thps_inc for non-SHMEM
-	 * file only. This undo is not needed unless failure is
-	 * due to SCAN_COPY_MC.
-	 */
-	if (!is_shmem && result == SCAN_COPY_MC) {
-		filemap_nr_thps_dec(mapping);
-		/*
-		 * Paired with the fence in do_dentry_open() -> get_write_access()
-		 * to ensure the update to nr_thps is visible.
-		 */
-		smp_mb();
-	}
 
 	new_folio->mapping = NULL;
 
Signature · 1 line
2.43.0
maintainer Reviewed-by on v2 6/12
#40 lore raw

Re: [PATCH 7.2 v2 06/12] mm: fs: remove filemap_nr_thps*() functions and their users

Quoted 18 lines · Zi Yan

They are used by READ_ONLY_THP_FOR_FS to handle writes to FSes without large folio support, so that read-only THPs created in these FSes are not seen by the FSes when the underlying fd becomes writable. Now read-only PMD THPs only appear in a FS with large folio support and the supported orders include PMD_ORDRE.

READ_ONLY_THP_FOR_FS was using mapping->nr_thps, inode->i_writecount, and smp_mb() to prevent writes to a read-only THP and collapsing writable folios into a THP. In collapse_file(), mapping->nr_thps is increased, then smp_mb(), and if inode->i_writecount > 0, collapse is stopped, while do_dentry_open() first increases inode->i_writecount, then a full memory fence, and if mapping->nr_thps > 0, all read-only THPs are truncated.

Now this mechanism can be removed along with READ_ONLY_THP_FOR_FS code, since a dirty folio check has been added after try_to_unmap() and try_to_unmap_flush() in collapse_file() to make sure no writable folio can be collapsed.

Quoted 8 lines
---
 fs/open.c               | 27 ---------------------------
 include/linux/pagemap.h | 29 -----------------------------
 mm/filemap.c            |  1 -
 mm/huge_memory.c        |  1 -
 mm/khugepaged.c         | 28 ----------------------------
 5 files changed, 86 deletions(-)

This is great.

maintainer Acked-by on v2 6/12
#41 lore raw

Re: [PATCH 7.2 v2 06/12] mm: fs: remove filemap_nr_thps*() functions and their users

In reply to Zi Yan
Quoted 13 lines · Zi Yan

They are used by READ_ONLY_THP_FOR_FS to handle writes to FSes without large folio support, so that read-only THPs created in these FSes are not seen by the FSes when the underlying fd becomes writable. Now read-only PMD THPs only appear in a FS with large folio support and the supported orders include PMD_ORDRE.

READ_ONLY_THP_FOR_FS was using mapping->nr_thps, inode->i_writecount, and smp_mb() to prevent writes to a read-only THP and collapsing writable folios into a THP. In collapse_file(), mapping->nr_thps is increased, then smp_mb(), and if inode->i_writecount > 0, collapse is stopped, while do_dentry_open() first increases inode->i_writecount, then a full memory fence, and if mapping->nr_thps > 0, all read-only THPs are truncated.

Quoted 6 lines

Now this mechanism can be removed along with READ_ONLY_THP_FOR_FS code, since a dirty folio check has been added after try_to_unmap() and try_to_unmap_flush() in collapse_file() to make sure no writable folio can be collapsed.

Signature · 3 lines
Cheers,

David
reviewer Reviewed-by on v2 6/12
#42 lore raw

Re: [PATCH 7.2 v2 06/12] mm: fs: remove filemap_nr_thps*() functions and their users

In reply to Zi Yan
Quoted 13 lines · Zi Yan

They are used by READ_ONLY_THP_FOR_FS to handle writes to FSes without large folio support, so that read-only THPs created in these FSes are not seen by the FSes when the underlying fd becomes writable. Now read-only PMD THPs only appear in a FS with large folio support and the supported orders include PMD_ORDRE.

READ_ONLY_THP_FOR_FS was using mapping->nr_thps, inode->i_writecount, and smp_mb() to prevent writes to a read-only THP and collapsing writable folios into a THP. In collapse_file(), mapping->nr_thps is increased, then smp_mb(), and if inode->i_writecount > 0, collapse is stopped, while do_dentry_open() first increases inode->i_writecount, then a full memory fence, and if mapping->nr_thps > 0, all read-only THPs are truncated.

Quoted 7 lines

Now this mechanism can be removed along with READ_ONLY_THP_FOR_FS code, since a dirty folio check has been added after try_to_unmap() and try_to_unmap_flush() in collapse_file() to make sure no writable folio can be collapsed.

---

Thanks. LGTM.

author reviewer
#43 lore raw

PATCH v2 7/12 fs: remove nr_thps from struct address_space

In reply to Zi Yan

filemap_nr_thps*() are removed, the related field, address_space->nr_thps, is no longer needed. Remove it.

---
 fs/inode.c         | 3 ---
 include/linux/fs.h | 5 -----
 2 files changed, 8 deletions(-)
fs/inode.c +0 -3
index cc12b68e021b..16ab0a345419 100644
@@ -280,9 +280,6 @@ int inode_init_always_gfp(struct super_block *sb, struct inode *inode, gfp_t gfp
 	mapping->flags = 0;
 	mapping->wb_err = 0;
 	atomic_set(&mapping->i_mmap_writable, 0);
-#ifdef CONFIG_READ_ONLY_THP_FOR_FS
-	atomic_set(&mapping->nr_thps, 0);
-#endif
 	mapping_set_gfp_mask(mapping, GFP_HIGHUSER_MOVABLE);
 	mapping->i_private_data = NULL;
 	mapping->writeback_index = 0;
include/linux/fs.h +0 -5
index 0bdccfa70b44..35875696fb4c 100644
@@ -455,7 +455,6 @@ extern const struct address_space_operations empty_aops;
  *   memory mappings.
  * @gfp_mask: Memory allocation flags to use for allocating pages.
  * @i_mmap_writable: Number of VM_SHARED, VM_MAYWRITE mappings.
- * @nr_thps: Number of THPs in the pagecache (non-shmem only).
  * @i_mmap: Tree of private and shared mappings.
  * @i_mmap_rwsem: Protects @i_mmap and @i_mmap_writable.
  * @nrpages: Number of page entries, protected by the i_pages lock.
@@ -473,10 +472,6 @@ struct address_space {
 	struct rw_semaphore	invalidate_lock;
 	gfp_t			gfp_mask;
 	atomic_t		i_mmap_writable;
-#ifdef CONFIG_READ_ONLY_THP_FOR_FS
-	/* number of thp, only for non-shmem files */
-	atomic_t		nr_thps;
-#endif
 	struct rb_root_cached	i_mmap;
 	unsigned long		nrpages;
 	pgoff_t			writeback_index;
Signature · 1 line
2.43.0
maintainer Reviewed-by on v2 7/12
#44 lore raw

Re: [PATCH 7.2 v2 07/12] fs: remove nr_thps from struct address_space

Quoted 2 lines · Zi Yan

filemap_nr_thps*() are removed, the related field, address_space->nr_thps, is no longer needed. Remove it.

... this shrinks struct address_space by 8 bytes on 64-bit systems which may increase the number of inodes we can cache.

Quoted 4 lines
reviewer Reviewed-by on v2 7/12
#45 lore raw

Re: [PATCH 7.2 v2 07/12] fs: remove nr_thps from struct address_space

In reply to Zi Yan
Quoted 8 lines · Zi Yan

filemap_nr_thps*() are removed, the related field, address_space->nr_thps, is no longer needed. Remove it.

---

LGTM.

author reviewer
#46 lore raw

PATCH v2 8/12 mm/huge_memory: remove folio split check for READ_ONLY_THP_FOR_FS

In reply to Zi Yan

Without READ_ONLY_THP_FOR_FS, large file-backed folios cannot be created by a FS without large folio support. The check is no longer needed.

---
 mm/huge_memory.c | 30 +++---------------------------
 1 file changed, 3 insertions(+), 27 deletions(-)
mm/huge_memory.c +3 -27
index 5c9ee900ed90..4de38c6c6d06 100644
@@ -3821,33 +3821,9 @@ int folio_check_splittable(struct folio *folio, unsigned int new_order,
 	if (!folio->mapping && !folio_test_anon(folio))
 		return -EBUSY;
 
-	if (folio_test_anon(folio)) {
-		/* order-1 is not supported for anonymous THP. */
-		if (new_order == 1)
-			return -EINVAL;
-	} 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.
-			 */
-			return -EINVAL;
-		}
-	}
+	/* order-1 is not supported for anonymous THP. */
+	if (folio_test_anon(folio) && new_order == 1)
+		return -EINVAL;
 
 	/*
 	 * swapcache folio could only be split to order 0
Signature · 1 line
2.43.0
maintainer
#47 lore raw

Re: [PATCH 7.2 v2 08/12] mm/huge_memory: remove folio split check for READ_ONLY_THP_FOR_FS

mm/huge_memory.c int folio_check_splittable(struct folio *folio, unsigned int new_order, · line 3824

Quoted 1 line · Zi Yan
mm/huge_memory.c +1 -0
+	/* order-1 is not supported for anonymous THP. */

It's also not supported for file folios, right? Or do we just skip adding order-1 file folios to the deferred split list? Either way, we need to correct _something_, whether it's the code or the comment.

Quoted 2 lines
mm/huge_memory.c +2 -0
+	if (folio_test_anon(folio) && new_order == 1)
+		return -EINVAL;
author reviewer
#48 lore raw

Re: [PATCH 7.2 v2 08/12] mm/huge_memory: remove folio split check for READ_ONLY_THP_FOR_FS

Quoted 5 lines · Matthew Wilcox

mm/huge_memory.c int folio_check_splittable(struct folio *folio, unsigned int new_order, · line 3824

Quoted 1 line · Zi Yan
mm/huge_memory.c +1 -0
+	/* order-1 is not supported for anonymous THP. */

It's also not supported for file folios, right? Or do we just skip adding order-1 file folios to the deferred split list? Either way,

order <= 1 folios are not added to deferred split list. See deferred_split_folio().

IIUC, we have order-1 file folios but not order-1 anon folios.

Quoted 4 lines

we need to correct _something_, whether it's the code or the comment.

mm/huge_memory.c int folio_check_splittable(struct folio *folio, unsigned int new_order, · line 3826

Quoted 2 lines
mm/huge_memory.c +2 -0
+	if (folio_test_anon(folio) && new_order == 1)
+		return -EINVAL;

Best Regards,
Yan, Zi

maintainer Acked-by
#49 lore raw

Re: [PATCH 7.2 v2 08/12] mm/huge_memory: remove folio split check for READ_ONLY_THP_FOR_FS

Quoted 8 lines · Zi Yan
Quoted 5 lines · Matthew Wilcox

mm/huge_memory.c int folio_check_splittable(struct folio *folio, unsigned int new_order, · line 3824

Quoted 1 line · Zi Yan
mm/huge_memory.c +1 -0
+	/* order-1 is not supported for anonymous THP. */

It's also not supported for file folios, right? Or do we just skip adding order-1 file folios to the deferred split list? Either way,

Quoted 4 lines

order <= 1 folios are not added to deferred split list. See deferred_split_folio().

IIUC, we have order-1 file folios but not order-1 anon folios.

And only anon folios are ever added to the deferred split list.

Signature · 3 lines
Cheers,

David
reviewer Reviewed-by on v2 8/12
#50 lore raw

Re: [PATCH 7.2 v2 08/12] mm/huge_memory: remove folio split check for READ_ONLY_THP_FOR_FS

In reply to Zi Yan
Quoted 7 lines · Zi Yan

Without READ_ONLY_THP_FOR_FS, large file-backed folios cannot be created by a FS without large folio support. The check is no longer needed.

---

LGTM.

author reviewer
#51 lore raw

PATCH v2 9/12 mm/truncate: use folio_split() in truncate_inode_partial_folio()

In reply to Zi Yan

After READ_ONLY_THP_FOR_FS is removed, FS either supports large folio or not. folio_split() can be used on a FS with large folio support without worrying about getting a THP on a FS without large folio support.

When READ_ONLY_THP_FOR_FS was present, a PMD large pagecache folio can appear in a FS without large folio support after khugepaged or madvise(MADV_COLLAPSE) creates it. During truncate_inode_partial_folio(), such a PMD large pagecache folio is split and if the FS does not support large folio, it needs to be split to order-0 ones and could not be split non uniformly to ones with various orders. try_folio_split_to_order() was added to handle this situation by checking folio_check_splittable(..., SPLIT_TYPE_NON_UNIFORM) to detect if the large folio is created due to READ_ONLY_THP_FOR_FS and the FS does not support large folio. Now READ_ONLY_THP_FOR_FS is removed, all large pagecache folios are created with FSes supporting large folio, this function is no longer needed and all large pagecache folios can be split non uniformly.

---
 include/linux/huge_mm.h | 25 ++-----------------------
 mm/truncate.c           |  8 ++++----
 2 files changed, 6 insertions(+), 27 deletions(-)
include/linux/huge_mm.h +2 -23
index 2949e5acff35..164d6edf1b65 100644
@@ -389,27 +389,6 @@ static inline int split_huge_page_to_order(struct page *page, unsigned int new_o
 	return split_huge_page_to_list_to_order(page, NULL, new_order);
 }
 
-/**
- * try_folio_split_to_order() - try to split a @folio at @page to @new_order
- * using non uniform split.
- * @folio: folio to be split
- * @page: split to @new_order at the given page
- * @new_order: the target split order
- *
- * Try to split a @folio at @page using non uniform split to @new_order, if
- * non uniform split is not supported, fall back to uniform split. After-split
- * folios are put back to LRU list. Use min_order_for_split() to get the lower
- * bound of @new_order.
- *
- * Return: 0 - split is successful, otherwise split failed.
- */
-static inline int try_folio_split_to_order(struct folio *folio,
-		struct page *page, unsigned int new_order)
-{
-	if (folio_check_splittable(folio, new_order, SPLIT_TYPE_NON_UNIFORM))
-		return split_huge_page_to_order(&folio->page, new_order);
-	return folio_split(folio, new_order, page, NULL);
-}
 static inline int split_huge_page(struct page *page)
 {
 	return split_huge_page_to_list_to_order(page, NULL, 0);
@@ -642,8 +621,8 @@ static inline int split_folio_to_list(struct folio *folio, struct list_head *lis
 	return -EINVAL;
 }
 
-static inline int try_folio_split_to_order(struct folio *folio,
-		struct page *page, unsigned int new_order)
+static inline int folio_split(struct folio *folio, unsigned int new_order,
+		struct page *page, struct list_head *list)
 {
 	VM_WARN_ON_ONCE_FOLIO(1, folio);
 	return -EINVAL;
mm/truncate.c +4 -4
index 2931d66c16d0..6973b05ec4b8 100644
@@ -177,7 +177,7 @@ int truncate_inode_folio(struct address_space *mapping, struct folio *folio)
 	return 0;
 }
 
-static int try_folio_split_or_unmap(struct folio *folio, struct page *split_at,
+static int folio_split_or_unmap(struct folio *folio, struct page *split_at,
 				    unsigned long min_order)
 {
 	enum ttu_flags ttu_flags =
@@ -186,7 +186,7 @@ static int try_folio_split_or_unmap(struct folio *folio, struct page *split_at,
 		TTU_IGNORE_MLOCK;
 	int ret;
 
-	ret = try_folio_split_to_order(folio, split_at, min_order);
+	ret = folio_split(folio, min_order, split_at, NULL);
 
 	/*
 	 * If the split fails, unmap the folio, so it will be refaulted
@@ -252,7 +252,7 @@ bool truncate_inode_partial_folio(struct folio *folio, loff_t start, loff_t end)
 
 	min_order = mapping_min_folio_order(folio->mapping);
 	split_at = folio_page(folio, PAGE_ALIGN_DOWN(offset) / PAGE_SIZE);
-	if (!try_folio_split_or_unmap(folio, split_at, min_order)) {
+	if (!folio_split_or_unmap(folio, split_at, min_order)) {
 		/*
 		 * try to split at offset + length to make sure folios within
 		 * the range can be dropped, especially to avoid memory waste
@@ -279,7 +279,7 @@ bool truncate_inode_partial_folio(struct folio *folio, loff_t start, loff_t end)
 		/* make sure folio2 is large and does not change its mapping */
 		if (folio_test_large(folio2) &&
 		    folio2->mapping == folio->mapping)
-			try_folio_split_or_unmap(folio2, split_at2, min_order);
+			folio_split_or_unmap(folio2, split_at2, min_order);
 
 		folio_unlock(folio2);
 out:
Signature · 1 line
2.43.0
author reviewer
#52 lore raw

PATCH v2 10/12 fs/btrfs: remove a comment referring to READ_ONLY_THP_FOR_FS

In reply to Zi Yan

READ_ONLY_THP_FOR_FS is no longer present, remove related comment.

---
 fs/btrfs/defrag.c | 3 ---
 1 file changed, 3 deletions(-)
fs/btrfs/defrag.c +0 -3
index 7e2db5d3a4d4..a8d49d9ca981 100644
@@ -860,9 +860,6 @@ static struct folio *defrag_prepare_one_folio(struct btrfs_inode *inode, pgoff_t
 		return folio;
 
 	/*
-	 * Since we can defragment files opened read-only, we can encounter
-	 * transparent huge pages here (see CONFIG_READ_ONLY_THP_FOR_FS).
-	 *
 	 * The IO for such large folios is not fully tested, thus return
 	 * an error to reject such folios unless it's an experimental build.
 	 *
Signature · 1 line
2.43.0
maintainer Reviewed-by on v2 10/12
#53 lore raw

Re: [PATCH 7.2 v2 10/12] fs/btrfs: remove a comment referring to READ_ONLY_THP_FOR_FS

Quoted 13 lines · Zi Yan

READ_ONLY_THP_FOR_FS is no longer present, remove related comment.

---
 fs/btrfs/defrag.c | 3 ---
 1 file changed, 3 deletions(-)
fs/btrfs/defrag.c +0 -0
index 7e2db5d3a4d4..a8d49d9ca981 100644

fs/btrfs/defrag.c static struct folio *defrag_prepare_one_folio(struct btrfs_inode *inode, pgoff_t · line 865

Quoted 9 lines
fs/btrfs/defrag.c +0 -3
@@ -860,9 +860,6 @@ static struct folio *defrag_prepare_one_folio(struct btrfs_inode *inode, pgoff_t
 		return folio;
 
 	/*
-	 * Since we can defragment files opened read-only, we can encounter
-	 * transparent huge pages here (see CONFIG_READ_ONLY_THP_FOR_FS).
-	 *
 	 * The IO for such large folios is not fully tested, thus return
 	 * an error to reject such folios unless it's an experimental build.
 	 *
Signature · 3 lines
Cheers,

David
author reviewer
#54 lore raw

PATCH v2 11/12 selftests/mm: remove READ_ONLY_THP_FOR_FS in khugepaged

In reply to Zi Yan

Change the requirement to a file system with large folio support and the supported order needs to include PMD_ORDER.

---
 tools/testing/selftests/mm/khugepaged.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
tools/testing/selftests/mm/khugepaged.c +2 -2
index 3fe7ef04ac62..bdcdd31beb1e 100644
@@ -1086,8 +1086,8 @@ static void usage(void)
 	fprintf(stderr, "\t<context>\t: [all|khugepaged|madvise]\n");
 	fprintf(stderr, "\t<mem_type>\t: [all|anon|file|shmem]\n");
 	fprintf(stderr, "\n\t\"file,all\" mem_type requires [dir] argument\n");
-	fprintf(stderr, "\n\t\"file,all\" mem_type requires kernel built with\n");
-	fprintf(stderr,	"\tCONFIG_READ_ONLY_THP_FOR_FS=y\n");
+	fprintf(stderr, "\n\t\"file,all\" mem_type requires a file system\n");
+	fprintf(stderr,	"\twith large folio support (order >= PMD order)\n");
 	fprintf(stderr, "\n\tif [dir] is a (sub)directory of a tmpfs mount, tmpfs must be\n");
 	fprintf(stderr,	"\tmounted with huge=advise option for khugepaged tests to work\n");
 	fprintf(stderr,	"\n\tSupported Options:\n");
Signature · 1 line
2.43.0
author reviewer
#56 lore raw

PATCH v2 12/12 selftests/mm: remove READ_ONLY_THP_FOR_FS from comments in guard-regions

In reply to Zi Yan

Any file system with large folio support and the supported orders include PMD_ORDER can be used.

---
 tools/testing/selftests/mm/guard-regions.c | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)
tools/testing/selftests/mm/guard-regions.c +5 -4
index 48e8b1539be3..13e77e48b6ef 100644
@@ -2205,7 +2205,7 @@ TEST_F(guard_regions, collapse)
 
 	/*
 	 * We must close and re-open local-file backed as read-only for
-	 * CONFIG_READ_ONLY_THP_FOR_FS to work.
+	 * MADV_COLLAPSE to work.
 	 */
 	if (variant->backing == LOCAL_FILE_BACKED) {
 		ASSERT_EQ(close(self->fd), 0);
@@ -2237,9 +2237,10 @@ TEST_F(guard_regions, collapse)
 	/*
 	 * Now collapse the entire region. This should fail in all cases.
 	 *
-	 * The madvise() call will also fail if CONFIG_READ_ONLY_THP_FOR_FS is
-	 * not set for the local file case, but we can't differentiate whether
-	 * this occurred or if the collapse was rightly rejected.
+	 * The madvise() call will also fail if the file system does not support
+	 * large folio or the supported orders do not include PMD_ORDER for the
+	 * local file case, but we can't differentiate whether this occurred or
+	 * if the collapse was rightly rejected.
 	 */
 	EXPECT_NE(madvise(ptr, size, MADV_COLLAPSE), 0);
 
Signature · 1 line
2.43.0
maintainer
#57 lore raw

Re: [PATCH 7.2 v2 12/12] selftests/mm: remove READ_ONLY_THP_FOR_FS from comments in guard-regions

tools/testing/selftests/mm/guard-regions.c TEST_F(guard_regions, collapse) · line 2208

Quoted 7 lines · Zi Yan

+++ b/tools/testing/selftests/mm/guard-regions.c

tools/testing/selftests/mm/guard-regions.c +1 -1
@@ -2205,7 +2205,7 @@ TEST_F(guard_regions, collapse)
 
 	/*
 	 * We must close and re-open local-file backed as read-only for
-	 * CONFIG_READ_ONLY_THP_FOR_FS to work.
+	 * MADV_COLLAPSE to work.

Is this true? Does MADV_COLLAPSE refuse to work on writable files? Should we delete some code here as well as fix the comment? ;-)

author reviewer
#58 lore raw

Re: [PATCH 7.2 v2 12/12] selftests/mm: remove READ_ONLY_THP_FOR_FS from comments in guard-regions

Quoted 11 lines · Matthew Wilcox

tools/testing/selftests/mm/guard-regions.c TEST_F(guard_regions, collapse) · line 2208

Quoted 7 lines · Zi Yan

+++ b/tools/testing/selftests/mm/guard-regions.c

tools/testing/selftests/mm/guard-regions.c +1 -1
@@ -2205,7 +2205,7 @@ TEST_F(guard_regions, collapse)
 
 	/*
 	 * We must close and re-open local-file backed as read-only for
-	 * CONFIG_READ_ONLY_THP_FOR_FS to work.
+	 * MADV_COLLAPSE to work.

Is this true? Does MADV_COLLAPSE refuse to work on writable files? Should we delete some code here as well as fix the comment? ;-)

file_thp_enabled() used by __thp_vma_allowable_orders() refuses writable files with inode_is_open_for_write(). That should prevent MADV_COLLAPSE from working on writable files.

Best Regards,
Yan, Zi

maintainer
#59 lore raw

Re: [PATCH 7.2 v2 12/12] selftests/mm: remove READ_ONLY_THP_FOR_FS from comments in guard-regions

Quoted 14 lines · Zi Yan
Quoted 11 lines · Matthew Wilcox

tools/testing/selftests/mm/guard-regions.c TEST_F(guard_regions, collapse) · line 2208

Quoted 7 lines · Zi Yan

+++ b/tools/testing/selftests/mm/guard-regions.c

tools/testing/selftests/mm/guard-regions.c +1 -1
@@ -2205,7 +2205,7 @@ TEST_F(guard_regions, collapse)
 
 	/*
 	 * We must close and re-open local-file backed as read-only for
-	 * CONFIG_READ_ONLY_THP_FOR_FS to work.
+	 * MADV_COLLAPSE to work.

Is this true? Does MADV_COLLAPSE refuse to work on writable files? Should we delete some code here as well as fix the comment? ;-)

Quoted 3 lines

file_thp_enabled() used by __thp_vma_allowable_orders() refuses writable files with inode_is_open_for_write(). That should prevent MADV_COLLAPSE from working on writable files.

That sounds like more code that was added for RO_THP and should be deleted? See commit e6be37b2e7bd

#60 lore raw

Re: [PATCH 7.2 v2 12/12] selftests/mm: remove READ_ONLY_THP_FOR_FS from comments in guard-regions

Quoted 7 lines · Matthew Wilcox
Quoted 6 lines · Zi Yan
Quoted 3 lines · Matthew Wilcox

Is this true? Does MADV_COLLAPSE refuse to work on writable files? Should we delete some code here as well as fix the comment? ;-)

Quoted 6 lines
Quoted 3 lines

file_thp_enabled() used by __thp_vma_allowable_orders() refuses writable files with inode_is_open_for_write(). That should prevent MADV_COLLAPSE from working on writable files.

That sounds like more code that was added for RO_THP and should be deleted? See commit e6be37b2e7bd

Sounds like something to implement on top of this patch set?

But with the added dirty checks in patch #2, maybe it's trivial to do it in this patchset already.

Signature · 3 lines
Cheers,

David
author reviewer
#61 lore raw

Re: [PATCH 7.2 v2 12/12] selftests/mm: remove READ_ONLY_THP_FOR_FS from comments in guard-regions

Quoted 12 lines · David Hildenbrand (Arm)
Quoted 11 lines · Matthew Wilcox
Quoted 9 lines · Zi Yan
Quoted 3 lines · Matthew Wilcox

Is this true? Does MADV_COLLAPSE refuse to work on writable files? Should we delete some code here as well as fix the comment? ;-)

file_thp_enabled() used by __thp_vma_allowable_orders() refuses writable files with inode_is_open_for_write(). That should prevent MADV_COLLAPSE from working on writable files.

Quoted 7 lines
Quoted 2 lines

That sounds like more code that was added for RO_THP and should be deleted? See commit e6be37b2e7bd

Sounds like something to implement on top of this patch set?

But with the added dirty checks in patch #2, maybe it's trivial to do it in this patchset already.

Can you two elaborate? The code from commit e6be37b2e7bd is moved around and replaced by functions like __thp_vma_allowable_orders().

Best Regards,
Yan, Zi

maintainer
#62 lore raw

Re: [PATCH 7.2 v2 12/12] selftests/mm: remove READ_ONLY_THP_FOR_FS from comments in guard-regions

Quoted 5 lines · Zi Yan
Quoted 4 lines · David Hildenbrand (Arm)
Quoted 2 lines · Matthew Wilcox

That sounds like more code that was added for RO_THP and should be deleted? See commit e6be37b2e7bd

Quoted 7 lines
Quoted 4 lines

Sounds like something to implement on top of this patch set?

But with the added dirty checks in patch #2, maybe it's trivial to do it in this patchset already.

Can you two elaborate? The code from commit e6be37b2e7bd is moved around and replaced by functions like __thp_vma_allowable_orders().

What I was trying to say is that this restriction was added because of ROTHP. Since we're getting rid of ROTHP, we can remove this restriction. No matter where the code has now migrated to.

author reviewer
#63 lore raw

Re: [PATCH 7.2 v2 12/12] selftests/mm: remove READ_ONLY_THP_FOR_FS from comments in guard-regions

Quoted 11 lines · Matthew Wilcox
Quoted 10 lines · Zi Yan
Quoted 8 lines · David Hildenbrand (Arm)
Quoted 2 lines · Matthew Wilcox

That sounds like more code that was added for RO_THP and should be deleted? See commit e6be37b2e7bd

Sounds like something to implement on top of this patch set?

But with the added dirty checks in patch #2, maybe it's trivial to do it in this patchset already.

Quoted 6 lines
Quoted 2 lines

Can you two elaborate? The code from commit e6be37b2e7bd is moved around and replaced by functions like __thp_vma_allowable_orders().

What I was trying to say is that this restriction was added because of ROTHP. Since we're getting rid of ROTHP, we can remove this restriction. No matter where the code has now migrated to.

Got it. Thanks. Will clean this up.

Best Regards,
Yan, Zi

maintainer Acked-by on v2 12/12
#64 lore raw

Re: [PATCH 7.2 v2 12/12] selftests/mm: remove READ_ONLY_THP_FOR_FS from comments in guard-regions

In reply to Zi Yan
Quoted 22 lines · Zi Yan

Any file system with large folio support and the supported orders include PMD_ORDER can be used.

---
 tools/testing/selftests/mm/guard-regions.c | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)
tools/testing/selftests/mm/guard-regions.c +1 -1
index 48e8b1539be3..13e77e48b6ef 100644
@@ -2205,7 +2205,7 @@ TEST_F(guard_regions, collapse)
 
 	/*
 	 * We must close and re-open local-file backed as read-only for
-	 * CONFIG_READ_ONLY_THP_FOR_FS to work.
+	 * MADV_COLLAPSE to work.
 	 */
 	if (variant->backing == LOCAL_FILE_BACKED) {
 		ASSERT_EQ(close(self->fd), 0);

tools/testing/selftests/mm/guard-regions.c TEST_F(guard_regions, collapse) · line 2241

Quoted 8 lines
tools/testing/selftests/mm/guard-regions.c +2 -3
@@ -2237,9 +2237,10 @@ TEST_F(guard_regions, collapse)
 	/*
 	 * Now collapse the entire region. This should fail in all cases.
 	 *
-	 * The madvise() call will also fail if CONFIG_READ_ONLY_THP_FOR_FS is
-	 * not set for the local file case, but we can't differentiate whether
-	 * this occurred or if the collapse was rightly rejected.
+	 * The madvise() call will also fail if the file system does not support
+	 * large folio or the supported orders do not include PMD_ORDER for the

"folios"

Signature · 3 lines
Cheers,

David