From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 440144DAFBD for ; Wed, 16 Sep 2026 22:42:20 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789598552; cv=none; b=QZJkq78vwoOelS0DQKHDbqor8vibel/AMIygFHV2/ugB/emkxDLzyalJRmfbt2Bd0sUwNKx+0FKClgLd5V9rzbugK2gn6UoHkseX4DEgTvu43OH/XhsY3jq9RDZRtKqOteqFOgwINqGrIf6VsMMZTBhra749NmldrxmeZzKAljE= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789598552; c=relaxed/simple; bh=w1O8j17xkYq6Vcb4EF7rv/Tf8+nkDMwxqcenN2st3dk=; h=Date:To:From:Subject:Message-Id; b=RUTTGaPQ0qWhUVFbydKVCKMSRzJlE/7VlE5lUYKUe2OUwJIagfstvp6ofY4Agu9td4YWW5xSMsY0ys42qCAAXGeuDklMjp0qHH+UYiRDjzauPtLUGvFkSkmmcffbY16WmXfcgNfeq0Tkn7duIlbysXZ+GgASQSUMIAIQ9SRcn9g= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=linux-foundation.org header.i=@linux-foundation.org header.b=VabJOFgs; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=linux-foundation.org header.i=@linux-foundation.org header.b="VabJOFgs" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 598F01F0089F; Wed, 16 Sep 2026 22:42:08 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux-foundation.org; s=korg; t=1789598528; bh=FSlqVip2/qV+AjGXd9cvDTZzBs0ltbMp/uEux+qLGeE=; h=Date:To:From:Subject; b=VabJOFgsA49vTWI4mIbMQweEJ5uC+pf4BaFd8Sn0Y1cb5lMDdWnEgCmSinUEPnJ5b klxv+zPM1JeHZcHLBGkqwrolVHyh+jm+a9044gbhHWhhelPtBY9KNIMYUt4ZF6oone OFoMxQJjqvdl9mj2CZuVuELOZrHrkJ0Q6by2Wlec= Date: Wed, 16 Sep 2026 15:42:07 -0700 To: mm-commits@vger.kernel.org,kas@kernel.org,akpm@linux-foundation.org From: Andrew Morton Subject: [to-be-updated] mm-collapse-declare-the-collapse-interface-in-collapseh.patch removed from -mm tree Message-Id: <20260916224208.598F01F0089F@smtp.kernel.org> Precedence: bulk X-Mailing-List: mm-commits@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: The quilt patch titled Subject: mm/collapse: declare the collapse interface in collapse.h has been removed from the -mm tree. Its filename was mm-collapse-declare-the-collapse-interface-in-collapseh.patch This patch was dropped because an updated version will be issued ------------------------------------------------------ From: "Kiryl Shutsemau (Meta)" Subject: mm/collapse: declare the collapse interface in collapse.h Date: Thu, 10 Sep 2026 13:02:31 +0100 A collapse takes four calls: - collapse_control_init() - set up the control a caller carries; - collapse_scan_pmd() - scan one PTE table, under mmap_lock; - collapse_run_pmd() - collapse what the scan found, no mmap_lock; - collapse_control_release() - done with the control. All four are static in khugepaged.c, as are collapse_possible_orders(), which says what a VMA allows, and the revalidate a caller needs once a collapse has given the mmap_lock up. No other file can ask for a collapse without them. Declare them in collapse.h, with a comment stating the order they are called in and who holds the lock over each step. hugepage_vma_revalidate() becomes collapse_vma_revalidate(): it is part of what a collapse offers now, not a helper of the daemon. Preparation for implementing MADV_COLLAPSE in madvise.c. No functional change. Assisted-by: LLM Link: https://lore.kernel.org/20260910120238.2529819-12-kirill@shutemov.name Signed-off-by: Kiryl Shutsemau (Meta) Signed-off-by: Andrew Morton Cc: Baolin Wang Cc: Barry Song Cc: David Hildenbrand Cc: Dev Jain Cc: Jann Horn Cc: Lance Yang Cc: Liam R. Howlett Cc: Lorenzo Stoakes Cc: Ryan Roberts Cc: Vlastimil Babka Cc: Zi Yan --- mm/collapse.h | 44 ++++++++++++++++++++++++++++++++++++++++++++ mm/khugepaged.c | 18 +++++++++--------- 2 files changed, 53 insertions(+), 9 deletions(-) --- a/mm/collapse.h~mm-collapse-declare-the-collapse-interface-in-collapseh +++ a/mm/collapse.h @@ -106,4 +106,48 @@ struct collapse_control { bool scan_retract_only; }; +/* Which orders a VMA may collapse to, zero when it may not collapse at all */ +unsigned long collapse_possible_orders(struct vm_area_struct *vma, + vm_flags_t vm_flags, enum tva_type tva_flags); + +/* + * A caller states what it allows in cc->policy and then hands over one PTE + * table's worth of a VMA at a time: + * + * collapse_control_init(cc) once, before the first table + * collapse_scan_pmd(vma, addr, ...) per table + * collapse_run_pmd(mm, addr, cc) when a scan found work + * collapse_control_release(cc) once, when done with the control + * + * The caller holds mmap_lock for reading over the scan and passes an address + * within @vma, aligned to the PTE table the scan is to judge. + * + * The scan returns with that lock still held. It only reads, and almost every + * table it is offered has nothing to collapse, so a caller walks a whole VMA + * under the one lock it took to get there. SCAN_SUCCEED means there is + * something to collapse; anything else is why there is not. + * + * The run is called without the lock and returns without it, taking what it + * needs in between: what it does -- allocate, isolate, copy, flush -- is slow + * enough that a writer would wait behind it. The caller gives the lock up + * first, and with it @vma and anything derived under it, so a caller carrying + * on has to look up again with collapse_vma_revalidate(). The run revalidates + * for itself rather than trusting what the scan saw. + * + * A scan that found something has to be run: the file side takes a reference on + * the file while it still has the VMA to take it from, and the run is what + * gives it back. + */ +void collapse_control_init(struct collapse_control *cc); +void collapse_control_release(struct collapse_control *cc); +enum scan_result collapse_scan_pmd(struct vm_area_struct *vma, + unsigned long addr, struct collapse_control *cc, + unsigned long orders); +enum scan_result collapse_run_pmd(struct mm_struct *mm, unsigned long addr, + struct collapse_control *cc); +enum scan_result collapse_vma_revalidate(struct mm_struct *mm, + unsigned long address, bool expect_anon, + struct vm_area_struct **vmap, struct collapse_control *cc, + unsigned int order); + #endif /* __MM_COLLAPSE_H */ --- a/mm/khugepaged.c~mm-collapse-declare-the-collapse-interface-in-collapseh +++ a/mm/khugepaged.c @@ -498,7 +498,7 @@ void __khugepaged_enter(struct mm_struct * Check what orders are possible based on the vma and collapse type. * This is used to determine if mTHP collapse is a viable option. */ -static unsigned long collapse_possible_orders(struct vm_area_struct *vma, +unsigned long collapse_possible_orders(struct vm_area_struct *vma, vm_flags_t vm_flags, enum tva_type tva_flags) { unsigned long orders; @@ -1016,7 +1016,7 @@ static int collapse_find_target_node(str * Returns enum scan_result value. */ -static enum scan_result hugepage_vma_revalidate(struct mm_struct *mm, unsigned long address, +enum scan_result collapse_vma_revalidate(struct mm_struct *mm, unsigned long address, bool expect_anon, struct vm_area_struct **vmap, struct collapse_control *cc, unsigned int order) { @@ -1264,7 +1264,7 @@ static enum scan_result collapse_huge_pa } mmap_read_lock(mm); - result = hugepage_vma_revalidate(mm, pmd_addr, /*expect_anon=*/ true, + result = collapse_vma_revalidate(mm, pmd_addr, /*expect_anon=*/ true, &vma, cc, order); if (result != SCAN_SUCCEED) { mmap_read_unlock(mm); @@ -1299,7 +1299,7 @@ static enum scan_result collapse_huge_pa * mmap_lock. */ mmap_write_lock(mm); - result = hugepage_vma_revalidate(mm, pmd_addr, /*expect_anon=*/ true, + result = collapse_vma_revalidate(mm, pmd_addr, /*expect_anon=*/ true, &vma, cc, order); if (result != SCAN_SUCCEED) goto out_up_write; @@ -2736,13 +2736,13 @@ static enum scan_result collapse_scan_fi return result; } -static void collapse_control_init(struct collapse_control *cc) +void collapse_control_init(struct collapse_control *cc) { cc->progress = 0; cc->scan_file = NULL; } -static void collapse_control_release(struct collapse_control *cc) +void collapse_control_release(struct collapse_control *cc) { /* A scan that took a file reference should have been run */ if (WARN_ON_ONCE(cc->scan_file)) { @@ -2751,7 +2751,7 @@ static void collapse_control_release(str } } -static enum scan_result collapse_scan_pmd(struct vm_area_struct *vma, +enum scan_result collapse_scan_pmd(struct vm_area_struct *vma, unsigned long addr, struct collapse_control *cc, unsigned long orders) { @@ -2795,7 +2795,7 @@ static enum scan_result collapse_scan_pm return result; } -static enum scan_result collapse_run_pmd(struct mm_struct *mm, +enum scan_result collapse_run_pmd(struct mm_struct *mm, unsigned long addr, struct collapse_control *cc) { struct file *file = cc->scan_file; @@ -3249,7 +3249,7 @@ int madvise_collapse(struct vm_area_stru if (!vma) { cond_resched(); mmap_read_lock(mm); - result = hugepage_vma_revalidate(mm, addr, false, &found, + result = collapse_vma_revalidate(mm, addr, false, &found, cc, HPAGE_PMD_ORDER); if (result != SCAN_SUCCEED) { last_fail = result; _ Patches currently in -mm which might be from kas@kernel.org are mm-huge_memory-do-not-touch-frozen-folios-in-deferred_split_isolate.patch mm-huge_memory-dequeue-the-deferred-split-after-the-split-freeze.patch mm-huge_memory-add-folio_reset_partially_mapped.patch mm-collapse-implement-madv_collapse-in-madvisec.patch a.patch