AI Trajectory

null

{
  "EnableConfigs": null,
  "FocusSymbols": [],
  "Reasoning": "The patch is a pure refactoring of the folio allocation API. It renames `__folio_alloc_node` to `folio_alloc_node`, moves the `NUMA_NO_NODE` check into `__folio_alloc_noprof` (making it consistent with `alloc_pages_node`), and moves some mempolicy declarations to an internal header. It does not introduce any new functional logic, features, or complex code paths that require specific fuzzing.",
  "WorthFuzzing": false
}

null

{
  "PatchDiff": "commit dc20412bf5b73229963d922ea8ff2b0cebd1d492\nAuthor: syz-cluster \u003ctriage@syzkaller.com\u003e\nDate:   Thu Jul 16 19:27:33 2026 +0000\n\n    syz-cluster: applied patch under review\n\ndiff --git a/MAINTAINERS b/MAINTAINERS\nindex 8813d5d7eb0c1f..9cde99c2596397 100644\n--- a/MAINTAINERS\n+++ b/MAINTAINERS\n@@ -17068,6 +17068,7 @@ F:\tinclude/uapi/linux/mempolicy.h\n F:\tinclude/linux/migrate.h\n F:\tinclude/linux/migrate_mode.h\n F:\tmm/mempolicy.c\n+F:\tmm/mempolicy.h\n F:\tmm/migrate.c\n F:\tmm/migrate_device.c\n \ndiff --git a/drivers/iommu/iommu-pages.c b/drivers/iommu/iommu-pages.c\nindex 3bab175d85571a..47e0759f0e0ae3 100644\n--- a/drivers/iommu/iommu-pages.c\n+++ b/drivers/iommu/iommu-pages.c\n@@ -56,14 +56,7 @@ void *iommu_alloc_pages_node_sz(int nid, gfp_t gfp, size_t size)\n \t */\n \torder = get_order(size);\n \n-\t/*\n-\t * __folio_alloc_node() does not handle NUMA_NO_NODE like\n-\t * alloc_pages_node() did.\n-\t */\n-\tif (nid == NUMA_NO_NODE)\n-\t\tnid = numa_mem_id();\n-\n-\tfolio = __folio_alloc_node(gfp | __GFP_ZERO, order, nid);\n+\tfolio = folio_alloc_node(gfp | __GFP_ZERO, order, nid);\n \tif (unlikely(!folio))\n \t\treturn NULL;\n \ndiff --git a/drivers/irqchip/irq-loongarch-ir.c b/drivers/irqchip/irq-loongarch-ir.c\nindex 21c649a89a7063..427f7fd3cad424 100644\n--- a/drivers/irqchip/irq-loongarch-ir.c\n+++ b/drivers/irqchip/irq-loongarch-ir.c\n@@ -384,7 +384,7 @@ static int redirect_table_init(struct redirect_desc *irde)\n \tunsigned long *bitmap;\n \tstruct folio *folio;\n \n-\tfolio = __folio_alloc_node(GFP_KERNEL | __GFP_ZERO, IRD_TABLE_PAGE_ORDER, irde-\u003enode);\n+\tfolio = folio_alloc_node(GFP_KERNEL | __GFP_ZERO, IRD_TABLE_PAGE_ORDER, irde-\u003enode);\n \tif (!folio) {\n \t\tpr_err(\"Node [%d] redirect table alloc pages failed!\\n\", irde-\u003enode);\n \t\treturn -ENOMEM;\n@@ -410,7 +410,7 @@ static int redirect_queue_init(struct redirect_desc *irde)\n \tstruct redirect_queue *inv_queue = \u0026irde-\u003einv_queue;\n \tstruct folio *folio;\n \n-\tfolio = __folio_alloc_node(GFP_KERNEL | __GFP_ZERO, INV_QUEUE_PAGE_ORDER, irde-\u003enode);\n+\tfolio = folio_alloc_node(GFP_KERNEL | __GFP_ZERO, INV_QUEUE_PAGE_ORDER, irde-\u003enode);\n \tif (!folio) {\n \t\tpr_err(\"Node [%d] invalid queue alloc pages failed!\\n\", irde-\u003enode);\n \t\treturn -ENOMEM;\ndiff --git a/include/linux/gfp.h b/include/linux/gfp.h\nindex 872bc53f32ec87..17c14b8ca007dc 100644\n--- a/include/linux/gfp.h\n+++ b/include/linux/gfp.h\n@@ -11,7 +11,6 @@\n #include \u003clinux/sched.h\u003e\n \n struct vm_area_struct;\n-struct mempolicy;\n \n /* Helper macro to avoid gfp flags if they are the default one */\n #define __default_gfp(a,b,...) b\n@@ -204,10 +203,6 @@ static inline void arch_free_page(struct page *page, int order) { }\n static inline void arch_alloc_page(struct page *page, int order) { }\n #endif\n \n-struct folio *__folio_alloc_noprof(gfp_t gfp, unsigned int order, int preferred_nid,\n-\t\tnodemask_t *nodemask);\n-#define __folio_alloc(...)\t\t\talloc_hooks(__folio_alloc_noprof(__VA_ARGS__))\n-\n unsigned long alloc_pages_bulk_noprof(gfp_t gfp, int preferred_nid,\n \t\t\t\tnodemask_t *nodemask, int nr_pages,\n \t\t\t\tstruct page **page_array);\n@@ -252,15 +247,9 @@ static inline void warn_if_node_offline(int this_node, gfp_t gfp_mask)\n \tdump_stack();\n }\n \n-static inline\n-struct folio *__folio_alloc_node_noprof(gfp_t gfp, unsigned int order, int nid)\n-{\n-\twarn_if_node_offline(nid, gfp);\n-\n-\treturn __folio_alloc_noprof(gfp, order, nid, NULL);\n-}\n+struct folio *folio_alloc_node_noprof(gfp_t gfp, unsigned int order, int nid);\n \n-#define  __folio_alloc_node(...)\t\talloc_hooks(__folio_alloc_node_noprof(__VA_ARGS__))\n+#define  folio_alloc_node(...)\t\talloc_hooks(folio_alloc_node_noprof(__VA_ARGS__))\n \n /*\n  * Allocate pages, preferring the node given as nid. When nid == NUMA_NO_NODE,\n@@ -274,8 +263,6 @@ struct page *alloc_pages_node_noprof(int nid, gfp_t gfp_mask, unsigned int order\n #ifdef CONFIG_NUMA\n struct page *alloc_pages_noprof(gfp_t gfp, unsigned int order);\n struct folio *folio_alloc_noprof(gfp_t gfp, unsigned int order);\n-struct folio *folio_alloc_mpol_noprof(gfp_t gfp, unsigned int order,\n-\t\tstruct mempolicy *mpol, pgoff_t ilx, int nid);\n struct folio *vma_alloc_folio_noprof(gfp_t gfp, int order, struct vm_area_struct *vma,\n \t\tunsigned long addr);\n #else\n@@ -285,12 +272,7 @@ static inline struct page *alloc_pages_noprof(gfp_t gfp_mask, unsigned int order\n }\n static inline struct folio *folio_alloc_noprof(gfp_t gfp, unsigned int order)\n {\n-\treturn __folio_alloc_node_noprof(gfp, order, numa_node_id());\n-}\n-static inline struct folio *folio_alloc_mpol_noprof(gfp_t gfp, unsigned int order,\n-\t\tstruct mempolicy *mpol, pgoff_t ilx, int nid)\n-{\n-\treturn folio_alloc_noprof(gfp, order);\n+\treturn folio_alloc_node_noprof(gfp, order, numa_node_id());\n }\n static inline struct folio *vma_alloc_folio_noprof(gfp_t gfp, int order,\n \t\tstruct vm_area_struct *vma, unsigned long addr)\n@@ -301,7 +283,6 @@ static inline struct folio *vma_alloc_folio_noprof(gfp_t gfp, int order,\n \n #define alloc_pages(...)\t\t\talloc_hooks(alloc_pages_noprof(__VA_ARGS__))\n #define folio_alloc(...)\t\t\talloc_hooks(folio_alloc_noprof(__VA_ARGS__))\n-#define folio_alloc_mpol(...)\t\t\talloc_hooks(folio_alloc_mpol_noprof(__VA_ARGS__))\n #define vma_alloc_folio(...)\t\t\talloc_hooks(vma_alloc_folio_noprof(__VA_ARGS__))\n \n #define alloc_page(gfp_mask) alloc_pages(gfp_mask, 0)\ndiff --git a/mm/filemap.c b/mm/filemap.c\nindex 1dbb4c6f824e9a..1cf91970a68501 100644\n--- a/mm/filemap.c\n+++ b/mm/filemap.c\n@@ -52,6 +52,7 @@\n \n #include \u003casm/tlbflush.h\u003e\n #include \"internal.h\"\n+#include \"mempolicy.h\"\n \n #define CREATE_TRACE_POINTS\n #include \u003ctrace/events/filemap.h\u003e\n@@ -63,6 +64,7 @@\n \n #include \u003casm/mman.h\u003e\n \n+#include \"mempolicy.h\"\n #include \"swap.h\"\n \n /*\n@@ -1005,7 +1007,7 @@ struct folio *filemap_alloc_folio_noprof(gfp_t gfp, unsigned int order,\n \t\tdo {\n \t\t\tcpuset_mems_cookie = read_mems_allowed_begin();\n \t\t\tn = cpuset_mem_spread_node();\n-\t\t\tfolio = __folio_alloc_node_noprof(gfp, order, n);\n+\t\t\tfolio = folio_alloc_node_noprof(gfp, order, n);\n \t\t} while (!folio \u0026\u0026 read_mems_allowed_retry(cpuset_mems_cookie));\n \n \t\treturn folio;\ndiff --git a/mm/mempolicy.c b/mm/mempolicy.c\nindex 5720f7f54d942f..31c4e9f49b5e9e 100644\n--- a/mm/mempolicy.c\n+++ b/mm/mempolicy.c\n@@ -119,6 +119,7 @@\n #include \u003clinux/memory.h\u003e\n \n #include \"internal.h\"\n+#include \"mempolicy.h\"\n #include \"page_alloc.h\"\n \n /* Internal flags */\ndiff --git a/mm/mempolicy.h b/mm/mempolicy.h\nnew file mode 100644\nindex 00000000000000..d80fe4c559786d\n--- /dev/null\n+++ b/mm/mempolicy.h\n@@ -0,0 +1,31 @@\n+/* SPDX-License-Identifier: GPL-2.0-or-later */\n+/*\n+ * mm-internal API for mempolicy.c. Public API lives in\n+ * include/linux/mempolicy.h.\n+ */\n+#ifndef __MM_MEMPOLICY_H\n+#define __MM_MEMPOLICY_H\n+\n+#include \u003clinux/gfp.h\u003e\n+#include \u003clinux/mempolicy.h\u003e\n+\n+#ifdef CONFIG_NUMA\n+struct folio *folio_alloc_mpol_noprof(gfp_t gfp, unsigned int order,\n+\t\tstruct mempolicy *mpol, pgoff_t ilx, int nid);\n+#else\n+static inline struct folio *folio_alloc_mpol_noprof(gfp_t gfp, unsigned int order,\n+\t\tstruct mempolicy *mpol, pgoff_t ilx, int nid)\n+{\n+\treturn folio_alloc_noprof(gfp, order);\n+}\n+#endif\n+\n+#define folio_alloc_mpol(...)\t\t\talloc_hooks(folio_alloc_mpol_noprof(__VA_ARGS__))\n+\n+unsigned long alloc_pages_bulk_mempolicy_noprof(gfp_t gfp,\n+\t\t\t\tunsigned long nr_pages,\n+\t\t\t\tstruct page **page_array);\n+#define  alloc_pages_bulk_mempolicy(...)\t\t\t\t\\\n+\talloc_hooks(alloc_pages_bulk_mempolicy_noprof(__VA_ARGS__))\n+\n+#endif /* __MM_MEMPOLICY_H */\ndiff --git a/mm/migrate.c b/mm/migrate.c\nindex 222c8c15f782f7..b7836b02f32dbe 100644\n--- a/mm/migrate.c\n+++ b/mm/migrate.c\n@@ -2682,7 +2682,7 @@ static struct folio *alloc_misplaced_dst_folio(struct folio *src,\n \t\t\t__GFP_NOWARN;\n \t\tgfp \u0026= ~__GFP_RECLAIM;\n \t}\n-\treturn __folio_alloc_node(gfp, order, nid);\n+\treturn folio_alloc_node(gfp, order, nid);\n }\n \n /*\ndiff --git a/mm/page_alloc.c b/mm/page_alloc.c\nindex 37a3c1c00e1696..ff8515e173e1ef 100644\n--- a/mm/page_alloc.c\n+++ b/mm/page_alloc.c\n@@ -5435,11 +5435,23 @@ EXPORT_SYMBOL(alloc_pages_node_noprof);\n struct folio *__folio_alloc_noprof(gfp_t gfp, unsigned int order, int preferred_nid,\n \t\tnodemask_t *nodemask)\n {\n-\tstruct page *page = __alloc_pages_noprof(gfp | __GFP_COMP, order,\n-\t\t\t\t\tpreferred_nid, nodemask, ALLOC_DEFAULT);\n+\tstruct page *page;\n+\n+\tif (preferred_nid == NUMA_NO_NODE)\n+\t\tpreferred_nid = numa_mem_id();\n+\n+\twarn_if_node_offline(preferred_nid, gfp);\n+\n+\tpage = __alloc_pages_noprof(gfp | __GFP_COMP, order,\n+\t\t\t\t    preferred_nid, nodemask, ALLOC_DEFAULT);\n \treturn page_rmappable_folio(page);\n }\n-EXPORT_SYMBOL(__folio_alloc_noprof);\n+\n+struct folio *folio_alloc_node_noprof(gfp_t gfp, unsigned int order, int nid)\n+{\n+\treturn __folio_alloc_noprof(gfp, order, nid, NULL);\n+}\n+EXPORT_SYMBOL(folio_alloc_node_noprof);\n \n /*\n  * Common helper functions. Never use with __GFP_HIGHMEM because the returned\ndiff --git a/mm/page_alloc.h b/mm/page_alloc.h\nindex b9259deddb59d7..409be31898ae77 100644\n--- a/mm/page_alloc.h\n+++ b/mm/page_alloc.h\n@@ -258,6 +258,10 @@ struct page *__alloc_pages_noprof(gfp_t gfp, unsigned int order, int preferred_n\n \t\tnodemask_t *nodemask, unsigned int alloc_flags);\n #define __alloc_pages(...)\t\t\talloc_hooks(__alloc_pages_noprof(__VA_ARGS__))\n \n+struct folio *__folio_alloc_noprof(gfp_t gfp, unsigned int order, int preferred_nid,\n+\t\tnodemask_t *nodemask);\n+#define __folio_alloc(...)\t\t\talloc_hooks(__folio_alloc_noprof(__VA_ARGS__))\n+\n extern void zone_pcp_reset(struct zone *zone);\n extern void zone_pcp_disable(struct zone *zone);\n extern void zone_pcp_enable(struct zone *zone);\ndiff --git a/mm/shmem.c b/mm/shmem.c\nindex 5071177059a964..69f561332bb934 100644\n--- a/mm/shmem.c\n+++ b/mm/shmem.c\n@@ -41,6 +41,7 @@\n #include \u003clinux/swapfile.h\u003e\n #include \u003clinux/iversion.h\u003e\n #include \u003clinux/unicode.h\u003e\n+#include \"mempolicy.h\"\n #include \"swap.h\"\n \n static struct vfsmount *shm_mnt __ro_after_init;\ndiff --git a/mm/swap_state.c b/mm/swap_state.c\nindex 5be825911e645e..8ccd03c39a4071 100644\n--- a/mm/swap_state.c\n+++ b/mm/swap_state.c\n@@ -24,6 +24,7 @@\n #include \u003clinux/shmem_fs.h\u003e\n #include \u003clinux/sysctl.h\u003e\n #include \"internal.h\"\n+#include \"mempolicy.h\"\n #include \"swap_table.h\"\n #include \"swap.h\"\n \ndiff --git a/net/sunrpc/svc.c b/net/sunrpc/svc.c\nindex ae9ec4bf34f729..74350a2e07036e 100644\n--- a/net/sunrpc/svc.c\n+++ b/net/sunrpc/svc.c\n@@ -711,7 +711,7 @@ svc_prepare_thread(struct svc_serv *serv, struct svc_pool *pool, int node)\n \trqstp-\u003erq_server = serv;\n \trqstp-\u003erq_pool = pool;\n \n-\trqstp-\u003erq_scratch_folio = __folio_alloc_node(GFP_KERNEL, 0, node);\n+\trqstp-\u003erq_scratch_folio = folio_alloc_node(GFP_KERNEL, 0, node);\n \tif (!rqstp-\u003erq_scratch_folio)\n \t\tgoto out_enomem;\n \n"
}

