__alloc_pages_noprof() takes an explicit alloc_flags, but the bulk and
folio entry points do not, so callers cannot select allocator behaviour
(e.g. an alternate zonelist) through them.

Thread alloc_flags through both, matching __alloc_pages_noprof(), and
keep the flag-carrying primitives mm-internal (page_alloc.h) so the
public gfp.h wrappers stay flag-free:

 - add __alloc_pages_bulk_noprof(gfp, alloc_flags, ...) in page_alloc.h
   alloc_pages_bulk_noprof() becomes a wrapper passing ALLOC_DEFAULT

 - give __folio_alloc_noprof() an alloc_flags parameter and moves
   __folio_alloc_node_noprof() moves into page_alloc.c
   __folio_alloc_noprof() is no longer exported

No functional change: every caller passes ALLOC_DEFAULT.

Signed-off-by: Gregory Price <[email protected]>
---
 include/linux/gfp.h | 13 +------------
 mm/khugepaged.c     |  2 +-
 mm/migrate.c        |  2 +-
 mm/page_alloc.c     | 46 ++++++++++++++++++++++++++++++---------------
 mm/page_alloc.h     |  8 ++++++++
 5 files changed, 42 insertions(+), 29 deletions(-)

diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index 872bc53f32ec8..a327e58c313f8 100644
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -204,10 +204,6 @@ static inline void arch_free_page(struct page *page, int 
order) { }
 static inline void arch_alloc_page(struct page *page, int order) { }
 #endif
 
-struct folio *__folio_alloc_noprof(gfp_t gfp, unsigned int order, int 
preferred_nid,
-               nodemask_t *nodemask);
-#define __folio_alloc(...)                     
alloc_hooks(__folio_alloc_noprof(__VA_ARGS__))
-
 unsigned long alloc_pages_bulk_noprof(gfp_t gfp, int preferred_nid,
                                nodemask_t *nodemask, int nr_pages,
                                struct page **page_array);
@@ -252,14 +248,7 @@ static inline void warn_if_node_offline(int this_node, 
gfp_t gfp_mask)
        dump_stack();
 }
 
-static inline
-struct folio *__folio_alloc_node_noprof(gfp_t gfp, unsigned int order, int nid)
-{
-       warn_if_node_offline(nid, gfp);
-
-       return __folio_alloc_noprof(gfp, order, nid, NULL);
-}
-
+struct folio *__folio_alloc_node_noprof(gfp_t gfp, unsigned int order, int 
nid);
 #define  __folio_alloc_node(...)               
alloc_hooks(__folio_alloc_node_noprof(__VA_ARGS__))
 
 /*
diff --git a/mm/khugepaged.c b/mm/khugepaged.c
index 27e8f3077e80f..89ce6bcbc376b 100644
--- a/mm/khugepaged.c
+++ b/mm/khugepaged.c
@@ -1243,7 +1243,7 @@ static enum scan_result alloc_charge_folio(struct folio 
**foliop, struct mm_stru
        int node = collapse_find_target_node(cc);
        struct folio *folio;
 
-       folio = __folio_alloc(gfp, order, node, &cc->alloc_nmask);
+       folio = __folio_alloc(gfp, order, node, &cc->alloc_nmask, 
ALLOC_DEFAULT);
        if (!folio) {
                *foliop = NULL;
                if (is_pmd_order(order))
diff --git a/mm/migrate.c b/mm/migrate.c
index 60355be9f652c..a8a86141dbb54 100644
--- a/mm/migrate.c
+++ b/mm/migrate.c
@@ -2231,7 +2231,7 @@ struct folio *alloc_migration_target(struct folio *src, 
unsigned long private)
        if (is_highmem_idx(zidx) || zidx == ZONE_MOVABLE)
                gfp_mask |= __GFP_HIGHMEM;
 
-       return __folio_alloc(gfp_mask, order, nid, mtc->nmask);
+       return __folio_alloc(gfp_mask, order, nid, mtc->nmask, ALLOC_DEFAULT);
 }
 
 #ifdef CONFIG_NUMA_MIGRATION
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 4c1ef84c02a3d..aa35bbe5d4c3e 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -5103,8 +5103,8 @@ static inline bool prepare_alloc_pages(gfp_t gfp_mask, 
unsigned int order,
  * @page_array were set to %NULL on entry, the slots from 0 to the return value
  * - 1 will be filled.
  */
