mm/khugepaged: rework max_ptes_* handling with helper functions

The following cleanup reworks all the max_ptes_* handling into helper
functions.  This increases the code readability and will later be used to
implement the mTHP handling of these variables.

With these changes we abstract all the madvise_collapse() special casing
(do not respect the sysctls) away from the functions that utilize them.
And will be used later in this series to cleanly restrict the mTHP
collapse behavior.

No functional change is intended; however, we are now only reading the
sysfs variables once per scan, whereas before these variables were being
read on each loop iteration.

Link: https://lore.kernel.org/20260605161422.213817-4-npache@redhat.com
Signed-off-by: Nico Pache <npache@redhat.com>
Reviewed-by: Zi Yan <ziy@nvidia.com>
Reviewed-by: Lorenzo Stoakes <ljs@kernel.org>
Reviewed-by: Lance Yang <lance.yang@linux.dev>
Suggested-by: David Hildenbrand <david@kernel.org>
Acked-by: David Hildenbrand (Arm) <david@kernel.org>
Acked-by: Usama Arif <usama.arif@linux.dev>
Cc: Alistair Popple <apopple@nvidia.com>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Anshuman Khandual <anshuman.khandual@arm.com>
Cc: Bagas Sanjaya <bagasdotme@gmail.com>
Cc: Baolin Wang <baolin.wang@linux.alibaba.com>
Cc: Barry Song <baohua@kernel.org>
Cc: Brendan Jackman <jackmanb@google.com>
Cc: Byungchul Park <byungchul@sk.com>
Cc: Catalin Marinas <catalin.marinas@arm.com>
Cc: David Rientjes <rientjes@google.com>
Cc: Dev Jain <dev.jain@arm.com>
Cc: Gregory Price <gourry@gourry.net>
Cc: "Huang, Ying" <ying.huang@linux.alibaba.com>
Cc: Hugh Dickins <hughd@google.com>
Cc: Jan Kara <jack@suse.cz>
Cc: Jann Horn <jannh@google.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: Joshua Hahn <joshua.hahnjy@gmail.com>
Cc: Kefeng Wang <wangkefeng.wang@huawei.com>
Cc: Liam R. Howlett <liam@infradead.org>
Cc: "Masami Hiramatsu (Google)" <mhiramat@kernel.org>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Cc: Matthew Brost <matthew.brost@intel.com>
Cc: Matthew Wilcox (Oracle) <willy@infradead.org>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Mike Rapoport <rppt@kernel.org>
Cc: Nanyong Sun <sunnanyong@huawei.com>
Cc: Pedro Falcato <pfalcato@suse.de>
Cc: Peter Xu <peterx@redhat.com>
Cc: Rafael Aquini <raquini@redhat.com>
Cc: Rakie Kim <rakie.kim@sk.com>
Cc: Randy Dunlap <rdunlap@infradead.org>
Cc: Ryan Roberts <ryan.roberts@arm.com>
Cc: Shivank Garg <shivankg@amd.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Suren Baghdasaryan <surenb@google.com>
Cc: Takashi Iwai (SUSE) <tiwai@suse.de>
Cc: Thomas Hellström <thomas.hellstrom@linux.intel.com>
Cc: Usama Arif <usamaarif642@gmail.com>
Cc: Vishal Moola (Oracle) <vishal.moola@gmail.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Wei Yang <richard.weiyang@gmail.com>
Cc: Will Deacon <will@kernel.org>
Cc: Yang Shi <yang@os.amperecomputing.com>
Cc: Zach O'Keefe <zokeefe@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/mm/khugepaged.c b/mm/khugepaged.c
index 454ca90e3696fc399686d4901b62ab878396394f..69d34305b21734847880cf12ba42fe2da1a28bf6 100644 (file)
--- a/mm/khugepaged.c
+++ b/mm/khugepaged.c
@@ -348,6 +348,64 @@ static bool pte_none_or_zero(pte_t pte)
        return pte_present(pte) && is_zero_pfn(pte_pfn(pte));
 }
 