gemini-3.1-pro-preview

null

{
  "EnableConfigs": null,
  "FocusSymbols": [],
  "Reasoning": "The patch is a pure refactoring of the folio allocation API. It renames `__folio_alloc_node` to `folio_alloc_node`, moves the `NUMA_NO_NODE` check into `__folio_alloc_noprof` (making it consistent with `alloc_pages_node`), and moves some mempolicy declarations to an internal header. It does not introduce any new functional logic, features, or complex code paths that require specific fuzzing.",
  "WorthFuzzing": false
}

You are an expert Linux kernel maintainer.
Your job is to review a provided patch series and determine
if it makes functional changes to the kernel that should be fuzzed.

IMPORTANT: The changes have ALREADY been applied and committed as the HEAD commit in
your workspace. Do NOT rely on your internal knowledge of the kernel. You must actively
use your code access tools to examine the actual source code and confirm any assumptions.

Return WorthFuzzing=false if the patch only contains:
- Modifications to Documentation/, Kconfig files, or code comments.
- Purely decorative changes, such as logging (e.g., pr_err, printk) or tracepoints.
- Changes to numeric constants or macros that do not functionally alter execution flow.
- Code paths that are impossible to reach in virtualized environments like GCE or QEMU,
even when utilizing software-emulated hardware (e.g., usb gadget, mac80211_hwsim).