-unsigned long alloc_pages_bulk_noprof(gfp_t gfp, int preferred_nid,
-                       nodemask_t *nodemask, int nr_pages,
+unsigned long __alloc_pages_bulk_noprof(gfp_t gfp, unsigned int alloc_flags,
+                       int preferred_nid, nodemask_t *nodemask, int nr_pages,
                        struct page **page_array)
 {
        struct page *page;
@@ -5112,8 +5112,8 @@ unsigned long alloc_pages_bulk_noprof(gfp_t gfp, int 
preferred_nid,
        struct zoneref *z;
        struct per_cpu_pages *pcp;
        struct list_head *pcp_list;
-       struct alloc_context ac;
-       unsigned int alloc_flags = ALLOC_WMARK_LOW;
+       struct alloc_context ac = { .alloc_flags = alloc_flags };
+       unsigned int fastpath_alloc_flags = alloc_flags | ALLOC_WMARK_LOW;
        int nr_populated = 0, nr_account = 0;
 
        /*
@@ -5153,7 +5153,7 @@ unsigned long alloc_pages_bulk_noprof(gfp_t gfp, int 
preferred_nid,
 
        /* May set ALLOC_NOFRAGMENT, fragmentation will return 1 page. */
        gfp &= gfp_allowed_mask;
-       if (!prepare_alloc_pages(gfp, 0, preferred_nid, nodemask, &ac, &gfp, 
&alloc_flags))
+       if (!prepare_alloc_pages(gfp, 0, preferred_nid, nodemask, &ac, &gfp, 
&fastpath_alloc_flags))
                goto out;
 
        /* Find an allowed local zone that meets the low watermark. */
@@ -5161,7 +5161,7 @@ unsigned long alloc_pages_bulk_noprof(gfp_t gfp, int 
preferred_nid,
        for_next_zone_zonelist_nodemask(zone, z, ac.highest_zoneidx, 
ac.nodemask) {
                unsigned long mark;
 
-               if (cpusets_enabled() && (alloc_flags & ALLOC_CPUSET) &&
+               if (cpusets_enabled() && (fastpath_alloc_flags & ALLOC_CPUSET) 
&&
                    !__cpuset_zone_allowed(zone, gfp)) {
                        continue;
                }
@@ -5171,16 +5171,17 @@ unsigned long alloc_pages_bulk_noprof(gfp_t gfp, int 
preferred_nid,
                        goto failed;
                }
 
-               cond_accept_memory(zone, 0, alloc_flags);
+               cond_accept_memory(zone, 0, fastpath_alloc_flags);
 retry_this_zone:
-               mark = wmark_pages(zone, alloc_flags & ALLOC_WMARK_MASK) + 
nr_pages - nr_populated;
+               mark = wmark_pages(zone, fastpath_alloc_flags & 
ALLOC_WMARK_MASK) +
+                      nr_pages - nr_populated;
                if (zone_watermark_fast(zone, 0,  mark,
                                zonelist_zone_idx(ac.preferred_zoneref),
-                               alloc_flags, gfp)) {
+                               fastpath_alloc_flags, gfp)) {
                        break;
                }
 
-               if (cond_accept_memory(zone, 0, alloc_flags))
+               if (cond_accept_memory(zone, 0, fastpath_alloc_flags))
                        goto retry_this_zone;
 
                /* Try again if zone has deferred pages */
@@ -5212,7 +5213,7 @@ unsigned long alloc_pages_bulk_noprof(gfp_t gfp, int 
preferred_nid,
                        continue;
                }
 
-               page = __rmqueue_pcplist(zone, 0, ac.migratetype, alloc_flags,
+               page = __rmqueue_pcplist(zone, 0, ac.migratetype, 
fastpath_alloc_flags,
                                                                pcp, pcp_list);
                if (unlikely(!page)) {
                        /* Try and allocate at least one page */
@@ -5238,11 +5239,19 @@ unsigned long alloc_pages_bulk_noprof(gfp_t gfp, int 
preferred_nid,
        return nr_populated;
 
 failed:
-       page = __alloc_pages_noprof(gfp, 0, preferred_nid, nodemask, 
ALLOC_DEFAULT);
+       page = __alloc_pages_noprof(gfp, 0, preferred_nid, nodemask, 
alloc_flags);
        if (page)
                page_array[nr_populated++] = page;
        goto out;
 }
+
+unsigned long alloc_pages_bulk_noprof(gfp_t gfp, int preferred_nid,
+                       nodemask_t *nodemask, int nr_pages,
+                       struct page **page_array)
+{
+       return __alloc_pages_bulk_noprof(gfp, ALLOC_DEFAULT, preferred_nid,
+                                        nodemask, nr_pages, page_array);
+}
 EXPORT_SYMBOL_GPL(alloc_pages_bulk_noprof);
 
 /*
@@ -5433,13 +5442,20 @@ struct page *alloc_pages_node_noprof(int nid, gfp_t 
gfp_mask, unsigned int order
 EXPORT_SYMBOL(alloc_pages_node_noprof);
 
 struct folio *__folio_alloc_noprof(gfp_t gfp, unsigned int order, int 
preferred_nid,
-               nodemask_t *nodemask)
+               nodemask_t *nodemask, unsigned int alloc_flags)
 {
        struct page *page = __alloc_pages_noprof(gfp | __GFP_COMP, order,
-                                       preferred_nid, nodemask, ALLOC_DEFAULT);
+                                       preferred_nid, nodemask, alloc_flags);
        return page_rmappable_folio(page);
 }
-EXPORT_SYMBOL(__folio_alloc_noprof);
+
+struct folio *__folio_alloc_node_noprof(gfp_t gfp, unsigned int order, int nid)
+{
+       warn_if_node_offline(nid, gfp);
+
+       return __folio_alloc_noprof(gfp, order, nid, NULL, ALLOC_DEFAULT);
+}
+EXPORT_SYMBOL(__folio_alloc_node_noprof);
 
 /*
  * Common helper functions. Never use with __GFP_HIGHMEM because the returned
diff --git a/mm/page_alloc.h b/mm/page_alloc.h
index b9259deddb59d..23fc79ce97b60 100644
--- a/mm/page_alloc.h
+++ b/mm/page_alloc.h
@@ -258,6 +258,14 @@ struct page *__alloc_pages_noprof(gfp_t gfp, unsigned int 
order, int preferred_n
                nodemask_t *nodemask, unsigned int alloc_flags);
 #define __alloc_pages(...)                     
alloc_hooks(__alloc_pages_noprof(__VA_ARGS__))
 
+struct folio *__folio_alloc_noprof(gfp_t gfp, unsigned int order, int 
preferred_nid,
+               nodemask_t *nodemask, unsigned int alloc_flags);
+#define __folio_alloc(...)                     
alloc_hooks(__folio_alloc_noprof(__VA_ARGS__))
+
+unsigned long __alloc_pages_bulk_noprof(gfp_t gfp, unsigned int alloc_flags,
+               int preferred_nid, nodemask_t *nodemask, int nr_pages,
+               struct page **page_array);
+
 extern void zone_pcp_reset(struct zone *zone);
 extern void zone_pcp_disable(struct zone *zone);
 extern void zone_pcp_enable(struct zone *zone);
-- 
2.53.0-Meta


Reply via email to