Re: [PATCH v4 4/7] mm/khugepaged: fix outdated comments

On 8/11/26 6:48 AM, Nico Pache (Red Hat) wrote:
> Fix comment in collapse_scan_pmd() that still described the old
> folio_mapcount() > folio_ref_count() check and a "512" false-positive
> scenario. The code now uses folio_expected_ref_count() != folio_ref_count()
> which doesn't suffer from the same limitation.
> 
> Fix comment in collapse_huge_page() that referenced ptep_clear_flush,
> when the code actually uses pmdp_collapse_flush.
> 
> Fix comment in __collapse_huge_page_swapin() that referenced the old
> function name khugepaged_scan_pmd, now collapse_scan_pmd.
> 
> Also clean up some simple typos and stale terminology (mmap_sem ->
> mmap_lock, PG_lock -> folio lock, page -> folio, grammar).
> 
> We also clarify a comment regarding where the max_ptes_none check is
> deferred to in mthp_collapse() from the original collapse_scan_pmd check.
> 
> Update all comments that references a function to include parentheses.
> 
> Acked-by: Usama Arif <[email protected]>
> Assisted-by: Cursor(claude-sonnet-4):4.6
> Acked-by: David Hildenbrand (Arm) <[email protected]>
> Signed-off-by: Nico Pache (Red Hat) <[email protected]>
> ---

Hi Andrew, 

Can you please append the following fixup!

Thank you :)


commit a5b3dde4f1b1657731dc7a1908ef60f6bd6283db
Author: Nico Pache (Red Hat) <[email protected]>
Date:   Fri Aug 21 04:27:28 2026 -0600

    fixup! mm/khugepaged: fix outdated comments
    
    Polish the refreshed GUP-pin comment wording per review.
    
    Signed-off-by: Nico Pache (Red Hat) <[email protected]>