If it modifies reachable core kernel logic, drivers, or architectures, use your code search
tools to verify the code can be executed, then return WorthFuzzing=true.

When returning WorthFuzzing=true, you MUST ALSO:
1. Extract any specific kernel functions that should be heavily fuzzed into FocusSymbols.
   Avoid listing generic hot-path functions to prevent skewed test distributions.
2. Identify any specific CONFIG_ options required to properly test this new/modified feature.
   Go and look into the Kconfig files and check for ifdefs around the code, do not make assumptions.
   Do not list too generic configs (we already have them enabled). Only list those that
   specifically cover the modified code. List them in the EnableConfigs output array,
   and DO NOT add a 'CONFIG_' prefix (e.g., return "NET_IPV4" instead of "CONFIG_NET_IPV4").
Prefer calling several tools at the same time to save round-trips.


Use set-results tool to provide results of the analysis.
It must be called exactly once before the final reply.
Ignore results of this tool.

For your convenience, here is the diff of the changes:
commit dc20412bf5b73229963d922ea8ff2b0cebd1d492
Author: syz-cluster <triage@syzkaller.com>
Date:   Thu Jul 16 19:27:33 2026 +0000

    syz-cluster: applied patch under review

diff --git a/MAINTAINERS b/MAINTAINERS
index 8813d5d7eb0c1f..9cde99c2596397 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -17068,6 +17068,7 @@ F:	include/uapi/linux/mempolicy.h
 F:	include/linux/migrate.h
 F:	include/linux/migrate_mode.h
 F:	mm/mempolicy.c
+F:	mm/mempolicy.h
 F:	mm/migrate.c
 F:	mm/migrate_device.c
 
diff --git a/drivers/iommu/iommu-pages.c b/drivers/iommu/iommu-pages.c
index 3bab175d85571a..47e0759f0e0ae3 100644
--- a/drivers/iommu/iommu-pages.c
+++ b/drivers/iommu/iommu-pages.c
@@ -56,14 +56,7 @@ void *iommu_alloc_pages_node_sz(int nid, gfp_t gfp, size_t size)
 	 */
 	order = get_order(size);
 
-	/*
-	 * __folio_alloc_node() does not handle NUMA_NO_NODE like
-	 * alloc_pages_node() did.
-	 */
-	if (nid == NUMA_NO_NODE)
-		nid = numa_mem_id();
-
-	folio = __folio_alloc_node(gfp | __GFP_ZERO, order, nid);
+	folio = folio_alloc_node(gfp | __GFP_ZERO, order, nid);
 	if (unlikely(!folio))
 		return NULL;
 
diff --git a/drivers/irqchip/irq-loongarch-ir.c b/drivers/irqchip/irq-loongarch-ir.c
index 21c649a89a7063..427f7fd3cad424 100644
--- a/drivers/irqchip/irq-loongarch-ir.c
+++ b/drivers/irqchip/irq-loongarch-ir.c
@@ -384,7 +384,7 @@ static int redirect_table_init(struct redirect_desc *irde)
 	unsigned long *bitmap;
 	struct folio *folio;
 
-	folio = __folio_alloc_node(GFP_KERNEL | __GFP_ZERO, IRD_TABLE_PAGE_ORDER, irde->node);
+	folio = folio_alloc_node(GFP_KERNEL | __GFP_ZERO, IRD_TABLE_PAGE_ORDER, irde->node);
 	if (!folio) {
 		pr_err("Node [%d] redirect table alloc pages failed!\n", irde->node);
 		return -ENOMEM;
@@ -410,7 +410,7 @@ static int redirect_queue_init(struct redirect_desc *irde)
 	struct redirect_queue *inv_queue = &irde->inv_queue;
 	struct folio *folio;
 
-	folio = __folio_alloc_node(GFP_KERNEL | __GFP_ZERO, INV_QUEUE_PAGE_ORDER, irde->node);
+	folio = folio_alloc_node(GFP_KERNEL | __GFP_ZERO, INV_QUEUE_PAGE_ORDER, irde->node);
 	if (!folio) {
 		pr_err("Node [%d] invalid queue alloc pages failed!\n", irde->node);
 		return -ENOMEM;
diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index 872bc53f32ec87..17c14b8ca007dc 100644
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -11,7 +11,6 @@
 #include <linux/sched.h>
 
 struct vm_area_struct;
-struct mempolicy;
 
 /* Helper macro to avoid gfp flags if they are the default one */
 #define __default_gfp(a,b,...) b
@@ -204,10 +203,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,15 +247,9 @@ 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__))
+#define  folio_alloc_node(...)		alloc_hooks(folio_alloc_node_noprof(__VA_ARGS__))
 
 /*
  * Allocate pages, preferring the node given as nid. When nid == NUMA_NO_NODE,
@@ -274,8 +263,6 @@ struct page *alloc_pages_node_noprof(int nid, gfp_t gfp_mask, unsigned int order
 #ifdef CONFIG_NUMA
 struct page *alloc_pages_noprof(gfp_t gfp, unsigned int order);
 struct folio *folio_alloc_noprof(gfp_t gfp, unsigned int order);
-struct folio *folio_alloc_mpol_noprof(gfp_t gfp, unsigned int order,
-		struct mempolicy *mpol, pgoff_t ilx, int nid);
 struct folio *vma_alloc_folio_noprof(gfp_t gfp, int order, struct vm_area_struct *vma,
 		unsigned long addr);
 #else
@@ -285,12 +272,7 @@ static inline struct page *alloc_pages_noprof(gfp_t gfp_mask, unsigned int order
 }
 static inline struct folio *folio_alloc_noprof(gfp_t gfp, unsigned int order)
 {
-	return __folio_alloc_node_noprof(gfp, order, numa_node_id());
-}
-static inline struct folio *folio_alloc_mpol_noprof(gfp_t gfp, unsigned int order,
-		struct mempolicy *mpol, pgoff_t ilx, int nid)
-{
-	return folio_alloc_noprof(gfp, order);
+	return folio_alloc_node_noprof(gfp, order, numa_node_id());
 }
 static inline struct folio *vma_alloc_folio_noprof(gfp_t gfp, int order,
 		struct vm_area_struct *vma, unsigned long addr)
@@ -301,7 +283,6 @@ static inline struct folio *vma_alloc_folio_noprof(gfp_t gfp, int order,
 
 #define alloc_pages(...)			alloc_hooks(alloc_pages_noprof(__VA_ARGS__))
 #define folio_alloc(...)			alloc_hooks(folio_alloc_noprof(__VA_ARGS__))
-#define folio_alloc_mpol(...)			alloc_hooks(folio_alloc_mpol_noprof(__VA_ARGS__))
 #define vma_alloc_folio(...)			alloc_hooks(vma_alloc_folio_noprof(__VA_ARGS__))
 
 #define alloc_page(gfp_mask) alloc_pages(gfp_mask, 0)
diff --git a/mm/filemap.c b/mm/filemap.c
index 1dbb4c6f824e9a..1cf91970a68501 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -52,6 +52,7 @@
 
 #include <asm/tlbflush.h>
 #include "internal.h"
+#include "mempolicy.h"
 
 #define CREATE_TRACE_POINTS
 #include <trace/events/filemap.h>
@@ -63,6 +64,7 @@
 
 #include <asm/mman.h>
 
+#include "mempolicy.h"
 #include "swap.h"
 
 /*
@@ -1005,7 +1007,7 @@ struct folio *filemap_alloc_folio_noprof(gfp_t gfp, unsigned int order,
 		do {
 			cpuset_mems_cookie = read_mems_allowed_begin();
 			n = cpuset_mem_spread_node();
-			folio = __folio_alloc_node_noprof(gfp, order, n);
+			folio = folio_alloc_node_noprof(gfp, order, n);
 		} while (!folio && read_mems_allowed_retry(cpuset_mems_cookie));
 
 		return folio;
diff --git a/mm/mempolicy.c b/mm/mempolicy.c
index 5720f7f54d942f..31c4e9f49b5e9e 100644
--- a/mm/mempolicy.c
+++ b/mm/mempolicy.c
@@ -119,6 +119,7 @@
 #include <linux/memory.h>
 
 #include "internal.h"
+#include "mempolicy.h"
 #include "page_alloc.h"
 
 /* Internal flags */
diff --git a/mm/mempolicy.h b/mm/mempolicy.h
new file mode 100644
index 00000000000000..d80fe4c559786d
--- /dev/null
+++ b/mm/mempolicy.h
@@ -0,0 +1,31 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * mm-internal API for mempolicy.c. Public API lives in
+ * include/linux/mempolicy.h.
+ */
+#ifndef __MM_MEMPOLICY_H
+#define __MM_MEMPOLICY_H
+
+#include <linux/gfp.h>
+#include <linux/mempolicy.h>
+
+#ifdef CONFIG_NUMA
+struct folio *folio_alloc_mpol_noprof(gfp_t gfp, unsigned int order,
+		struct mempolicy *mpol, pgoff_t ilx, int nid);
+#else
+static inline struct folio *folio_alloc_mpol_noprof(gfp_t gfp, unsigned int order,
+		struct mempolicy *mpol, pgoff_t ilx, int nid)
+{
+	return folio_alloc_noprof(gfp, order);
+}
+#endif
+
+#define folio_alloc_mpol(...)			alloc_hooks(folio_alloc_mpol_noprof(__VA_ARGS__))
+
+unsigned long alloc_pages_bulk_mempolicy_noprof(gfp_t gfp,
+				unsigned long nr_pages,
+				struct page **page_array);
+#define  alloc_pages_bulk_mempolicy(...)				\
+	alloc_hooks(alloc_pages_bulk_mempolicy_noprof(__VA_ARGS__))
+
+#endif /* __MM_MEMPOLICY_H */
diff --git a/mm/migrate.c b/mm/migrate.c
index 222c8c15f782f7..b7836b02f32dbe 100644
--- a/mm/migrate.c
+++ b/mm/migrate.c
@@ -2682,7 +2682,7 @@ static struct folio *alloc_misplaced_dst_folio(struct folio *src,
 			__GFP_NOWARN;
 		gfp &= ~__GFP_RECLAIM;
 	}