+/**
+ * collapse_max_ptes_none - Calculate maximum allowed empty PTEs or PTEs mapping
+ * the shared zeropage for the given collapse operation.
+ * @cc: The collapse control struct
+ * @vma: The vma to check for userfaultfd
+ *
+ * Return: Maximum number of empty/shared zeropage PTEs for the collapse operation
+ */
+static unsigned int collapse_max_ptes_none(struct collapse_control *cc,
+               struct vm_area_struct *vma)
+{
+       if (vma && userfaultfd_armed(vma))
+               return 0;
+       /* for MADV_COLLAPSE, allow any empty/shared zeropage PTEs */
+       if (!cc->is_khugepaged)
+               return HPAGE_PMD_NR;
+       /* For all other cases respect the user defined maximum */
+       return khugepaged_max_ptes_none;
+}
+
+/**
+ * collapse_max_ptes_shared - Calculate maximum allowed PTEs that map shared
+ * anonymous pages for the given collapse operation.
+ * @cc: The collapse control struct
+ *
+ * Return: Maximum number of PTEs that map shared anonymous pages for the
+ * collapse operation
+ */
+static unsigned int collapse_max_ptes_shared(struct collapse_control *cc)
+{
+       /*
+        * For MADV_COLLAPSE, do not restrict the number of PTEs that map shared
+        * anonymous pages.
+        */
+       if (!cc->is_khugepaged)
+               return HPAGE_PMD_NR;
+       return khugepaged_max_ptes_shared;
+}
+
+/**
+ * collapse_max_ptes_swap - Calculate the maximum allowed non-present PTEs or the
+ * maximum allowed non-present pagecache entries for the given collapse operation.
+ * @cc: The collapse control struct
+ *
+ * Return: Maximum number of non-present PTEs or the maximum allowed non-present
+ * pagecache entries for the collapse operation.
+ */
+static unsigned int collapse_max_ptes_swap(struct collapse_control *cc)
+{
+       /*
+        * For MADV_COLLAPSE, do not restrict the number PTEs entries or
+        * pagecache entries that are non-present.
+        */
+       if (!cc->is_khugepaged)
+               return HPAGE_PMD_NR;
+       return khugepaged_max_ptes_swap;
+}
+
 int hugepage_madvise(struct vm_area_struct *vma,
                     vm_flags_t *vm_flags, int advice)
 {
@@ -543,6 +601,8 @@ static enum scan_result __collapse_huge_page_isolate(struct vm_area_struct *vma,
                unsigned long start_addr, pte_t *pte, struct collapse_control *cc,
                struct list_head *compound_pagelist)
 {
+       const unsigned int max_ptes_none = collapse_max_ptes_none(cc, vma);
+       const unsigned int max_ptes_shared = collapse_max_ptes_shared(cc);
        struct page *page = NULL;
        struct folio *folio = NULL;
        unsigned long addr = start_addr;
@@ -554,16 +614,12 @@ static enum scan_result __collapse_huge_page_isolate(struct vm_area_struct *vma,
             _pte++, addr += PAGE_SIZE) {
                pte_t pteval = ptep_get(_pte);
                if (pte_none_or_zero(pteval)) {
-                       ++none_or_zero;
-                       if (!userfaultfd_armed(vma) &&
-                           (!cc->is_khugepaged ||
-                            none_or_zero <= khugepaged_max_ptes_none)) {
-                               continue;
-                       } else {
+                       if (++none_or_zero > max_ptes_none) {
                                result = SCAN_EXCEED_NONE_PTE;
                                count_vm_event(THP_SCAN_EXCEED_NONE_PTE);
                                goto out;
                        }
+                       continue;
                }
                if (!pte_present(pteval)) {
                        result = SCAN_PTE_NON_PRESENT;
@@ -594,9 +650,7 @@ static enum scan_result __collapse_huge_page_isolate(struct vm_area_struct *vma,
 
                /* See collapse_scan_pmd(). */
                if (folio_maybe_mapped_shared(folio)) {
-                       ++shared;
-                       if (cc->is_khugepaged &&
-                           shared > khugepaged_max_ptes_shared) {
+                       if (++shared > max_ptes_shared) {
                                result = SCAN_EXCEED_SHARED_PTE;
                                count_vm_event(THP_SCAN_EXCEED_SHARED_PTE);
                                goto out;
@@ -1276,6 +1330,9 @@ static enum scan_result collapse_scan_pmd(struct mm_struct *mm,
                struct vm_area_struct *vma, unsigned long start_addr,
                bool *lock_dropped, struct collapse_control *cc)
 {
+       const unsigned int max_ptes_none = collapse_max_ptes_none(cc, vma);
+       const unsigned int max_ptes_shared = collapse_max_ptes_shared(cc);
+       const unsigned int max_ptes_swap = collapse_max_ptes_swap(cc);
        pmd_t *pmd;
        pte_t *pte, *_pte;
        int none_or_zero = 0, shared = 0, referenced = 0;
@@ -1309,36 +1366,29 @@ static enum scan_result collapse_scan_pmd(struct mm_struct *mm,
 
                pte_t pteval = ptep_get(_pte);
                if (pte_none_or_zero(pteval)) {
-                       ++none_or_zero;
-                       if (!userfaultfd_armed(vma) &&
-                           (!cc->is_khugepaged ||
-                            none_or_zero <= khugepaged_max_ptes_none)) {
-                               continue;
-                       } else {
+                       if (++none_or_zero > max_ptes_none) {
                                result = SCAN_EXCEED_NONE_PTE;
                                count_vm_event(THP_SCAN_EXCEED_NONE_PTE);
                                goto out_unmap;
                        }
+                       continue;
                }
                if (!pte_present(pteval)) {
-                       ++unmapped;
-                       if (!cc->is_khugepaged ||
-                           unmapped <= khugepaged_max_ptes_swap) {
-                               /*
-                                * Always be strict with uffd-wp
-                                * enabled swap entries.  Please see
-                                * comment below for pte_uffd_wp().
-                                */
-                               if (pte_swp_uffd_wp_any(pteval)) {
-                                       result = SCAN_PTE_UFFD_WP;
-                                       goto out_unmap;
-                               }
-                               continue;
-                       } else {
+                       if (++unmapped > max_ptes_swap) {
                                result = SCAN_EXCEED_SWAP_PTE;
                                count_vm_event(THP_SCAN_EXCEED_SWAP_PTE);
                                goto out_unmap;
                        }
+                       /*
+                        * Always be strict with uffd-wp
+                        * enabled swap entries.  Please see
+                        * comment below for pte_uffd_wp().
+                        */
+                       if (pte_swp_uffd_wp_any(pteval)) {
+                               result = SCAN_PTE_UFFD_WP;
+                               goto out_unmap;
+                       }
+                       continue;
                }
                if (pte_uffd_wp(pteval)) {
                        /*
@@ -1381,9 +1431,7 @@ static enum scan_result collapse_scan_pmd(struct mm_struct *mm,
                 * is shared.
                 */
                if (folio_maybe_mapped_shared(folio)) {
-                       ++shared;
-                       if (cc->is_khugepaged &&
-                           shared > khugepaged_max_ptes_shared) {
+                       if (++shared > max_ptes_shared) {
                                result = SCAN_EXCEED_SHARED_PTE;
                                count_vm_event(THP_SCAN_EXCEED_SHARED_PTE);
                                goto out_unmap;
@@ -2338,6 +2386,8 @@ static enum scan_result collapse_scan_file(struct mm_struct *mm,
                unsigned long addr, struct file *file, pgoff_t start,
                struct collapse_control *cc)
 {
+       const unsigned int max_ptes_none = collapse_max_ptes_none(cc, NULL);
+       const unsigned int max_ptes_swap = collapse_max_ptes_swap(cc);
        struct folio *folio = NULL;
        struct address_space *mapping = file->f_mapping;
        XA_STATE(xas, &mapping->i_pages, start);
@@ -2356,8 +2406,7 @@ static enum scan_result collapse_scan_file(struct mm_struct *mm,
 
                if (xa_is_value(folio)) {
                        swap += 1 << xas_get_order(&xas);
-                       if (cc->is_khugepaged &&
-                           swap > khugepaged_max_ptes_swap) {
+                       if (swap > max_ptes_swap) {
                                result = SCAN_EXCEED_SWAP_PTE;
                                count_vm_event(THP_SCAN_EXCEED_SWAP_PTE);
                                break;
@@ -2428,8 +2477,7 @@ static enum scan_result collapse_scan_file(struct mm_struct *mm,
                cc->progress += HPAGE_PMD_NR;
 
        if (result == SCAN_SUCCEED) {
-               if (cc->is_khugepaged &&
-                   present < HPAGE_PMD_NR - khugepaged_max_ptes_none) {
+               if (present < HPAGE_PMD_NR - max_ptes_none) {
                        result = SCAN_EXCEED_NONE_PTE;
                        count_vm_event(THP_SCAN_EXCEED_NONE_PTE);
                } else {