diff --git a/mm/khugepaged.c b/mm/khugepaged.c
index ad7629a0216a..30f17c7494fa 100644
--- a/mm/khugepaged.c
+++ b/mm/khugepaged.c
@@ -1759,9 +1759,9 @@ static enum scan_result collapse_scan_pmd(struct mm_struct *mm,
 		/*
 		 * Check if the page has any GUP (or other external) pins.
 		 *
-		 * Here the check is racy, but such case is ephemeral and
-		 * we could always retry collapse later. Anyway the same
-		 * check will be done again later the risk seems low.
+		 * Here the check is racy, but such cases are ephemeral and
+		 * we can always retry collapse later. Anyway the same
+		 * check will be done again later, so the risk seems to be low.
 		 */
 		if (folio_expected_ref_count(folio) != folio_ref_count(folio)) {
 			result = SCAN_PAGE_COUNT;


>  mm/khugepaged.c | 44 +++++++++++++++++++++-----------------------
>  1 file changed, 21 insertions(+), 23 deletions(-)
> 
> diff --git a/mm/khugepaged.c b/mm/khugepaged.c
> index cae510aa2914..90d6e595d282 100644
> --- a/mm/khugepaged.c
> +++ b/mm/khugepaged.c
> @@ -620,7 +620,7 @@ void __khugepaged_exit(struct mm_struct *mm)
>  		/*
>  		 * This is required to serialize against
>  		 * collapse_test_exit() (which is guaranteed to run
> -		 * under mmap sem read mode). Stop here (after we return all
> +		 * under mmap_lock read mode). Stop here (after we return all
>  		 * pagetables will be destroyed) until khugepaged has finished
>  		 * working on the pagetables under the mmap_lock.
>  		 */
> @@ -788,8 +788,8 @@ static enum scan_result __collapse_huge_page_isolate(struct vm_area_struct *vma,
>  
>  		/*
>  		 * We can do it before folio_isolate_lru because the
> -		 * folio can't be freed from under us. NOTE: PG_lock
> -		 * is needed to serialize against split_huge_page
> +		 * folio can't be freed from under us. NOTE: folio lock
> +		 * is needed to serialize against split_huge_page()
>  		 * when invoked from the VM.
>  		 */
>  		if (!folio_trylock(folio)) {
> @@ -815,7 +815,7 @@ static enum scan_result __collapse_huge_page_isolate(struct vm_area_struct *vma,
>  		}
>  
>  		/*
> -		 * Isolate the page to avoid collapsing an hugepage
> +		 * Isolate the folio to avoid collapsing a hugepage
>  		 * currently in use by the VM.
>  		 */
>  		if (!folio_isolate_lru(folio)) {
> @@ -927,7 +927,7 @@ static void __collapse_huge_page_copy_failed(pte_t *pte,
>  	 * Re-establish the PMD to point to the original page table
>  	 * entry. Restoring PMD needs to be done prior to releasing
>  	 * pages. Since pages are still isolated and locked here,
> -	 * acquiring anon_vma_lock_write is unnecessary.
> +	 * acquiring anon_vma_lock_write() is unnecessary.
>  	 */
>  	pmd_ptl = pmd_lock(vma->vm_mm, pmd);
>  	pmd_populate(vma->vm_mm, pmd, pmd_pgtable(orig_pmd));
> @@ -1101,9 +1101,9 @@ static enum scan_result hugepage_vma_revalidate(struct mm_struct *mm, unsigned l
>  		return SCAN_VMA_CHECK;
>  	/*
>  	 * Anon VMA expected, the address may be unmapped then
> -	 * remapped to file after khugepaged reaquired the mmap_lock.
> +	 * remapped to file after khugepaged reacquired the mmap_lock.
>  	 *
> -	 * thp_vma_allowable_orders may return true for qualified file
> +	 * thp_vma_allowable_orders() may return true for qualified file
>  	 * vmas.
>  	 */
>  	if (expect_anon && (!(*vmap)->anon_vma || !vma_is_anonymous(*vmap)))
> @@ -1159,7 +1159,7 @@ static enum scan_result check_pmd_still_valid(struct mm_struct *mm,
>  
>  /*
>   * Bring missing pages in from swap, to complete THP collapse.
> - * Only done if khugepaged_scan_pmd believes it is worthwhile.
> + * Only done if collapse_scan_pmd() believes it is worthwhile.
>   *
>   * For mTHP orders the function bails on the first swap entry, because
>   * faulting pages back in during collapse could re-populate PTEs that
> @@ -1227,7 +1227,7 @@ static enum scan_result __collapse_huge_page_swapin(struct mm_struct *mm,
>  		pte = NULL;
>  
>  		/*
> -		 * do_swap_page returns VM_FAULT_RETRY with released mmap_lock.
> +		 * do_swap_page() returns VM_FAULT_RETRY with released mmap_lock.
>  		 * Note we treat VM_FAULT_RETRY as VM_FAULT_ERROR here because
>  		 * we do not retry here and swap entry will remain in pagetable
>  		 * resulting in later failure.
> @@ -1291,7 +1291,7 @@ static enum scan_result alloc_charge_folio(struct folio **foliop, struct mm_stru
>  }
>  
>  /*
> - * collapse_huge_page expects the mmap_lock to be unlocked before entering and
> + * collapse_huge_page() expects the mmap_lock to be unlocked before entering and
>   * will always return with the lock unlocked, to avoid holding the mmap_lock
>   * while allocating a THP, as that could trigger direct reclaim/compaction.
>   * Note that the VMA must be rechecked after grabbing the mmap_lock again.
> @@ -1338,7 +1338,7 @@ static enum scan_result collapse_huge_page(struct mm_struct *mm, unsigned long s
>  
>  	if (unmapped) {
>  		/*
> -		 * __collapse_huge_page_swapin will return with mmap_lock
> +		 * __collapse_huge_page_swapin() will return with mmap_lock
>  		 * released when it fails. So we jump out_nolock directly in
>  		 * that case.  Continuing to collapse causes inconsistency.
>  		 */
> @@ -1351,8 +1351,8 @@ static enum scan_result collapse_huge_page(struct mm_struct *mm, unsigned long s
>  	mmap_read_unlock(mm);
>  	/*
>  	 * Prevent all access to pagetables with the exception of
> -	 * gup_fast later handled by the ptep_clear_flush and the VM
> -	 * handled by the anon_vma lock + PG_lock.
> +	 * gup_fast later handled by the pmdp_collapse_flush() and the VM
> +	 * handled by the anon_vma lock + folio lock.
>  	 *
>  	 * UFFDIO_MOVE is prevented to race as well thanks to the
>  	 * mmap_lock.
> @@ -1409,9 +1409,9 @@ static enum scan_result collapse_huge_page(struct mm_struct *mm, unsigned long s
>  		spin_lock(pmd_ptl);
>  		VM_WARN_ON_ONCE(!pmd_none(*pmd));
>  		/*
> -		 * We can only use set_pmd_at when establishing
> +		 * We can only use set_pmd_at() when establishing
>  		 * hugepmds and never for establishing regular pmds that
> -		 * points to regular pagetables. Use pmd_populate for that
> +		 * points to regular pagetables. Use pmd_populate() for that
>  		 */
>  		pmd_populate(mm, pmd, pmd_pgtable(_pmd));
>  		spin_unlock(pmd_ptl);
> @@ -1643,7 +1643,8 @@ static enum scan_result collapse_scan_pmd(struct mm_struct *mm,
>  
>  	/*
>  	 * If PMD is the only enabled order, enforce max_ptes_none, otherwise
> -	 * scan all pages to populate the bitmap for mTHP collapse.
> +	 * scan all pages to populate the bitmap for mTHP collapse. The bitmap
> +	 * is then checked again in mthp_collapse() for each attempted order.
>  	 */
>  	if (enabled_orders != BIT(HPAGE_PMD_ORDER))
>  		max_ptes_none = KHUGEPAGED_MAX_PTES_LIMIT;
> @@ -1764,12 +1765,9 @@ static enum scan_result collapse_scan_pmd(struct mm_struct *mm,
>  		/*
>  		 * Check if the page has any GUP (or other external) pins.
>  		 *
> -		 * Here the check may be racy:
> -		 * it may see folio_mapcount() > folio_ref_count().
> -		 * But such case is ephemeral we could always retry collapse
> -		 * later.  However it may report false positive if the page
> -		 * has excessive GUP pins (i.e. 512).  Anyway the same check
> -		 * will be done again later the risk seems low.
> +		 * Here the check is racy, but such case is ephemeral and
> +		 * we could always retry collapse later. Anyway the same
> +		 * check will be done again later the risk seems low.
>  		 */
>  		if (folio_expected_ref_count(folio) != folio_ref_count(folio)) {
>  			result = SCAN_PAGE_COUNT;
> @@ -1790,7 +1788,7 @@ static enum scan_result collapse_scan_pmd(struct mm_struct *mm,
>  out_unmap:
>  	pte_unmap_unlock(pte, ptl);
>  	if (result == SCAN_SUCCEED) {
> -		/* collapse_huge_page expects the lock to be dropped before calling */
> +		/* collapse_huge_page() expects the lock to be dropped before calling */
>  		mmap_read_unlock(mm);
>  		result = mthp_collapse(mm, start_addr, referenced,
>  				       unmapped, cc, enabled_orders);
>