-	return __folio_alloc_node(gfp, order, nid);
+	return folio_alloc_node(gfp, order, nid);
 }
 
 /*
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 37a3c1c00e1696..ff8515e173e1ef 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -5435,11 +5435,23 @@ EXPORT_SYMBOL(alloc_pages_node_noprof);
 struct folio *__folio_alloc_noprof(gfp_t gfp, unsigned int order, int preferred_nid,
 		nodemask_t *nodemask)
 {
-	struct page *page = __alloc_pages_noprof(gfp | __GFP_COMP, order,
-					preferred_nid, nodemask, ALLOC_DEFAULT);
+	struct page *page;
+
+	if (preferred_nid == NUMA_NO_NODE)
+		preferred_nid = numa_mem_id();
+
+	warn_if_node_offline(preferred_nid, gfp);
+
+	page = __alloc_pages_noprof(gfp | __GFP_COMP, order,
+				    preferred_nid, nodemask, ALLOC_DEFAULT);
 	return page_rmappable_folio(page);
 }
-EXPORT_SYMBOL(__folio_alloc_noprof);
+
+struct folio *folio_alloc_node_noprof(gfp_t gfp, unsigned int order, int nid)
+{
+	return __folio_alloc_noprof(gfp, order, nid, NULL);
+}
+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 b9259deddb59d7..409be31898ae77 100644
--- a/mm/page_alloc.h
+++ b/mm/page_alloc.h
@@ -258,6 +258,10 @@ 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);
+#define __folio_alloc(...)			alloc_hooks(__folio_alloc_noprof(__VA_ARGS__))
+
 extern void zone_pcp_reset(struct zone *zone);
 extern void zone_pcp_disable(struct zone *zone);
 extern void zone_pcp_enable(struct zone *zone);
diff --git a/mm/shmem.c b/mm/shmem.c
index 5071177059a964..69f561332bb934 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -41,6 +41,7 @@
 #include <linux/swapfile.h>
 #include <linux/iversion.h>
 #include <linux/unicode.h>
+#include "mempolicy.h"
 #include "swap.h"
 
 static struct vfsmount *shm_mnt __ro_after_init;
diff --git a/mm/swap_state.c b/mm/swap_state.c
index 5be825911e645e..8ccd03c39a4071 100644
--- a/mm/swap_state.c
+++ b/mm/swap_state.c
@@ -24,6 +24,7 @@
 #include <linux/shmem_fs.h>
 #include <linux/sysctl.h>
 #include "internal.h"
+#include "mempolicy.h"
 #include "swap_table.h"
 #include "swap.h"
 
diff --git a/net/sunrpc/svc.c b/net/sunrpc/svc.c
index ae9ec4bf34f729..74350a2e07036e 100644
--- a/net/sunrpc/svc.c
+++ b/net/sunrpc/svc.c
@@ -711,7 +711,7 @@ svc_prepare_thread(struct svc_serv *serv, struct svc_pool *pool, int node)
 	rqstp->rq_server = serv;
 	rqstp->rq_pool = pool;
 
-	rqstp->rq_scratch_folio = __folio_alloc_node(GFP_KERNEL, 0, node);
+	rqstp->rq_scratch_folio = folio_alloc_node(GFP_KERNEL, 0, node);
 	if (!rqstp->rq_scratch_folio)
 		goto out_enomem;
 

gemini-3.1-pro-preview

null

null

							input: 6092
							output: 22
							thoughts: 1670
						

**Analyzing the Folio Allocation API Refactoring**

Okay, so I'm looking at this patch and my initial thought is, it's a refactor, plain and simple. They're renaming `__folio_alloc_node` to `folio_alloc_node` and moving the `NUMA_NO_NODE` logic into `__folio_alloc_noprof`. It also looks like `folio_alloc_mpol` and `alloc_pages_bulk_mempolicy` are being shuffled into a new internal header, `mm/mempolicy.h`. No big surprises there, just tidying things up.

Let's break it down. I see the changes are reflected in `drivers/iommu/iommu-pages.c`, `drivers/irqchip/irq-loongarch-ir.c`, `mm/filemap.c`, `mm/migrate.c` and `net/sunrpc/svc.c`. It's a straightforward rename, replacing the old `__folio_alloc_node` with the new `folio_alloc_node` in those locations. The definition of the function is changed in `mm/page_alloc.c` and is exposed to the rest of the kernel through `include/linux/gfp.h`.

The core logic change is really the handling of `NUMA_NO_NODE`. Previously, it looks like `NUMA_NO_NODE` was being handled at the call site of `__folio_alloc_node`, or was it defined at all? The patch moves this check into `__folio_alloc_noprof` itself, which is then called by `folio_alloc_node_noprof`. Now, `folio_alloc_node_noprof` is a direct function call, making the code cleaner.

Before, `folio_alloc_node` was a macro that called `__folio_alloc_node_noprof`. Now `folio_alloc_node` directly calls `folio_alloc_node_noprof`.
`__folio_alloc_noprof` now handles the `NUMA_NO_NODE` check and `warn_if_node_offline`.

So, from a fuzzing perspective, is there really any functional change? The core allocation mechanism itself seems untouched. It's just an API change with some logic rearrangement. The potential for new bugs here seems pretty low, given that it's just reorganizing existing code and centralizing that `NUMA_NO_NODE` check. While I'd never rule out the *possibility* of a subtle issue, it doesn't jump out at me as a prime target for intensive fuzzing efforts. It might still be worth some cursory fuzzing, but it probably shouldn't be a priority. We would need to identify all the callers of `__folio_alloc_noprof` to be certain.

{
  "Expression": "__folio_alloc_noprof"
}

{
  "Output": "mm/page_alloc.c=5433=EXPORT_SYMBOL(alloc_pages_node_noprof);\nmm/page_alloc.c-5434-\nmm/page_alloc.c:5435:struct folio *__folio_alloc_noprof(gfp_t gfp, unsigned int order, int preferred_nid,\nmm/page_alloc.c-5436-\t\tnodemask_t *nodemask)\n--\nmm/page_alloc.c=5450=struct folio *folio_alloc_node_noprof(gfp_t gfp, unsigned int order, int nid)\nmm/page_alloc.c-5451-{\nmm/page_alloc.c:5452:\treturn __folio_alloc_noprof(gfp, order, nid, NULL);\nmm/page_alloc.c-5453-}\n--\nmm/page_alloc.h=257=struct page *__alloc_pages_noprof(gfp_t gfp, unsigned int order, int preferred_nid,\n--\nmm/page_alloc.h-260-\nmm/page_alloc.h:261:struct folio *__folio_alloc_noprof(gfp_t gfp, unsigned int order, int preferred_nid,\nmm/page_alloc.h-262-\t\tnodemask_t *nodemask);\nmm/page_alloc.h:263:#define __folio_alloc(...)\t\t\talloc_hooks(__folio_alloc_noprof(__VA_ARGS__))\nmm/page_alloc.h-264-\n"
}

gemini-3.1-pro-preview

null

null

							input: 8799
							output: 19
							thoughts: 66
						

Okay, let's break this down.

**Understanding the Folio Allocation Flow**

Right, so I'm tracing the folio allocation path. It looks like `__folio_alloc_noprof` is a key function here, called directly by `folio_alloc_node_noprof` and also by `__folio_alloc`. Hmm, hold on a second... `__folio_alloc` is actually a macro. The macro expands to call `__folio_alloc_noprof`. That's important to remember; a macro abstraction is in place. Now, the real question is: where does this whole chain *begin*? Who's the calling function of `__folio_alloc`? I need to understand the entry point to this whole process, the root of the calls. Tracing that back is where I need to start.

{
  "Expression": "__folio_alloc\\("
}

{
  "Output": "mm/khugepaged.c=1238=static enum scan_result alloc_charge_folio(struct folio **foliop, struct mm_struct *mm,\n--\nmm/khugepaged.c-1245-\nmm/khugepaged.c:1246:\tfolio = __folio_alloc(gfp, order, node, \u0026cc-\u003ealloc_nmask);\nmm/khugepaged.c-1247-\tif (!folio) {\n--\nmm/migrate.c=2199=struct folio *alloc_migration_target(struct folio *src, unsigned long private)\n--\nmm/migrate.c-2234-\nmm/migrate.c:2235:\treturn __folio_alloc(gfp_mask, order, nid, mtc-\u003enmask);\nmm/migrate.c-2236-}\n--\nmm/page_alloc.h=261=struct folio *__folio_alloc_noprof(gfp_t gfp, unsigned int order, int preferred_nid,\nmm/page_alloc.h-262-\t\tnodemask_t *nodemask);\nmm/page_alloc.h:263:#define __folio_alloc(...)\t\t\talloc_hooks(__folio_alloc_noprof(__VA_ARGS__))\nmm/page_alloc.h-264-\n"
}

gemini-3.1-pro-preview

null

null

							input: 9399
							output: 22
							thoughts: 211
						

**Investigating the `__folio_alloc` Call Site and NUMA Node Handling**

Okay, so I'm digging into this `__folio_alloc` function. I see it's called by `alloc_charge_folio` in `mm/khugepaged.c` and also by `alloc_migration_target` in `mm/migrate.c`. The core issue is that, prior to this patch, `__folio_alloc` wasn't explicitly handling the `NUMA_NO_NODE` value. Now I need to figure out how these callers were interacting with it.

My first thought is, were either of those functions, `alloc_charge_folio` or `alloc_migration_target`, *even* passing `NUMA_NO_NODE`? Let's break it down... `alloc_charge_folio` seems to pass a `node` value, while `alloc_migration_target` passes a `nid`. If either was actually sending `NUMA_NO_NODE` down the line, I'd expect it to reach `__alloc_pages_noprof`. That function *should* handle the `NUMA_NO_NODE` scenario, right?

Wait a second...I'm getting a nagging feeling that's wrong. Let me double check that `__alloc_pages_noprof` function in `mm/page_alloc.c`... just to be sure. It's crucial that I verify this piece.

{
  "Expression": "__alloc_pages_noprof"
}

{
  "Output": "mm/page_alloc.c=5106=unsigned long alloc_pages_bulk_noprof(gfp_t gfp, int preferred_nid,\n--\nmm/page_alloc.c-5240-failed:\nmm/page_alloc.c:5241:\tpage = __alloc_pages_noprof(gfp, 0, preferred_nid, nodemask, ALLOC_DEFAULT);\nmm/page_alloc.c-5242-\tif (page)\n--\nmm/page_alloc.c=5410=EXPORT_SYMBOL(__alloc_frozen_pages_noprof);\nmm/page_alloc.c-5411-\nmm/page_alloc.c:5412:struct page *__alloc_pages_noprof(gfp_t gfp, unsigned int order,\nmm/page_alloc.c-5413-\t\tint preferred_nid, nodemask_t *nodemask, unsigned int alloc_flags)\n--\nmm/page_alloc.c=5424=struct page *alloc_pages_node_noprof(int nid, gfp_t gfp_mask, unsigned int order)\n--\nmm/page_alloc.c-5430-\nmm/page_alloc.c:5431:\treturn __alloc_pages_noprof(gfp_mask, order, nid, NULL, ALLOC_DEFAULT);\nmm/page_alloc.c-5432-}\n--\nmm/page_alloc.c=5435=struct folio *__folio_alloc_noprof(gfp_t gfp, unsigned int order, int preferred_nid,\n--\nmm/page_alloc.c-5444-\nmm/page_alloc.c:5445:\tpage = __alloc_pages_noprof(gfp | __GFP_COMP, order,\nmm/page_alloc.c-5446-\t\t\t\t    preferred_nid, nodemask, ALLOC_DEFAULT);\n--\nmm/page_alloc.h=255=void free_frozen_pages_nolock(struct page *page, unsigned int order);\nmm/page_alloc.h-256-\nmm/page_alloc.h:257:struct page *__alloc_pages_noprof(gfp_t gfp, unsigned int order, int preferred_nid,\nmm/page_alloc.h-258-\t\tnodemask_t *nodemask, unsigned int alloc_flags);\nmm/page_alloc.h:259:#define __alloc_pages(...)\t\t\talloc_hooks(__alloc_pages_noprof(__VA_ARGS__))\nmm/page_alloc.h-260-\n"
}

gemini-3.1-pro-preview

null

null

							input: 10604
							output: 36
							thoughts: 16
						

Okay, let's dive into this. I need to understand the workings of `__alloc_pages_noprof`. It's a critical function, no doubt, and it's probably got some interesting optimization tricks hidden within its implementation. I'm going to carefully dissect its logic, looking for the key components that impact performance and resource allocation. I'm especially interested in how it handles NUMA, page flags, and potentially, low-memory situations. I'll be looking for any hints about slab allocation or direct physical mapping; it’s likely a base layer that other kernel components build upon. Gotta get this right. Let's see how it works under the hood.

{
  "File": "mm/page_alloc.c",
  "FirstLine": 5412,
  "LineCount": 20
}

{
  "Contents": "5412:\tstruct page *__alloc_pages_noprof(gfp_t gfp, unsigned int order,\n5413:\t\t\tint preferred_nid, nodemask_t *nodemask, unsigned int alloc_flags)\n5414:\t{\n5415:\t\tstruct page *page;\n5416:\t\n5417:\t\tpage = __alloc_frozen_pages_noprof(gfp, order, preferred_nid, nodemask,\n5418:\t\t\t\t\t\t   alloc_flags);\n5419:\t\tif (page)\n5420:\t\t\tset_page_refcounted(page);\n5421:\t\treturn page;\n5422:\t}\n5423:\t\n5424:\tstruct page *alloc_pages_node_noprof(int nid, gfp_t gfp_mask, unsigned int order)\n5425:\t{\n5426:\t\tif (nid == NUMA_NO_NODE)\n5427:\t\t\tnid = numa_mem_id();\n5428:\t\n5429:\t\twarn_if_node_offline(nid, gfp_mask);\n5430:\t\n5431:\t\treturn __alloc_pages_noprof(gfp_mask, order, nid, NULL, ALLOC_DEFAULT);\n"
}

gemini-3.1-pro-preview

null

null

							input: 11140
							output: 24
							thoughts: 964
						

**Analyzing the NUMA Node Handling in Page Allocation**

Okay, so looking at this code, it seems the core of the issue revolves around how the `NUMA_NO_NODE` value is handled in page allocation, particularly within the NUMA architecture. I'm focusing on the differences between `alloc_pages_node_noprof` and the `__folio_alloc` functions.

Initially, `alloc_pages_node_noprof` correctly addresses the `NUMA_NO_NODE` case by calling `numa_mem_id()` to get the current node. However, it looks like `__alloc_pages_noprof` itself *doesn't* handle `NUMA_NO_NODE` directly.

Now, things get interesting. `__folio_alloc_noprof`, which is used to allocate folio structures, used to pass the node ID down to `__alloc_pages_noprof`. The point is, the old `__folio_alloc_node_noprof` *also* did *not* handle `NUMA_NO_NODE`. The problem is that the calling function, `__folio_alloc_node` (which itself called `__folio_alloc_node_noprof`), also did NOT handle `NUMA_NO_NODE`. This meant that `drivers/iommu/iommu-pages.c` had to do extra handling for this, which it did.

This patch, however, refactors things. It moves the `NUMA_NO_NODE` handling *into* `__folio_alloc_noprof` itself, making it responsible for the default node selection. The call is now moved to `numa_mem_id()` and the function renamed. Now, `folio_alloc_node` handles this case correctly, just like `alloc_pages_node` does. It also means that any caller of `__folio_alloc_node` or `__folio_alloc` now handles the `-1` `NUMA_NO_NODE`.

So, it's a minor refactoring, essentially. It resolves an API inconsistency. Previously, if `-1` was passed (which equates to `NUMA_NO_NODE`) to `__folio_alloc`, it was then passed to `__alloc_pages_noprof`.

The change is functionally important, though, because any caller *relying* on the default behavior will now receive it correctly.
What would have happened *before* if `NUMA_NO_NODE` was passed to these functions? Well, it will just get passed as `-1`. I need to review what `__alloc_frozen_pages_noprof` does with that case, just to be sure...

{
  "Expression": "__alloc_frozen_pages_noprof"
}

{
  "Output": "mm/mempolicy.c=2409=static struct page *alloc_pages_preferred_many(gfp_t gfp, unsigned int order,\n--\nmm/mempolicy.c-2422-\tpreferred_gfp \u0026= ~(__GFP_DIRECT_RECLAIM | __GFP_NOFAIL);\nmm/mempolicy.c:2423:\tpage = __alloc_frozen_pages_noprof(preferred_gfp, order, nid, nodemask,\nmm/mempolicy.c-2424-\t\t\t\t\t   ALLOC_DEFAULT);\nmm/mempolicy.c-2425-\tif (!page)\nmm/mempolicy.c:2426:\t\tpage = __alloc_frozen_pages_noprof(gfp, order, nid, NULL,\nmm/mempolicy.c-2427-\t\t\t\t\t\t   ALLOC_DEFAULT);\n--\nmm/mempolicy.c=2442=static struct page *alloc_pages_mpol(gfp_t gfp, unsigned int order,\n--\nmm/mempolicy.c-2472-\t\t\t */\nmm/mempolicy.c:2473:\t\t\tpage = __alloc_frozen_pages_noprof(\nmm/mempolicy.c-2474-\t\t\t\tgfp | __GFP_THISNODE | __GFP_NORETRY, order,\n--\nmm/mempolicy.c-2486-\nmm/mempolicy.c:2487:\tpage = __alloc_frozen_pages_noprof(gfp, order, nid, nodemask, ALLOC_DEFAULT);\nmm/mempolicy.c-2488-\n--\nmm/page_alloc.c=5323=static const gfp_t gfp_nolock = __GFP_NOWARN | __GFP_ZERO | __GFP_NOMEMALLOC |\n--\nmm/page_alloc.c-5328- */\nmm/page_alloc.c:5329:struct page *__alloc_frozen_pages_noprof(gfp_t gfp, unsigned int order,\nmm/page_alloc.c-5330-\t\tint preferred_nid, nodemask_t *nodemask, unsigned int alloc_flags)\n--\nmm/page_alloc.c-5409-}\nmm/page_alloc.c:5410:EXPORT_SYMBOL(__alloc_frozen_pages_noprof);\nmm/page_alloc.c-5411-\nmm/page_alloc.c=5412=struct page *__alloc_pages_noprof(gfp_t gfp, unsigned int order,\n--\nmm/page_alloc.c-5416-\nmm/page_alloc.c:5417:\tpage = __alloc_frozen_pages_noprof(gfp, order, preferred_nid, nodemask,\nmm/page_alloc.c-5418-\t\t\t\t\t   alloc_flags);\n--\nmm/page_alloc.c=7987=struct page *alloc_frozen_pages_nolock_noprof(gfp_t gfp_flags, int nid, unsigned int order)\n--\nmm/page_alloc.c-7991-\nmm/page_alloc.c:7992:\treturn __alloc_frozen_pages_noprof(gfp_flags, order, nid, NULL, ALLOC_NOLOCK);\nmm/page_alloc.c-7993-}\n--\nmm/page_alloc.h=230=extern int user_min_free_kbytes;\nmm/page_alloc.h-231-\nmm/page_alloc.h:232:struct page *__alloc_frozen_pages_noprof(gfp_t gfp, unsigned int order, int nid,\nmm/page_alloc.h-233-\t\tnodemask_t *nodemask, unsigned int alloc_flags);\nmm/page_alloc.h-234-#define __alloc_frozen_pages(...) \\\nmm/page_alloc.h:235:\talloc_hooks(__alloc_frozen_pages_noprof(__VA_ARGS__))\nmm/page_alloc.h-236-void free_frozen_pages(struct page *page, unsigned int order);\n--\nmm/page_alloc.h=242=static inline struct page *alloc_frozen_pages_noprof(gfp_t gfp, unsigned int order)\nmm/page_alloc.h-243-{\nmm/page_alloc.h:244:\treturn __alloc_frozen_pages_noprof(gfp, order, numa_node_id(), NULL,\nmm/page_alloc.h-245-\t\t\t\t\t   ALLOC_DEFAULT);\n--\nmm/slub.c=5292=static void *___kmalloc_large_node(size_t size, gfp_t flags, int node)\n--\nmm/slub.c-5305-\telse\nmm/slub.c:5306:\t\tpage = __alloc_frozen_pages_noprof(flags, order, node, NULL,\nmm/slub.c-5307-\t\t\t\t\t\t   ALLOC_DEFAULT);\n"
}

gemini-3.1-pro-preview

null

null

							input: 13958
							output: 36
							thoughts: 29
						

Okay, here's my take on those thoughts, framed as an expert's internal monologue:

**Investigating `__alloc_frozen_pages_noprof` and NUMA_NO_NODE**

Alright, let's dive into `__alloc_frozen_pages_noprof`. I need to understand its behavior, specifically how it deals with `NUMA_NO_NODE`. The implications here are fairly straightforward. I'm assuming we're dealing with memory allocation in the context of frozen pages, likely related to early boot or extremely low-level kernel operations. `NUMA_NO_NODE` is the important bit, likely indicating that a specific NUMA node isn't defined, or perhaps that we're intentionally avoiding NUMA considerations. I'm going to quickly scan the code for how it's handled. Is it treated as an error? Does it fall back to a default node, maybe node zero or all nodes? Does the function simply proceed without NUMA awareness if `NUMA_NO_NODE` is the target? This is critical for assessing the allocators performance, robustness, and the system's overall memory management. I'm looking for where `NUMA_NO_NODE` is checked, how it's used in calculations, and where it may be translated to other node indices. Specifically, I'm expecting to find conditional logic around this variable. My interest is: what does it do?

{
  "File": "mm/page_alloc.c",
  "FirstLine": 5329,
  "LineCount": 40
}

{
  "Contents": "5329:\tstruct page *__alloc_frozen_pages_noprof(gfp_t gfp, unsigned int order,\n5330:\t\t\tint preferred_nid, nodemask_t *nodemask, unsigned int alloc_flags)\n5331:\t{\n5332:\t\tstruct page *page;\n5333:\t\tgfp_t alloc_gfp; /* The gfp_t that was actually used for allocation */\n5334:\t\tstruct alloc_context ac = {\n5335:\t\t\t.alloc_flags = alloc_flags,\n5336:\t\t};\n5337:\t\tunsigned int fastpath_alloc_flags = alloc_flags;\n5338:\t\n5339:\t\t/* Other flags could be supported later if needed. */\n5340:\t\tif (WARN_ON(alloc_flags \u0026 ~(ALLOC_NOLOCK | ALLOC_NO_CODETAG)))\n5341:\t\t\treturn NULL;\n5342:\t\n5343:\t\tif (!alloc_order_allowed(gfp, order, alloc_flags))\n5344:\t\t\treturn NULL;\n5345:\t\n5346:\t\tif (alloc_flags \u0026 ALLOC_NOLOCK) {\n5347:\t\t\t/* Certain other flags could be supported later if needed. */\n5348:\t\t\tVM_WARN_ON_ONCE(gfp \u0026 ~(__GFP_ACCOUNT | gfp_nolock));\n5349:\t\t\tif (!alloc_nolock_allowed())\n5350:\t\t\t\treturn NULL;\n5351:\t\t\tgfp |= gfp_nolock;\n5352:\t\t\tfastpath_alloc_flags |= ALLOC_WMARK_MIN;\n5353:\t\t} else {\n5354:\t\t\tfastpath_alloc_flags |= ALLOC_WMARK_LOW;\n5355:\t\t}\n5356:\t\n5357:\t\tgfp \u0026= gfp_allowed_mask;\n5358:\t\t/*\n5359:\t\t * Apply scoped allocation constraints. This is mainly about GFP_NOFS\n5360:\t\t * resp. GFP_NOIO which has to be inherited for all allocation requests\n5361:\t\t * from a particular context which has been marked by\n5362:\t\t * memalloc_no{fs,io}_{save,restore}. And PF_MEMALLOC_PIN which ensures\n5363:\t\t * movable zones are not used during allocation.\n5364:\t\t */\n5365:\t\tgfp = current_gfp_context(gfp);\n5366:\t\talloc_gfp = gfp;\n5367:\t\tif (!prepare_alloc_pages(gfp, order, preferred_nid, nodemask, \u0026ac,\n5368:\t\t\t\t\u0026alloc_gfp, \u0026fastpath_alloc_flags))\n"
}

gemini-3.1-pro-preview

null

null

							input: 15030
							output: 19
							thoughts: 11
						

Okay, let's dive into this code.

**Diving into `prepare_alloc_pages`**

Alright, I'm going to start by taking a look at `prepare_alloc_pages`. My expertise allows me to quickly zero in on the key aspects here. This is a crucial function, I presume, in handling memory allocation, specifically related to pages. Given the name, I'm expecting this to be the setup stage before the actual physical allocation occurs, or perhaps some pre-validation or initialization of structures. I need to understand what this function is preparing to do, and what its inputs and outputs are. Is it taking a `struct page` pointer? A request size? Flags indicating allocation behavior? Let's trace it and see how it interacts with the rest of the memory management subsystem. Are there any critical sections or locking that are happening here? That's always a point of concern. I'll be looking for potential bottlenecks, race conditions, or optimization opportunities, considering the overall context of the memory allocator I'm working with. This is going to be interesting.

{
  "Expression": "prepare_alloc_pages"
}

{
  "Output": "mm/page_alloc.c=4730=__alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,\n--\nmm/page_alloc.c-5036-\nmm/page_alloc.c:5037:static inline bool prepare_alloc_pages(gfp_t gfp_mask, unsigned int order,\nmm/page_alloc.c-5038-\t\tint preferred_nid, nodemask_t *nodemask,\n--\nmm/page_alloc.c=5106=unsigned long alloc_pages_bulk_noprof(gfp_t gfp, int preferred_nid,\n--\nmm/page_alloc.c-5155-\tgfp \u0026= gfp_allowed_mask;\nmm/page_alloc.c:5156:\tif (!prepare_alloc_pages(gfp, 0, preferred_nid, nodemask, \u0026ac, \u0026gfp, \u0026alloc_flags))\nmm/page_alloc.c-5157-\t\tgoto out;\n--\nmm/page_alloc.c=5329=struct page *__alloc_frozen_pages_noprof(gfp_t gfp, unsigned int order,\n--\nmm/page_alloc.c-5366-\talloc_gfp = gfp;\nmm/page_alloc.c:5367:\tif (!prepare_alloc_pages(gfp, order, preferred_nid, nodemask, \u0026ac,\nmm/page_alloc.c-5368-\t\t\t\u0026alloc_gfp, \u0026fastpath_alloc_flags))\n"
}

gemini-3.1-pro-preview

null

null

							input: 15683
							output: 36
							thoughts: 11
						

Okay, let's dive into this code.

**Diving into `prepare_alloc_pages`**

Alright, I'm going to take a look at the `prepare_alloc_pages` function. I recognize this name; it's likely a critical piece in the memory allocation puzzle. My immediate thought is, what are the key responsibilities here? Is it about setting up the environment, validating parameters, or perhaps pre-zeroing pages or handling cache considerations before the actual allocation? I'm expecting to see things like sanity checks on the requested size and the memory zone, maybe some interaction with page flags, and potentially, if we're dealing with NUMA systems, some node selection logic. I'll be looking specifically at what preparatory work is performed before handing off the request to the more substantial allocation routine. My experience tells me this will be a good entry point to understanding how the kernel handles memory requests, so, here goes.

{
  "File": "mm/page_alloc.c",
  "FirstLine": 5037,
  "LineCount": 20
}

{
  "Contents": "5037:\tstatic inline bool prepare_alloc_pages(gfp_t gfp_mask, unsigned int order,\n5038:\t\t\tint preferred_nid, nodemask_t *nodemask,\n5039:\t\t\tstruct alloc_context *ac, gfp_t *alloc_gfp,\n5040:\t\t\tunsigned int *alloc_flags)\n5041:\t{\n5042:\t\tac-\u003ehighest_zoneidx = gfp_zone(gfp_mask);\n5043:\t\tac-\u003ezonelist = node_zonelist(preferred_nid, gfp_mask);\n5044:\t\tac-\u003enodemask = nodemask;\n5045:\t\tac-\u003emigratetype = gfp_migratetype(gfp_mask);\n5046:\t\n5047:\t\tif (cpusets_enabled()) {\n5048:\t\t\t*alloc_gfp |= __GFP_HARDWALL;\n5049:\t\t\t/*\n5050:\t\t\t * When we are in the interrupt context, it is irrelevant\n5051:\t\t\t * to the current task context. It means that any node ok.\n5052:\t\t\t */\n5053:\t\t\tif (in_task() \u0026\u0026 !ac-\u003enodemask)\n5054:\t\t\t\tac-\u003enodemask = \u0026cpuset_current_mems_allowed;\n5055:\t\t\telse\n5056:\t\t\t\t*alloc_flags |= ALLOC_CPUSET;\n"
}

gemini-3.1-pro-preview

null

null

							input: 16298
							output: 18
							thoughts: 49
						

Okay, here's my interpretation of that thought process, assuming I'm an expert in memory management and NUMA systems:

**Thinking Through the `node_zonelist` Function**

Right, so `node_zonelist(preferred_nid, gfp_mask)` is being invoked. That's a key function for figuring out where to allocate memory, and the `gfp_mask` is critical for defining the allocation type. My immediate question is, what happens when `preferred_nid` is `NUMA_NO_NODE`, which is essentially a signal that we don't have a preferred NUMA node. It's often set to -1. Does the function just default to some pre-configured node? Does it fall back to the local node? Or does it employ some global policy, perhaps based on load balancing or availability across the system? I need to understand the behavior in this scenario because it dictates the allocation strategy when NUMA affinity isn't explicitly requested, which is a very common case. Understanding the fallback behavior is crucial for performance. I need to refresh my memory on what `node_zonelist` does when there is no specified node. I need to review its behavior in the source code to confirm the fallback path.

{
  "Expression": "node_zonelist"
}

{
  "Output": "Documentation/mm/physical_memory.rst=210=General\n--\nDocumentation/mm/physical_memory.rst-214-  The zones for this node.  Not all of the zones may be populated, but it is\nDocumentation/mm/physical_memory.rst:215:  the full list. It is referenced by this node's node_zonelists as well as\nDocumentation/mm/physical_memory.rst:216:  other node's node_zonelists.\nDocumentation/mm/physical_memory.rst-217-\nDocumentation/mm/physical_memory.rst:218:``node_zonelists``\nDocumentation/mm/physical_memory.rst-219-  The list of all zones in all nodes. This list defines the order of zones\nDocumentation/mm/physical_memory.rst:220:  that allocations are preferred from. The ``node_zonelists`` is set up by\nDocumentation/mm/physical_memory.rst-221-  ``build_zonelists()`` in ``mm/page_alloc.c`` during the initialization of\n--\nDocumentation/translations/zh_CN/mm/physical_memory.rst=95=RAM平均分配在两个节点上的arm64机器上，使用 ``movablecore=80%`` 参数\n--\nDocumentation/translations/zh_CN/mm/physical_memory.rst-203-表示该节点的区域列表。并非所有区域都可能被填充，但这是\nDocumentation/translations/zh_CN/mm/physical_memory.rst:204:完整的列表。它被该节点的node_zonelists以及其它节点的\nDocumentation/translations/zh_CN/mm/physical_memory.rst:205:node_zonelists引用。\nDocumentation/translations/zh_CN/mm/physical_memory.rst-206-\nDocumentation/translations/zh_CN/mm/physical_memory.rst:207:``node_zonelists``\nDocumentation/translations/zh_CN/mm/physical_memory.rst-208-表示所有节点中所有区域的列表。此列表定义了分配内存时首选的区域\nDocumentation/translations/zh_CN/mm/physical_memory.rst:209:顺序。``node_zonelists`` 在核心内存管理结构初始化期间，\nDocumentation/translations/zh_CN/mm/physical_memory.rst-210-由 ``mm/page_alloc.c`` 中的 ``build_zonelists()``\n--\ndrivers/tty/sysrq.c=385=static void moom_callback(struct work_struct *ignored)\n--\ndrivers/tty/sysrq.c-388-\tstruct oom_control oc = {\ndrivers/tty/sysrq.c:389:\t\t.zonelist = node_zonelist(first_memory_node, gfp_mask),\ndrivers/tty/sysrq.c-390-\t\t.nodemask = NULL,\n--\ninclude/linux/gfp.h=179=static inline gfp_t gfp_nested_mask(gfp_t flags)\n--\ninclude/linux/gfp.h-193- */\ninclude/linux/gfp.h:194:static inline struct zonelist *node_zonelist(int nid, gfp_t flags)\ninclude/linux/gfp.h-195-{\ninclude/linux/gfp.h:196:\treturn NODE_DATA(nid)-\u003enode_zonelists + gfp_zonelist(flags);\ninclude/linux/gfp.h-197-}\n--\ninclude/linux/mmzone.h=1467=typedef struct pglist_data {\n--\ninclude/linux/mmzone.h-1470-\t * zones may be populated, but it is the full list. It is referenced by\ninclude/linux/mmzone.h:1471:\t * this node's node_zonelists as well as other node's node_zonelists.\ninclude/linux/mmzone.h-1472-\t */\n--\ninclude/linux/mmzone.h-1475-\t/*\ninclude/linux/mmzone.h:1476:\t * node_zonelists contains references to all zones in all nodes.\ninclude/linux/mmzone.h-1477-\t * Generally the first zones will be references to this node's\n--\ninclude/linux/mmzone.h-1479-\t */\ninclude/linux/mmzone.h:1480:\tstruct zonelist node_zonelists[MAX_ZONELISTS];\ninclude/linux/mmzone.h-1481-\n--\ninclude/linux/mmzone.h=1908=static inline bool movable_only_nodes(nodemask_t *nodes)\n--\ninclude/linux/mmzone.h-1922-\tnid = first_node(*nodes);\ninclude/linux/mmzone.h:1923:\tzonelist = \u0026NODE_DATA(nid)-\u003enode_zonelists[ZONELIST_FALLBACK];\ninclude/linux/mmzone.h-1924-\tz = first_zones_zonelist(zonelist, ZONE_NORMAL,\tnodes);\n--\nmm/hugetlb.c=1275=static struct folio *dequeue_hugetlb_folio_nodemask(struct hstate *h, gfp_t gfp_mask,\n--\nmm/hugetlb.c-1287-\nmm/hugetlb.c:1288:\tzonelist = node_zonelist(nid, gfp_mask);\nmm/hugetlb.c-1289-\n--\nmm/mempolicy.c=2138=unsigned int mempolicy_slab_node(void)\n--\nmm/mempolicy.c-2170-\t\tenum zone_type highest_zoneidx = gfp_zone(GFP_KERNEL);\nmm/mempolicy.c:2171:\t\tzonelist = \u0026NODE_DATA(node)-\u003enode_zonelists[ZONELIST_FALLBACK];\nmm/mempolicy.c-2172-\t\tz = first_zones_zonelist(zonelist, highest_zoneidx,\n--\nmm/mempolicy.c=2981=int mpol_misplaced(struct folio *folio, struct vm_fault *vmf,\n--\nmm/mempolicy.c-3050-\t\tz = first_zones_zonelist(\nmm/mempolicy.c:3051:\t\t\t\tnode_zonelist(thisnid, GFP_HIGHUSER),\nmm/mempolicy.c-3052-\t\t\t\tgfp_zone(GFP_HIGHUSER),\n--\nmm/mm_init.c=75=void __init mminit_verify_zonelist(void)\n--\nmm/mm_init.c-93-\t\t\tlistid = i / MAX_NR_ZONES;\nmm/mm_init.c:94:\t\t\tzonelist = \u0026pgdat-\u003enode_zonelists[listid];\nmm/mm_init.c-95-\t\t\tzone = \u0026pgdat-\u003enode_zones[zoneid];\n--\nmm/page_alloc.c=5037=static inline bool prepare_alloc_pages(gfp_t gfp_mask, unsigned int order,\n--\nmm/page_alloc.c-5042-\tac-\u003ehighest_zoneidx = gfp_zone(gfp_mask);\nmm/page_alloc.c:5043:\tac-\u003ezonelist = node_zonelist(preferred_nid, gfp_mask);\nmm/page_alloc.c-5044-\tac-\u003enodemask = nodemask;\n--\nmm/page_alloc.c=5661=static unsigned long nr_free_zone_pages(int offset)\n--\nmm/page_alloc.c-5668-\nmm/page_alloc.c:5669:\tstruct zonelist *zonelist = node_zonelist(numa_node_id(), GFP_KERNEL);\nmm/page_alloc.c-5670-\n--\nmm/page_alloc.c=5825=static void build_zonelists_in_node_order(pg_data_t *pgdat, int *node_order,\n--\nmm/page_alloc.c-5830-\nmm/page_alloc.c:5831:\tzonerefs = pgdat-\u003enode_zonelists[ZONELIST_FALLBACK]._zonerefs;\nmm/page_alloc.c-5832-\n--\nmm/page_alloc.c-5847- */\nmm/page_alloc.c:5848:static void build_thisnode_zonelists(pg_data_t *pgdat)\nmm/page_alloc.c-5849-{\n--\nmm/page_alloc.c-5852-\nmm/page_alloc.c:5853:\tzonerefs = pgdat-\u003enode_zonelists[ZONELIST_NOFALLBACK]._zonerefs;\nmm/page_alloc.c-5854-\tnr_zones = build_zonerefs_node(pgdat, zonerefs);\n--\nmm/page_alloc.c=5860=static void build_zonelists(pg_data_t *pgdat)\n--\nmm/page_alloc.c-5886-\tbuild_zonelists_in_node_order(pgdat, node_order, nr_nodes);\nmm/page_alloc.c:5887:\tbuild_thisnode_zonelists(pgdat);\nmm/page_alloc.c-5888-\tpr_info(\"Fallback order for Node %d: \", local_node);\n--\nmm/page_alloc.c=5901=int local_memory_node(int node)\n--\nmm/page_alloc.c-5904-\nmm/page_alloc.c:5905:\tz = first_zones_zonelist(node_zonelist(node, GFP_KERNEL),\nmm/page_alloc.c-5906-\t\t\t\t   gfp_zone(GFP_KERNEL),\n--\nmm/page_alloc.c=5916=static void build_zonelists(pg_data_t *pgdat)\n--\nmm/page_alloc.c-5920-\nmm/page_alloc.c:5921:\tzonerefs = pgdat-\u003enode_zonelists[ZONELIST_FALLBACK]._zonerefs;\nmm/page_alloc.c-5922-\tnr_zones = build_zonerefs_node(pgdat, zonerefs);\n--\nmm/page_alloc.c=7485=struct page *alloc_contig_frozen_pages_noprof(unsigned long nr_pages,\n--\nmm/page_alloc.c-7495-retry:\nmm/page_alloc.c:7496:\tzonelist = node_zonelist(nid, gfp_mask);\nmm/page_alloc.c-7497-\tfor_each_zone_zonelist_nodemask(zone, z, zonelist,\n--\nmm/slub.c=3893=static void *get_from_any_partial(struct kmem_cache *s, gfp_t gfp_flags,\n--\nmm/slub.c-3935-\nmm/slub.c:3936:\t\tzonelist = node_zonelist(mempolicy_slab_node(), gfp_flags);\nmm/slub.c-3937-\t\tfor_each_zone_zonelist(zone, z, zonelist, highest_zoneidx) {\n--\nmm/slub.c=7254=__refill_objects_any(struct kmem_cache *s, void **p, gfp_t gfp, unsigned int min,\n--\nmm/slub.c-7270-\t\tcpuset_mems_cookie = read_mems_allowed_begin();\nmm/slub.c:7271:\t\tzonelist = node_zonelist(mempolicy_slab_node(), gfp);\nmm/slub.c-7272-\t\tfor_each_zone_zonelist(zone, z, zonelist, highest_zoneidx) {\n--\nmm/vmscan.c=6750=unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg,\n--\nmm/vmscan.c-6775-\t */\nmm/vmscan.c:6776:\tstruct zonelist *zonelist = node_zonelist(numa_node_id(), sc.gfp_mask);\nmm/vmscan.c-6777-\n--\nmm/vmscan.c=7548=unsigned long shrink_all_memory(unsigned long nr_to_reclaim)\n--\nmm/vmscan.c-7559-\t};\nmm/vmscan.c:7560:\tstruct zonelist *zonelist = node_zonelist(numa_node_id(), sc.gfp_mask);\nmm/vmscan.c-7561-\tunsigned long nr_reclaimed;\n"
}

gemini-3.1-pro-preview

null

null

							input: 19790
							output: 129
							thoughts: 1067
						

**Analysis of the Memory Allocation Patch**

Okay, let's break this down. My initial thought when looking at this `node_zonelist` function is, "Aha, potential out-of-bounds access if `nid` is `-1` (NUMA_NO_NODE)!" That `NODE_DATA(-1)` would definitely cause problems. But, wait, this patch isn't introducing the *potential* for this issue; it's revealing an *existing* one. The code was already vulnerable! It seems that before this patch, calling functions like `__folio_alloc` with `NUMA_NO_NODE` would ultimately lead to this problematic access.

Then I realized that `alloc_pages_node`, which is a lower-level function, correctly handled the `NUMA_NO_NODE` case. It would call `numa_mem_id()` when `nid` was `NUMA_NO_NODE`. However,  `__folio_alloc_node` and its variants, crucially, *didn't* have this check.  So, any code using `__folio_alloc_node` with `NUMA_NO_NODE` was already exposed to this potential crash. I can see this by looking at `drivers/iommu/iommu-pages.c`, which contains this explicit handling, it calls `numa_mem_id()`!

Therefore, this patch is essentially just a cleanup. It's making `folio_alloc_node` behave *consistently* with `alloc_pages_node` by incorporating the `NUMA_NO_NODE` handling directly. It also removes the workaround in `drivers/iommu/iommu-pages.c` because it is no longer needed. The key takeaway is this: it doesn't introduce any *new* functional logic that requires fuzzing. It's simply moving the check into the core allocation function.

Now, let's look at the actual code change:

```c
struct folio *__folio_alloc_noprof(gfp_t gfp, unsigned int order, int preferred_nid,
		nodemask_t *nodemask)
{
	struct page *page;

	if (preferred_nid == NUMA_NO_NODE)
		preferred_nid = numa_mem_id();

	warn_if_node_offline(preferred_nid, gfp);

	page = __alloc_pages_noprof(gfp | __GFP_COMP, order,
				    preferred_nid, nodemask, ALLOC_DEFAULT);
	return page_rmappable_folio(page);
}
```

This is, frankly, extremely simple. It's a straightforward refactoring. No new complex logic, no new features, no new drivers, no new system calls. Just a minor API cleanup that centralizes the handling of `NUMA_NO_NODE`.

Let's do a quick scan of the other files touched. The `mm/mempolicy.h` change is just moving declarations, which isn't interesting from a fuzzing perspective. The other files – `mm/filemap.c`, `mm/migrate.c`, `mm/shmem.c`, `mm/swap_state.c`, `net/sunrpc/svc.c`, `drivers/irqchip/irq-loongarch-ir.c` – are simply renaming or including the header.

Therefore, my conclusion is that this patch is *not* worth fuzzing specifically. It doesn't introduce any code paths that haven't been exercised already, and the core changes are very minimal and straightforward.

{
  "EnableConfigs": [],
  "FocusSymbols": [],
  "Reasoning": "The patch is a pure refactoring of the folio allocation API. It renames `__folio_alloc_node` to `folio_alloc_node`, moves the `NUMA_NO_NODE` check into `__folio_alloc_noprof` (making it consistent with `alloc_pages_node`), and moves some mempolicy declarations to an internal header. It does not introduce any new functional logic, features, or complex code paths that require specific fuzzing.",
  "WorthFuzzing": false
}

{
  "EnableConfigs": null,
  "FocusSymbols": [],
  "Reasoning": "The patch is a pure refactoring of the folio allocation API. It renames `__folio_alloc_node` to `folio_alloc_node`, moves the `NUMA_NO_NODE` check into `__folio_alloc_noprof` (making it consistent with `alloc_pages_node`), and moves some mempolicy declarations to an internal header. It does not introduce any new functional logic, features, or complex code paths that require specific fuzzing.",
  "WorthFuzzing": false
}