Skip to contentSkip to conversation

mm/hugetlb_cma: Fix null nodemask dereference in hugetlb_cma_alloc_frozen_folio

PATCH Superseded Sourav Panda 4 participants 14 messages Jul 26 – Aug 7

Subsystems (2)

v4 of 7 Superseded Latest is v7 →

lore
Share & tools
lore
#0 lore raw

PATCH v4 1/1 mm/hugetlb_cma: Fix null nodemask dereference in hugetlb_cma_alloc_frozen_folio

alloc_buddy_hugetlb_folio_with_mpol() can pass a NULL nodemask to alloc_fresh_hugetlb_folio() as a fallback to allocate from all nodes. If order is gigantic, alloc_fresh_hugetlb_folio() propagates the NULL nodemask down to hugetlb_cma_alloc_frozen_folio() via alloc_gigantic_frozen_folio().

hugetlb_cma_alloc_frozen_folio() blindly dereferences the nodemask in node_isset(nid, *nodemask) and for_each_node_mask(node, *nodemask), leading to a null pointer dereference kernel panic.

Fix this by checking if nodemask is NULL in hugetlb_cma_alloc_frozen_folio() and defaulting it to node_states[N_MEMORY]. This allows hugetlb_cma allocations to fall back to any node with memory, keeping behavior consistent with alloc_contig_frozen_pages() and alloc_buddy_frozen_folio().

From a userspace perspective, this bug allows an unprivileged user to crash the kernel (trigger a panic) by requesting a gigantic hugepage allocation with MPOL_PREFERRED_MANY on a system where CMA is only configured on a subset of NUMA nodes.

This can be reproduced by booting a VM with two NUMA nodes, restricting CMA to Node 1 (e.g., hugetlb_cma=1:1G default_hugepagesz=1G hugepagesz=1G hugepages=0), and running a program that allocates a 1GB hugepage area without reserving, restricts allocation to Node 0 using mbind() with MPOL_PREFERRED_MANY, and triggers a page fault:

void *ptr = mmap(NULL, 1UL << 30, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB | MAP_HUGE_1GB | MAP_NORESERVE, -1, 0);
unsigned long nodemask = 1; /* Node 0 */ mbind(ptr, 1UL << 30, MPOL_PREFERRED_MANY, &nodemask,

        sizeof(nodemask) * 8, 0);

memset(ptr, 0, 1UL << 30); /* Trigger fault */

This results in a NULL pointer dereference:

  BUG: kernel NULL pointer dereference, address: 0000000000000000
  #PF: supervisor read access in kernel mode
  #PF: error_code(0x0000) - not-present page
  Oops: Oops: 0000 [#1] SMP NOPTI
  RIP: 0010:hugetlb_cma_alloc_frozen_folio+0x75/0x120
  Call Trace:
   <TASK>
   only_alloc_fresh_hugetlb_folio.isra.0+0x2c/0x160
   alloc_surplus_hugetlb_folio+0x6d/0x100
   alloc_hugetlb_folio+0x3c5/0x660
   hugetlb_no_page+0x3d9/0x650
Fixes eb02f14c4a2b ("mm/hugetlb: allow overcommitting gigantic hugepages")

---
Changes in v4:
- Reverted the alloc_fresh_hugetlb_folio() cpuset snapshot approach from v3. As Muchun Song pointed out, snapshotting cpuset_current_mems_allowed does not prevent false-positive allocation failures without complex retry loops, and alloc_contig_frozen_pages() / alloc_buddy_frozen_folio() already handle NULL nodemasks safely internally.
- Handled NULL nodemask directly inside hugetlb_cma_alloc_frozen_folio() by defaulting nodemask to node_states[N_MEMORY] (Option 2), keeping HugeTLB allocators clean and consistent.
- v3: https://lore.kernel.org/linux-mm/[email protected]/
- v2: https://lore.kernel.org/linux-mm/[email protected]/
- v1: https://lore.kernel.org/linux-mm/[email protected]/

 mm/hugetlb_cma.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
mm/hugetlb_cma.c +4 -1
index 39344d6c78d8..5744de0ceeb7 100644
@@ -34,7 +34,10 @@ struct folio *hugetlb_cma_alloc_frozen_folio(int order, gfp_t gfp_mask,
 	if (!hugetlb_cma_size)
 		return NULL;
 
-	if (hugetlb_cma[nid])
+	if (!nodemask)
+		nodemask = &node_states[N_MEMORY];
+
+	if (hugetlb_cma[nid] && node_isset(nid, *nodemask))
 		page = cma_alloc_frozen_compound(hugetlb_cma[nid], order);
 
 	if (!page && !(gfp_mask & __GFP_THISNODE)) {
Signature · 1 line
2.55.0
maintainer
#1 lore raw
Quoted 37 lines · On Sun, 26 Jul 2026 07:29:34 +0000 Sourav Panda <[email protected]> wrote:

alloc_buddy_hugetlb_folio_with_mpol() can pass a NULL nodemask to alloc_fresh_hugetlb_folio() as a fallback to allocate from all nodes. If order is gigantic, alloc_fresh_hugetlb_folio() propagates the NULL nodemask down to hugetlb_cma_alloc_frozen_folio() via alloc_gigantic_frozen_folio().

hugetlb_cma_alloc_frozen_folio() blindly dereferences the nodemask in node_isset(nid, *nodemask) and for_each_node_mask(node, *nodemask), leading to a null pointer dereference kernel panic.

Fix this by checking if nodemask is NULL in hugetlb_cma_alloc_frozen_folio() and defaulting it to node_states[N_MEMORY]. This allows hugetlb_cma allocations to fall back to any node with memory, keeping behavior consistent with alloc_contig_frozen_pages() and alloc_buddy_frozen_folio().

Quoted 1 line

From a userspace perspective, this bug allows an unprivileged user to

crash the kernel (trigger a panic) by requesting a gigantic hugepage allocation with MPOL_PREFERRED_MANY on a system where CMA is only configured on a subset of NUMA nodes.

This can be reproduced by booting a VM with two NUMA nodes, restricting CMA to Node 1 (e.g., hugetlb_cma=1:1G default_hugepagesz=1G hugepagesz=1G hugepages=0), and running a program that allocates a 1GB hugepage area without reserving, restricts allocation to Node 0 using mbind() with MPOL_PREFERRED_MANY, and triggers a page fault:

void *ptr = mmap(NULL, 1UL << 30, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB | MAP_HUGE_1GB | MAP_NORESERVE, -1, 0);
unsigned long nodemask = 1; /* Node 0 */ mbind(ptr, 1UL << 30, MPOL_PREFERRED_MANY, &nodemask,

        sizeof(nodemask) * 8, 0);

memset(ptr, 0, 1UL << 30); /* Trigger fault */

This results in a NULL pointer dereference:

Quoted 11 lines
  BUG: kernel NULL pointer dereference, address: 0000000000000000
  #PF: supervisor read access in kernel mode
  #PF: error_code(0x0000) - not-present page
  Oops: Oops: 0000 [#1] SMP NOPTI
  RIP: 0010:hugetlb_cma_alloc_frozen_folio+0x75/0x120
  Call Trace:
   <TASK>
   only_alloc_fresh_hugetlb_folio.isra.0+0x2c/0x160
   alloc_surplus_hugetlb_folio+0x6d/0x100
   alloc_hugetlb_folio+0x3c5/0x660
   hugetlb_no_page+0x3d9/0x650

Thanks. I'll queue this as a hotfix while we await review.

Quoted 1 line
Fixes eb02f14c4a2b ("mm/hugetlb: allow overcommitting gigantic hugepages")

It's a good idea to cc the people who were involved in the to-be-fixed patch - Author and Reviewers.

Quoted 19 lines

...

mm/hugetlb_cma.c +4 -1
@@ -34,7 +34,10 @@ struct folio *hugetlb_cma_alloc_frozen_folio(int order, gfp_t gfp_mask,
 	if (!hugetlb_cma_size)
 		return NULL;
 
-	if (hugetlb_cma[nid])
+	if (!nodemask)
+		nodemask = &node_states[N_MEMORY];
+
+	if (hugetlb_cma[nid] && node_isset(nid, *nodemask))
 		page = cma_alloc_frozen_compound(hugetlb_cma[nid], order);
 
 	if (!page && !(gfp_mask & __GFP_THISNODE)) {
Signature · 1 line
2.55.0
#2 lore raw
Quoted 52 lines · Andrew Morton
Quoted 37 lines · On Sun, 26 Jul 2026 07:29:34 +0000 Sourav Panda <[email protected]> wrote:

alloc_buddy_hugetlb_folio_with_mpol() can pass a NULL nodemask to alloc_fresh_hugetlb_folio() as a fallback to allocate from all nodes. If order is gigantic, alloc_fresh_hugetlb_folio() propagates the NULL nodemask down to hugetlb_cma_alloc_frozen_folio() via alloc_gigantic_frozen_folio().

hugetlb_cma_alloc_frozen_folio() blindly dereferences the nodemask in node_isset(nid, *nodemask) and for_each_node_mask(node, *nodemask), leading to a null pointer dereference kernel panic.

Fix this by checking if nodemask is NULL in hugetlb_cma_alloc_frozen_folio() and defaulting it to node_states[N_MEMORY]. This allows hugetlb_cma allocations to fall back to any node with memory, keeping behavior consistent with alloc_contig_frozen_pages() and alloc_buddy_frozen_folio().

Quoted 1 line

From a userspace perspective, this bug allows an unprivileged user to

crash the kernel (trigger a panic) by requesting a gigantic hugepage allocation with MPOL_PREFERRED_MANY on a system where CMA is only configured on a subset of NUMA nodes.

This can be reproduced by booting a VM with two NUMA nodes, restricting CMA to Node 1 (e.g., hugetlb_cma=1:1G default_hugepagesz=1G hugepagesz=1G hugepages=0), and running a program that allocates a 1GB hugepage area without reserving, restricts allocation to Node 0 using mbind() with MPOL_PREFERRED_MANY, and triggers a page fault:

void *ptr = mmap(NULL, 1UL << 30, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB | MAP_HUGE_1GB | MAP_NORESERVE, -1, 0);
unsigned long nodemask = 1; /* Node 0 */ mbind(ptr, 1UL << 30, MPOL_PREFERRED_MANY, &nodemask,

        sizeof(nodemask) * 8, 0);

memset(ptr, 0, 1UL << 30); /* Trigger fault */

This results in a NULL pointer dereference:

Quoted 11 lines
  BUG: kernel NULL pointer dereference, address: 0000000000000000
  #PF: supervisor read access in kernel mode
  #PF: error_code(0x0000) - not-present page
  Oops: Oops: 0000 [#1] SMP NOPTI
  RIP: 0010:hugetlb_cma_alloc_frozen_folio+0x75/0x120
  Call Trace:
   <TASK>
   only_alloc_fresh_hugetlb_folio.isra.0+0x2c/0x160
   alloc_surplus_hugetlb_folio+0x6d/0x100
   alloc_hugetlb_folio+0x3c5/0x660
   hugetlb_no_page+0x3d9/0x650
Quoted 7 lines

Thanks. I'll queue this as a hotfix while we await review.

Quoted 1 line
Fixes eb02f14c4a2b ("mm/hugetlb: allow overcommitting gigantic hugepages")

It's a good idea to cc the people who were involved in the to-be-fixed patch - Author and Reviewers.

Done!

Quoted 19 lines
Quoted 19 lines

...

mm/hugetlb_cma.c +4 -2
@@ -34,7 +34,10 @@ struct folio *hugetlb_cma_alloc_frozen_folio(int order, gfp_t gfp_mask,
      if (!hugetlb_cma_size)
              return NULL;
 
-     if (hugetlb_cma[nid])
+     if (!nodemask)
+             nodemask = &node_states[N_MEMORY];
+
+     if (hugetlb_cma[nid] && node_isset(nid, *nodemask))
              page = cma_alloc_frozen_compound(hugetlb_cma[nid], order);
 
      if (!page && !(gfp_mask & __GFP_THISNODE)) {
--

2.55.0

#3 lore raw
In reply to Sourav Panda
Quoted 9 lines · Sourav Panda

alloc_buddy_hugetlb_folio_with_mpol() can pass a NULL nodemask to alloc_fresh_hugetlb_folio() as a fallback to allocate from all nodes. If order is gigantic, alloc_fresh_hugetlb_folio() propagates the NULL nodemask down to hugetlb_cma_alloc_frozen_folio() via alloc_gigantic_frozen_folio().

hugetlb_cma_alloc_frozen_folio() blindly dereferences the nodemask in node_isset(nid, *nodemask) and for_each_node_mask(node, *nodemask), leading to a null pointer dereference kernel panic.

node_isset() is being addded here in this change right ? OR was there another path via node_isset() which could have been called on a NULL valued nodemask ? Although subsequent for_each_node_mask() could do the required dereference as mentioned earlier.

Quoted 78 lines

Fix this by checking if nodemask is NULL in hugetlb_cma_alloc_frozen_folio() and defaulting it to node_states[N_MEMORY]. This allows hugetlb_cma allocations to fall back to any node with memory, keeping behavior consistent with alloc_contig_frozen_pages() and alloc_buddy_frozen_folio().

From a userspace perspective, this bug allows an unprivileged user to crash the kernel (trigger a panic) by requesting a gigantic hugepage allocation with MPOL_PREFERRED_MANY on a system where CMA is only configured on a subset of NUMA nodes.

This can be reproduced by booting a VM with two NUMA nodes, restricting CMA to Node 1 (e.g., hugetlb_cma=1:1G default_hugepagesz=1G hugepagesz=1G hugepages=0), and running a program that allocates a 1GB hugepage area without reserving, restricts allocation to Node 0 using mbind() with MPOL_PREFERRED_MANY, and triggers a page fault:

void *ptr = mmap(NULL, 1UL << 30, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB | MAP_HUGE_1GB | MAP_NORESERVE, -1, 0);
unsigned long nodemask = 1; /* Node 0 */ mbind(ptr, 1UL << 30, MPOL_PREFERRED_MANY, &nodemask,

        sizeof(nodemask) * 8, 0);

memset(ptr, 0, 1UL << 30); /* Trigger fault */

This results in a NULL pointer dereference:

  BUG: kernel NULL pointer dereference, address: 0000000000000000
  #PF: supervisor read access in kernel mode
  #PF: error_code(0x0000) - not-present page
  Oops: Oops: 0000 [#1] SMP NOPTI
  RIP: 0010:hugetlb_cma_alloc_frozen_folio+0x75/0x120
  Call Trace:
   <TASK>
   only_alloc_fresh_hugetlb_folio.isra.0+0x2c/0x160
   alloc_surplus_hugetlb_folio+0x6d/0x100
   alloc_hugetlb_folio+0x3c5/0x660
   hugetlb_no_page+0x3d9/0x650
Fixes eb02f14c4a2b ("mm/hugetlb: allow overcommitting gigantic hugepages")

---
Changes in v4:
- Reverted the alloc_fresh_hugetlb_folio() cpuset snapshot approach from v3. As Muchun Song pointed out, snapshotting cpuset_current_mems_allowed does not prevent false-positive allocation failures without complex retry loops, and alloc_contig_frozen_pages() / alloc_buddy_frozen_folio() already handle NULL nodemasks safely internally.
- Handled NULL nodemask directly inside hugetlb_cma_alloc_frozen_folio() by defaulting nodemask to node_states[N_MEMORY] (Option 2), keeping HugeTLB allocators clean and consistent.
- v3: https://lore.kernel.org/linux-mm/[email protected]/
- v2: https://lore.kernel.org/linux-mm/[email protected]/
- v1: https://lore.kernel.org/linux-mm/[email protected]/

 mm/hugetlb_cma.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
mm/hugetlb_cma.c +4 -1
index 39344d6c78d8..5744de0ceeb7 100644
@@ -34,7 +34,10 @@ struct folio *hugetlb_cma_alloc_frozen_folio(int order, gfp_t gfp_mask,
 	if (!hugetlb_cma_size)
 		return NULL;
 
-	if (hugetlb_cma[nid])
+	if (!nodemask)
+		nodemask = &node_states[N_MEMORY];
+
+	if (hugetlb_cma[nid] && node_isset(nid, *nodemask))
 		page = cma_alloc_frozen_compound(hugetlb_cma[nid], order);
 
 	if (!page && !(gfp_mask & __GFP_THISNODE)) {
Signature · 1 line
2.55.0
#4 lore raw
Quoted 8 lines · Anshuman Khandual
Quoted 6 lines · Sourav Panda

alloc_buddy_hugetlb_folio_with_mpol() can pass a NULL nodemask to alloc_fresh_hugetlb_folio() as a fallback to allocate from all nodes. If order is gigantic, alloc_fresh_hugetlb_folio() propagates the NULL nodemask down to hugetlb_cma_alloc_frozen_folio() via alloc_gigantic_frozen_folio().

Quoted 9 lines
Quoted 3 lines

hugetlb_cma_alloc_frozen_folio() blindly dereferences the nodemask in node_isset(nid, *nodemask) and for_each_node_mask(node, *nodemask), leading to a null pointer dereference kernel panic.

node_isset() is being addded here in this change right ? OR was there another path via node_isset() which could have been called on a NULL valued nodemask ? Although subsequent for_each_node_mask() could do the required dereference as mentioned earlier.

Thanks for the review, Anshuman!

Sashiko [1] suggested adding node_isset(nid, *nodemask) in v1 because without it, hugetlb_cma_alloc_frozen_folio() could allocate from a node without checking whether it is actually allowed by the caller's memory policy / nodemask.

Once we added that check, both node_isset(nid, *nodemask) and for_each_node_mask(node, *nodemask) became potential NULL pointer dereferences when nodemask is NULL.

[1] https://sashiko.dev/#/patchset/[email protected]

Thanks!
Sourav

Quoted 78 lines
Quoted 78 lines

Fix this by checking if nodemask is NULL in hugetlb_cma_alloc_frozen_folio() and defaulting it to node_states[N_MEMORY]. This allows hugetlb_cma allocations to fall back to any node with memory, keeping behavior consistent with alloc_contig_frozen_pages() and alloc_buddy_frozen_folio().

From a userspace perspective, this bug allows an unprivileged user to crash the kernel (trigger a panic) by requesting a gigantic hugepage allocation with MPOL_PREFERRED_MANY on a system where CMA is only configured on a subset of NUMA nodes.

This can be reproduced by booting a VM with two NUMA nodes, restricting CMA to Node 1 (e.g., hugetlb_cma=1:1G default_hugepagesz=1G hugepagesz=1G hugepages=0), and running a program that allocates a 1GB hugepage area without reserving, restricts allocation to Node 0 using mbind() with MPOL_PREFERRED_MANY, and triggers a page fault:

void *ptr = mmap(NULL, 1UL << 30, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB | MAP_HUGE_1GB | MAP_NORESERVE, -1, 0);
unsigned long nodemask = 1; /* Node 0 */ mbind(ptr, 1UL << 30, MPOL_PREFERRED_MANY, &nodemask,

        sizeof(nodemask) * 8, 0);

memset(ptr, 0, 1UL << 30); /* Trigger fault */

This results in a NULL pointer dereference:

  BUG: kernel NULL pointer dereference, address: 0000000000000000
  #PF: supervisor read access in kernel mode
  #PF: error_code(0x0000) - not-present page
  Oops: Oops: 0000 [#1] SMP NOPTI
  RIP: 0010:hugetlb_cma_alloc_frozen_folio+0x75/0x120
  Call Trace:
   <TASK>
   only_alloc_fresh_hugetlb_folio.isra.0+0x2c/0x160
   alloc_surplus_hugetlb_folio+0x6d/0x100
   alloc_hugetlb_folio+0x3c5/0x660
   hugetlb_no_page+0x3d9/0x650
Fixes eb02f14c4a2b ("mm/hugetlb: allow overcommitting gigantic hugepages")

---
Changes in v4:
- Reverted the alloc_fresh_hugetlb_folio() cpuset snapshot approach from v3. As Muchun Song pointed out, snapshotting cpuset_current_mems_allowed does not prevent false-positive allocation failures without complex retry loops, and alloc_contig_frozen_pages() / alloc_buddy_frozen_folio() already handle NULL nodemasks safely internally.
- Handled NULL nodemask directly inside hugetlb_cma_alloc_frozen_folio() by defaulting nodemask to node_states[N_MEMORY] (Option 2), keeping HugeTLB allocators clean and consistent.
- v3: https://lore.kernel.org/linux-mm/[email protected]/
- v2: https://lore.kernel.org/linux-mm/[email protected]/
- v1: https://lore.kernel.org/linux-mm/[email protected]/

 mm/hugetlb_cma.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
mm/hugetlb_cma.c +4 -2
index 39344d6c78d8..5744de0ceeb7 100644
@@ -34,7 +34,10 @@ struct folio *hugetlb_cma_alloc_frozen_folio(int order, gfp_t gfp_mask,
      if (!hugetlb_cma_size)
              return NULL;
 
-     if (hugetlb_cma[nid])
+     if (!nodemask)
+             nodemask = &node_states[N_MEMORY];
+
+     if (hugetlb_cma[nid] && node_isset(nid, *nodemask))
              page = cma_alloc_frozen_compound(hugetlb_cma[nid], order);
 
      if (!page && !(gfp_mask & __GFP_THISNODE)) {
--

2.55.0

#5 lore raw
Quoted 20 lines · Sourav Panda
Quoted 8 lines · Anshuman Khandual
Quoted 6 lines · Sourav Panda

alloc_buddy_hugetlb_folio_with_mpol() can pass a NULL nodemask to alloc_fresh_hugetlb_folio() as a fallback to allocate from all nodes. If order is gigantic, alloc_fresh_hugetlb_folio() propagates the NULL nodemask down to hugetlb_cma_alloc_frozen_folio() via alloc_gigantic_frozen_folio().

Quoted 9 lines
Quoted 3 lines

hugetlb_cma_alloc_frozen_folio() blindly dereferences the nodemask in node_isset(nid, *nodemask) and for_each_node_mask(node, *nodemask), leading to a null pointer dereference kernel panic.

node_isset() is being addded here in this change right ? OR was there another path via node_isset() which could have been called on a NULL valued nodemask ? Although subsequent for_each_node_mask() could do the required dereference as mentioned earlier.

Quoted 6 lines

Thanks for the review, Anshuman!

Sashiko [1] suggested adding node_isset(nid, *nodemask) in v1 because without it, hugetlb_cma_alloc_frozen_folio() could allocate from a node without checking whether it is actually allowed by the caller's memory policy / nodemask.

Fair enough.

Quoted 4 lines

Once we added that check, both node_isset(nid, *nodemask) and for_each_node_mask(node, *nodemask) became potential NULL pointer dereferences when nodemask is NULL.

Got it, thanks !

Quoted 85 lines

[1] https://sashiko.dev/#/patchset/[email protected]

Thanks!
Sourav

Quoted 78 lines
Quoted 78 lines

Fix this by checking if nodemask is NULL in hugetlb_cma_alloc_frozen_folio() and defaulting it to node_states[N_MEMORY]. This allows hugetlb_cma allocations to fall back to any node with memory, keeping behavior consistent with alloc_contig_frozen_pages() and alloc_buddy_frozen_folio().

From a userspace perspective, this bug allows an unprivileged user to crash the kernel (trigger a panic) by requesting a gigantic hugepage allocation with MPOL_PREFERRED_MANY on a system where CMA is only configured on a subset of NUMA nodes.

This can be reproduced by booting a VM with two NUMA nodes, restricting CMA to Node 1 (e.g., hugetlb_cma=1:1G default_hugepagesz=1G hugepagesz=1G hugepages=0), and running a program that allocates a 1GB hugepage area without reserving, restricts allocation to Node 0 using mbind() with MPOL_PREFERRED_MANY, and triggers a page fault:

void *ptr = mmap(NULL, 1UL << 30, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB | MAP_HUGE_1GB | MAP_NORESERVE, -1, 0);
unsigned long nodemask = 1; /* Node 0 */ mbind(ptr, 1UL << 30, MPOL_PREFERRED_MANY, &nodemask,

        sizeof(nodemask) * 8, 0);

memset(ptr, 0, 1UL << 30); /* Trigger fault */

This results in a NULL pointer dereference:

  BUG: kernel NULL pointer dereference, address: 0000000000000000
  #PF: supervisor read access in kernel mode
  #PF: error_code(0x0000) - not-present page
  Oops: Oops: 0000 [#1] SMP NOPTI
  RIP: 0010:hugetlb_cma_alloc_frozen_folio+0x75/0x120
  Call Trace:
   <TASK>
   only_alloc_fresh_hugetlb_folio.isra.0+0x2c/0x160
   alloc_surplus_hugetlb_folio+0x6d/0x100
   alloc_hugetlb_folio+0x3c5/0x660
   hugetlb_no_page+0x3d9/0x650
Fixes eb02f14c4a2b ("mm/hugetlb: allow overcommitting gigantic hugepages")

---
Changes in v4:
- Reverted the alloc_fresh_hugetlb_folio() cpuset snapshot approach from v3. As Muchun Song pointed out, snapshotting cpuset_current_mems_allowed does not prevent false-positive allocation failures without complex retry loops, and alloc_contig_frozen_pages() / alloc_buddy_frozen_folio() already handle NULL nodemasks safely internally.
- Handled NULL nodemask directly inside hugetlb_cma_alloc_frozen_folio() by defaulting nodemask to node_states[N_MEMORY] (Option 2), keeping HugeTLB allocators clean and consistent.
- v3: https://lore.kernel.org/linux-mm/[email protected]/
- v2: https://lore.kernel.org/linux-mm/[email protected]/
- v1: https://lore.kernel.org/linux-mm/[email protected]/

 mm/hugetlb_cma.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
mm/hugetlb_cma.c +4 -2
index 39344d6c78d8..5744de0ceeb7 100644
@@ -34,7 +34,10 @@ struct folio *hugetlb_cma_alloc_frozen_folio(int order, gfp_t gfp_mask,
      if (!hugetlb_cma_size)
              return NULL;
 
-     if (hugetlb_cma[nid])
+     if (!nodemask)
+             nodemask = &node_states[N_MEMORY];
+
+     if (hugetlb_cma[nid] && node_isset(nid, *nodemask))
              page = cma_alloc_frozen_compound(hugetlb_cma[nid], order);
 
      if (!page && !(gfp_mask & __GFP_THISNODE)) {
--

2.55.0

#6 lore raw
In reply to Sourav Panda
Quoted 74 lines · On Sun, 26 Jul 2026 07:29:34 +0000 Sourav Panda <[email protected]> wrote:

alloc_buddy_hugetlb_folio_with_mpol() can pass a NULL nodemask to alloc_fresh_hugetlb_folio() as a fallback to allocate from all nodes. If order is gigantic, alloc_fresh_hugetlb_folio() propagates the NULL nodemask down to hugetlb_cma_alloc_frozen_folio() via alloc_gigantic_frozen_folio().

hugetlb_cma_alloc_frozen_folio() blindly dereferences the nodemask in node_isset(nid, *nodemask) and for_each_node_mask(node, *nodemask), leading to a null pointer dereference kernel panic.

Fix this by checking if nodemask is NULL in hugetlb_cma_alloc_frozen_folio() and defaulting it to node_states[N_MEMORY]. This allows hugetlb_cma allocations to fall back to any node with memory, keeping behavior consistent with alloc_contig_frozen_pages() and alloc_buddy_frozen_folio().

Quoted 1 line

From a userspace perspective, this bug allows an unprivileged user to

crash the kernel (trigger a panic) by requesting a gigantic hugepage allocation with MPOL_PREFERRED_MANY on a system where CMA is only configured on a subset of NUMA nodes.

This can be reproduced by booting a VM with two NUMA nodes, restricting CMA to Node 1 (e.g., hugetlb_cma=1:1G default_hugepagesz=1G hugepagesz=1G hugepages=0), and running a program that allocates a 1GB hugepage area without reserving, restricts allocation to Node 0 using mbind() with MPOL_PREFERRED_MANY, and triggers a page fault:

void *ptr = mmap(NULL, 1UL << 30, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB | MAP_HUGE_1GB | MAP_NORESERVE, -1, 0);
unsigned long nodemask = 1; /* Node 0 */ mbind(ptr, 1UL << 30, MPOL_PREFERRED_MANY, &nodemask,

        sizeof(nodemask) * 8, 0);

memset(ptr, 0, 1UL << 30); /* Trigger fault */

This results in a NULL pointer dereference:

  BUG: kernel NULL pointer dereference, address: 0000000000000000
  #PF: supervisor read access in kernel mode
  #PF: error_code(0x0000) - not-present page
  Oops: Oops: 0000 [#1] SMP NOPTI
  RIP: 0010:hugetlb_cma_alloc_frozen_folio+0x75/0x120
  Call Trace:
   <TASK>
   only_alloc_fresh_hugetlb_folio.isra.0+0x2c/0x160
   alloc_surplus_hugetlb_folio+0x6d/0x100
   alloc_hugetlb_folio+0x3c5/0x660
   hugetlb_no_page+0x3d9/0x650
Fixes eb02f14c4a2b ("mm/hugetlb: allow overcommitting gigantic hugepages")

---
Changes in v4:
- Reverted the alloc_fresh_hugetlb_folio() cpuset snapshot approach from v3. As Muchun Song pointed out, snapshotting cpuset_current_mems_allowed does not prevent false-positive allocation failures without complex retry loops, and alloc_contig_frozen_pages() / alloc_buddy_frozen_folio() already handle NULL nodemasks safely internally.
- Handled NULL nodemask directly inside hugetlb_cma_alloc_frozen_folio() by defaulting nodemask to node_states[N_MEMORY] (Option 2), keeping HugeTLB allocators clean and consistent.
- v3: https://lore.kernel.org/linux-mm/[email protected]/
- v2: https://lore.kernel.org/linux-mm/[email protected]/
- v1: https://lore.kernel.org/linux-mm/[email protected]/

 mm/hugetlb_cma.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
mm/hugetlb_cma.c +0 -0
index 39344d6c78d8..5744de0ceeb7 100644

mm/hugetlb_cma.c struct folio *hugetlb_cma_alloc_frozen_folio(int order, gfp_t gfp_mask, · line 38

Quoted 6 lines
mm/hugetlb_cma.c +2 -1
@@ -34,7 +34,10 @@ struct folio *hugetlb_cma_alloc_frozen_folio(int order, gfp_t gfp_mask,
 	if (!hugetlb_cma_size)
 		return NULL;
 
-	if (hugetlb_cma[nid])
+	if (!nodemask)
+		nodemask = &node_states[N_MEMORY];

Hi Sourav,

hmm what if cpuset.mems only allows allocation from node 0, and hugetlb CMA is only available on node 1. This will no now allow allocating a gigantic page on node 1 when its explicitly not allowed?

Would it not be better to check cpuset as well?

Thanks,
Usama

Quoted 8 lines
mm/hugetlb_cma.c +2 -0
+
+	if (hugetlb_cma[nid] && node_isset(nid, *nodemask))
 		page = cma_alloc_frozen_compound(hugetlb_cma[nid], order);
 
 	if (!page && !(gfp_mask & __GFP_THISNODE)) {
Signature · 1 line
2.55.0
#7 lore raw
Quoted 86 lines · Usama Arif
Quoted 74 lines · On Sun, 26 Jul 2026 07:29:34 +0000 Sourav Panda <[email protected]> wrote:

alloc_buddy_hugetlb_folio_with_mpol() can pass a NULL nodemask to alloc_fresh_hugetlb_folio() as a fallback to allocate from all nodes. If order is gigantic, alloc_fresh_hugetlb_folio() propagates the NULL nodemask down to hugetlb_cma_alloc_frozen_folio() via alloc_gigantic_frozen_folio().

hugetlb_cma_alloc_frozen_folio() blindly dereferences the nodemask in node_isset(nid, *nodemask) and for_each_node_mask(node, *nodemask), leading to a null pointer dereference kernel panic.

Fix this by checking if nodemask is NULL in hugetlb_cma_alloc_frozen_folio() and defaulting it to node_states[N_MEMORY]. This allows hugetlb_cma allocations to fall back to any node with memory, keeping behavior consistent with alloc_contig_frozen_pages() and alloc_buddy_frozen_folio().

Quoted 1 line

From a userspace perspective, this bug allows an unprivileged user to

crash the kernel (trigger a panic) by requesting a gigantic hugepage allocation with MPOL_PREFERRED_MANY on a system where CMA is only configured on a subset of NUMA nodes.

This can be reproduced by booting a VM with two NUMA nodes, restricting CMA to Node 1 (e.g., hugetlb_cma=1:1G default_hugepagesz=1G hugepagesz=1G hugepages=0), and running a program that allocates a 1GB hugepage area without reserving, restricts allocation to Node 0 using mbind() with MPOL_PREFERRED_MANY, and triggers a page fault:

void *ptr = mmap(NULL, 1UL << 30, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB | MAP_HUGE_1GB | MAP_NORESERVE, -1, 0);
unsigned long nodemask = 1; /* Node 0 */ mbind(ptr, 1UL << 30, MPOL_PREFERRED_MANY, &nodemask,

        sizeof(nodemask) * 8, 0);

memset(ptr, 0, 1UL << 30); /* Trigger fault */

This results in a NULL pointer dereference:

  BUG: kernel NULL pointer dereference, address: 0000000000000000
  #PF: supervisor read access in kernel mode
  #PF: error_code(0x0000) - not-present page
  Oops: Oops: 0000 [#1] SMP NOPTI
  RIP: 0010:hugetlb_cma_alloc_frozen_folio+0x75/0x120
  Call Trace:
   <TASK>
   only_alloc_fresh_hugetlb_folio.isra.0+0x2c/0x160
   alloc_surplus_hugetlb_folio+0x6d/0x100
   alloc_hugetlb_folio+0x3c5/0x660
   hugetlb_no_page+0x3d9/0x650
Fixes eb02f14c4a2b ("mm/hugetlb: allow overcommitting gigantic hugepages")

---
Changes in v4:
- Reverted the alloc_fresh_hugetlb_folio() cpuset snapshot approach from v3. As Muchun Song pointed out, snapshotting cpuset_current_mems_allowed does not prevent false-positive allocation failures without complex retry loops, and alloc_contig_frozen_pages() / alloc_buddy_frozen_folio() already handle NULL nodemasks safely internally.
- Handled NULL nodemask directly inside hugetlb_cma_alloc_frozen_folio() by defaulting nodemask to node_states[N_MEMORY] (Option 2), keeping HugeTLB allocators clean and consistent.
- v3: https://lore.kernel.org/linux-mm/[email protected]/
- v2: https://lore.kernel.org/linux-mm/[email protected]/
- v1: https://lore.kernel.org/linux-mm/[email protected]/

 mm/hugetlb_cma.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
mm/hugetlb_cma.c +0 -0
index 39344d6c78d8..5744de0ceeb7 100644

mm/hugetlb_cma.c struct folio *hugetlb_cma_alloc_frozen_folio(int order, gfp_t gfp_mask, · line 38

Quoted 6 lines
mm/hugetlb_cma.c +2 -1
@@ -34,7 +34,10 @@ struct folio *hugetlb_cma_alloc_frozen_folio(int order, gfp_t gfp_mask,
      if (!hugetlb_cma_size)
              return NULL;
 
-     if (hugetlb_cma[nid])
+     if (!nodemask)
+             nodemask = &node_states[N_MEMORY];

Hi Sourav,

Quoted 9 lines

hmm what if cpuset.mems only allows allocation from node 0, and hugetlb CMA is only available on node 1. This will no now allow allocating a gigantic page on node 1 when its explicitly not allowed?

Would it not be better to check cpuset as well?

Thanks,
Usama

Hi Usama,

In v2 and v3 of this patch series, we actually used &cpuset_current_mems_allowed (adding a seqcount retry loop in v3 to safely read it without torn reads). However, during the v3 review, concerns about using cpuset_current_mems_allowed, noting potential false-positive allocation issues.

- v3: https://lore.kernel.org/linux-mm/[email protected]/
- v2: https://lore.kernel.org/linux-mm/[email protected]/
- v1: https://lore.kernel.org/linux-mm/[email protected]/

Let me know if you prefer I add it back!

Thanks!
Sourav

Quoted 8 lines
Quoted 8 lines
mm/hugetlb_cma.c +2 -1
+
+     if (hugetlb_cma[nid] && node_isset(nid, *nodemask))
              page = cma_alloc_frozen_compound(hugetlb_cma[nid], order);
 
      if (!page && !(gfp_mask & __GFP_THISNODE)) {
--

2.55.0

#8 lore raw
In reply to Usama Arif
Quoted 85 lines · Usama Arif
Quoted 74 lines · On Sun, 26 Jul 2026 07:29:34 +0000 Sourav Panda <[email protected]> wrote:

alloc_buddy_hugetlb_folio_with_mpol() can pass a NULL nodemask to alloc_fresh_hugetlb_folio() as a fallback to allocate from all nodes. If order is gigantic, alloc_fresh_hugetlb_folio() propagates the NULL nodemask down to hugetlb_cma_alloc_frozen_folio() via alloc_gigantic_frozen_folio().

hugetlb_cma_alloc_frozen_folio() blindly dereferences the nodemask in node_isset(nid, *nodemask) and for_each_node_mask(node, *nodemask), leading to a null pointer dereference kernel panic.

Fix this by checking if nodemask is NULL in hugetlb_cma_alloc_frozen_folio() and defaulting it to node_states[N_MEMORY]. This allows hugetlb_cma allocations to fall back to any node with memory, keeping behavior consistent with alloc_contig_frozen_pages() and alloc_buddy_frozen_folio().

Quoted 1 line

From a userspace perspective, this bug allows an unprivileged user to

crash the kernel (trigger a panic) by requesting a gigantic hugepage allocation with MPOL_PREFERRED_MANY on a system where CMA is only configured on a subset of NUMA nodes.

This can be reproduced by booting a VM with two NUMA nodes, restricting CMA to Node 1 (e.g., hugetlb_cma=1:1G default_hugepagesz=1G hugepagesz=1G hugepages=0), and running a program that allocates a 1GB hugepage area without reserving, restricts allocation to Node 0 using mbind() with MPOL_PREFERRED_MANY, and triggers a page fault:

void *ptr = mmap(NULL, 1UL << 30, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB | MAP_HUGE_1GB | MAP_NORESERVE, -1, 0);
unsigned long nodemask = 1; /* Node 0 */ mbind(ptr, 1UL << 30, MPOL_PREFERRED_MANY, &nodemask,

        sizeof(nodemask) * 8, 0);

memset(ptr, 0, 1UL << 30); /* Trigger fault */

This results in a NULL pointer dereference:

  BUG: kernel NULL pointer dereference, address: 0000000000000000
  #PF: supervisor read access in kernel mode
  #PF: error_code(0x0000) - not-present page
  Oops: Oops: 0000 [#1] SMP NOPTI
  RIP: 0010:hugetlb_cma_alloc_frozen_folio+0x75/0x120
  Call Trace:
   <TASK>
   only_alloc_fresh_hugetlb_folio.isra.0+0x2c/0x160
   alloc_surplus_hugetlb_folio+0x6d/0x100
   alloc_hugetlb_folio+0x3c5/0x660
   hugetlb_no_page+0x3d9/0x650
Fixes eb02f14c4a2b ("mm/hugetlb: allow overcommitting gigantic hugepages")

---
Changes in v4:
- Reverted the alloc_fresh_hugetlb_folio() cpuset snapshot approach from v3. As Muchun Song pointed out, snapshotting cpuset_current_mems_allowed does not prevent false-positive allocation failures without complex retry loops, and alloc_contig_frozen_pages() / alloc_buddy_frozen_folio() already handle NULL nodemasks safely internally.
- Handled NULL nodemask directly inside hugetlb_cma_alloc_frozen_folio() by defaulting nodemask to node_states[N_MEMORY] (Option 2), keeping HugeTLB allocators clean and consistent.
- v3: https://lore.kernel.org/linux-mm/[email protected]/
- v2: https://lore.kernel.org/linux-mm/[email protected]/
- v1: https://lore.kernel.org/linux-mm/[email protected]/

 mm/hugetlb_cma.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
mm/hugetlb_cma.c +0 -0
index 39344d6c78d8..5744de0ceeb7 100644

mm/hugetlb_cma.c struct folio *hugetlb_cma_alloc_frozen_folio(int order, gfp_t gfp_mask, · line 38

Quoted 6 lines
mm/hugetlb_cma.c +2 -1
@@ -34,7 +34,10 @@ struct folio *hugetlb_cma_alloc_frozen_folio(int order, gfp_t gfp_mask,
 	if (!hugetlb_cma_size)
 		return NULL;
 
-	if (hugetlb_cma[nid])
+	if (!nodemask)
+		nodemask = &node_states[N_MEMORY];

Hi Sourav,

Quoted 3 lines

hmm what if cpuset.mems only allows allocation from node 0, and hugetlb CMA is only available on node 1. This will no now allow allocating a gigantic page on node 1 when its explicitly not allowed?

That's fair point but should not the user be also responsible in provding a right nodemask containing CMA memory if it prefers avoiding node_states[N_MEMORY] based fallback mechanism in kernel ?

Quoted 14 lines

Would it not be better to check cpuset as well?

Thanks,
Usama

Quoted 8 lines
mm/hugetlb_cma.c +2 -0
+
+	if (hugetlb_cma[nid] && node_isset(nid, *nodemask))
 		page = cma_alloc_frozen_compound(hugetlb_cma[nid], order);
 
 	if (!page && !(gfp_mask & __GFP_THISNODE)) {
Signature · 1 line
2.55.0
#9 lore raw
Quoted 87 lines · Anshuman Khandual
Quoted 85 lines · Usama Arif
Quoted 74 lines · On Sun, 26 Jul 2026 07:29:34 +0000 Sourav Panda <[email protected]> wrote:

alloc_buddy_hugetlb_folio_with_mpol() can pass a NULL nodemask to alloc_fresh_hugetlb_folio() as a fallback to allocate from all nodes. If order is gigantic, alloc_fresh_hugetlb_folio() propagates the NULL nodemask down to hugetlb_cma_alloc_frozen_folio() via alloc_gigantic_frozen_folio().

hugetlb_cma_alloc_frozen_folio() blindly dereferences the nodemask in node_isset(nid, *nodemask) and for_each_node_mask(node, *nodemask), leading to a null pointer dereference kernel panic.

Fix this by checking if nodemask is NULL in hugetlb_cma_alloc_frozen_folio() and defaulting it to node_states[N_MEMORY]. This allows hugetlb_cma allocations to fall back to any node with memory, keeping behavior consistent with alloc_contig_frozen_pages() and alloc_buddy_frozen_folio().

Quoted 1 line

From a userspace perspective, this bug allows an unprivileged user to

crash the kernel (trigger a panic) by requesting a gigantic hugepage allocation with MPOL_PREFERRED_MANY on a system where CMA is only configured on a subset of NUMA nodes.

This can be reproduced by booting a VM with two NUMA nodes, restricting CMA to Node 1 (e.g., hugetlb_cma=1:1G default_hugepagesz=1G hugepagesz=1G hugepages=0), and running a program that allocates a 1GB hugepage area without reserving, restricts allocation to Node 0 using mbind() with MPOL_PREFERRED_MANY, and triggers a page fault:

void *ptr = mmap(NULL, 1UL << 30, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB | MAP_HUGE_1GB | MAP_NORESERVE, -1, 0);
unsigned long nodemask = 1; /* Node 0 */ mbind(ptr, 1UL << 30, MPOL_PREFERRED_MANY, &nodemask,

        sizeof(nodemask) * 8, 0);

memset(ptr, 0, 1UL << 30); /* Trigger fault */

This results in a NULL pointer dereference:

  BUG: kernel NULL pointer dereference, address: 0000000000000000
  #PF: supervisor read access in kernel mode
  #PF: error_code(0x0000) - not-present page
  Oops: Oops: 0000 [#1] SMP NOPTI
  RIP: 0010:hugetlb_cma_alloc_frozen_folio+0x75/0x120
  Call Trace:
   <TASK>
   only_alloc_fresh_hugetlb_folio.isra.0+0x2c/0x160
   alloc_surplus_hugetlb_folio+0x6d/0x100
   alloc_hugetlb_folio+0x3c5/0x660
   hugetlb_no_page+0x3d9/0x650
Fixes eb02f14c4a2b ("mm/hugetlb: allow overcommitting gigantic hugepages")

---
Changes in v4:
- Reverted the alloc_fresh_hugetlb_folio() cpuset snapshot approach from v3. As Muchun Song pointed out, snapshotting cpuset_current_mems_allowed does not prevent false-positive allocation failures without complex retry loops, and alloc_contig_frozen_pages() / alloc_buddy_frozen_folio() already handle NULL nodemasks safely internally.
- Handled NULL nodemask directly inside hugetlb_cma_alloc_frozen_folio() by defaulting nodemask to node_states[N_MEMORY] (Option 2), keeping HugeTLB allocators clean and consistent.
- v3: https://lore.kernel.org/linux-mm/[email protected]/
- v2: https://lore.kernel.org/linux-mm/[email protected]/
- v1: https://lore.kernel.org/linux-mm/[email protected]/

 mm/hugetlb_cma.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
mm/hugetlb_cma.c +0 -0
index 39344d6c78d8..5744de0ceeb7 100644

mm/hugetlb_cma.c struct folio *hugetlb_cma_alloc_frozen_folio(int order, gfp_t gfp_mask, · line 38

Quoted 6 lines
mm/hugetlb_cma.c +2 -1
@@ -34,7 +34,10 @@ struct folio *hugetlb_cma_alloc_frozen_folio(int order, gfp_t gfp_mask,
    if (!hugetlb_cma_size)
            return NULL;
 
-   if (hugetlb_cma[nid])
+   if (!nodemask)
+           nodemask = &node_states[N_MEMORY];

Hi Sourav,

Quoted 8 lines
Quoted 3 lines

hmm what if cpuset.mems only allows allocation from node 0, and hugetlb CMA is only available on node 1. This will no now allow allocating a gigantic page on node 1 when its explicitly not allowed?

That's fair point but should not the user be also responsible in provding a right nodemask containing CMA memory if it prefers avoiding node_states[N_MEMORY] based fallback mechanism in kernel ?

We have precedence for three options, which makes selecting one difficult :)

1) nodemask = &cpuset_current_mems_allowed is currently being used in:

       only_alloc_fresh_hugetlb_folio --> alloc_buddy_frozen_folio -->

__alloc_frozen_pages_noprof --> prepare_alloc_pages.
2) Some places use cookies with cpuset_current_mems_allowed to prevent torn writes. But this adds complexity.
An example would be dequeue_hugetlb_folio_nodemask()
3) node_states[N_MEMORY] is sprinkled all over the kernel (simplest).

Quoted 14 lines
Quoted 14 lines

Would it not be better to check cpuset as well?

Thanks,
Usama

Quoted 8 lines
mm/hugetlb_cma.c +2 -1
+
+   if (hugetlb_cma[nid] && node_isset(nid, *nodemask))
            page = cma_alloc_frozen_compound(hugetlb_cma[nid], order);
 
    if (!page && !(gfp_mask & __GFP_THISNODE)) {
--

2.55.0

#10 lore raw
Quoted 89 lines · Sourav Panda
Quoted 87 lines · Anshuman Khandual
Quoted 85 lines · Usama Arif
Quoted 74 lines · On Sun, 26 Jul 2026 07:29:34 +0000 Sourav Panda <[email protected]> wrote:

alloc_buddy_hugetlb_folio_with_mpol() can pass a NULL nodemask to alloc_fresh_hugetlb_folio() as a fallback to allocate from all nodes. If order is gigantic, alloc_fresh_hugetlb_folio() propagates the NULL nodemask down to hugetlb_cma_alloc_frozen_folio() via alloc_gigantic_frozen_folio().

hugetlb_cma_alloc_frozen_folio() blindly dereferences the nodemask in node_isset(nid, *nodemask) and for_each_node_mask(node, *nodemask), leading to a null pointer dereference kernel panic.

Fix this by checking if nodemask is NULL in hugetlb_cma_alloc_frozen_folio() and defaulting it to node_states[N_MEMORY]. This allows hugetlb_cma allocations to fall back to any node with memory, keeping behavior consistent with alloc_contig_frozen_pages() and alloc_buddy_frozen_folio().

Quoted 1 line

From a userspace perspective, this bug allows an unprivileged user to

crash the kernel (trigger a panic) by requesting a gigantic hugepage allocation with MPOL_PREFERRED_MANY on a system where CMA is only configured on a subset of NUMA nodes.

This can be reproduced by booting a VM with two NUMA nodes, restricting CMA to Node 1 (e.g., hugetlb_cma=1:1G default_hugepagesz=1G hugepagesz=1G hugepages=0), and running a program that allocates a 1GB hugepage area without reserving, restricts allocation to Node 0 using mbind() with MPOL_PREFERRED_MANY, and triggers a page fault:

void *ptr = mmap(NULL, 1UL << 30, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB | MAP_HUGE_1GB | MAP_NORESERVE, -1, 0);
unsigned long nodemask = 1; /* Node 0 */ mbind(ptr, 1UL << 30, MPOL_PREFERRED_MANY, &nodemask,

        sizeof(nodemask) * 8, 0);

memset(ptr, 0, 1UL << 30); /* Trigger fault */

This results in a NULL pointer dereference:

  BUG: kernel NULL pointer dereference, address: 0000000000000000
  #PF: supervisor read access in kernel mode
  #PF: error_code(0x0000) - not-present page
  Oops: Oops: 0000 [#1] SMP NOPTI
  RIP: 0010:hugetlb_cma_alloc_frozen_folio+0x75/0x120
  Call Trace:
   <TASK>
   only_alloc_fresh_hugetlb_folio.isra.0+0x2c/0x160
   alloc_surplus_hugetlb_folio+0x6d/0x100
   alloc_hugetlb_folio+0x3c5/0x660
   hugetlb_no_page+0x3d9/0x650
Fixes eb02f14c4a2b ("mm/hugetlb: allow overcommitting gigantic hugepages")

---
Changes in v4:
- Reverted the alloc_fresh_hugetlb_folio() cpuset snapshot approach from v3. As Muchun Song pointed out, snapshotting cpuset_current_mems_allowed does not prevent false-positive allocation failures without complex retry loops, and alloc_contig_frozen_pages() / alloc_buddy_frozen_folio() already handle NULL nodemasks safely internally.
- Handled NULL nodemask directly inside hugetlb_cma_alloc_frozen_folio() by defaulting nodemask to node_states[N_MEMORY] (Option 2), keeping HugeTLB allocators clean and consistent.
- v3: https://lore.kernel.org/linux-mm/[email protected]/
- v2: https://lore.kernel.org/linux-mm/[email protected]/
- v1: https://lore.kernel.org/linux-mm/[email protected]/

 mm/hugetlb_cma.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
mm/hugetlb_cma.c +0 -0
index 39344d6c78d8..5744de0ceeb7 100644

mm/hugetlb_cma.c struct folio *hugetlb_cma_alloc_frozen_folio(int order, gfp_t gfp_mask, · line 38

Quoted 6 lines
mm/hugetlb_cma.c +2 -1
@@ -34,7 +34,10 @@ struct folio *hugetlb_cma_alloc_frozen_folio(int order, gfp_t gfp_mask,
    if (!hugetlb_cma_size)
            return NULL;
 
-   if (hugetlb_cma[nid])
+   if (!nodemask)
+           nodemask = &node_states[N_MEMORY];

Hi Sourav,

Quoted 8 lines
Quoted 8 lines
Quoted 3 lines

hmm what if cpuset.mems only allows allocation from node 0, and hugetlb CMA is only available on node 1. This will no now allow allocating a gigantic page on node 1 when its explicitly not allowed?

That's fair point but should not the user be also responsible in provding a right nodemask containing CMA memory if it prefers avoiding node_states[N_MEMORY] based fallback mechanism in kernel ?

I don't think the task can be made responsible for providing a CMA-aware fallback mask here. Userspace supplies the MPOL_PREFERRED_MANY preference, but the kernel itself changes the second attempt to a NULL nodemask. That permits fallback outside the preferred policy nodes; it does not permit fallback outside the task's hardwall cpuset.

Quoted 6 lines

We have precedence for three options, which makes selecting one difficult :)

1) nodemask = &cpuset_current_mems_allowed is currently being used in:

       only_alloc_fresh_hugetlb_folio --> alloc_buddy_frozen_folio -->

__alloc_frozen_pages_noprof --> prepare_alloc_pages.

Here I think using &cpuset_current_mems_allowed is part of the page allocator's wider cpuset handling.

Quoted 5 lines

2) Some places use cookies with cpuset_current_mems_allowed to prevent torn writes. But this adds complexity.
An example would be dequeue_hugetlb_folio_nodemask()
3) node_states[N_MEMORY] is sprinkled all over the kernel (simplest).

I would prefer option 2. A NULL mempolicy mask should fall back to cpuset_current_mems_allowed, not all N_MEMORY nodes.

Quoted 14 lines
Quoted 14 lines
Quoted 14 lines

Would it not be better to check cpuset as well?

Thanks,
Usama

Quoted 8 lines
mm/hugetlb_cma.c +2 -1
+
+   if (hugetlb_cma[nid] && node_isset(nid, *nodemask))
            page = cma_alloc_frozen_compound(hugetlb_cma[nid], order);
 
    if (!page && !(gfp_mask & __GFP_THISNODE)) {
--

2.55.0

#11 lore raw
Quoted 116 lines · Usama Arif
Quoted 89 lines · Sourav Panda
Quoted 87 lines · Anshuman Khandual
Quoted 85 lines · Usama Arif
Quoted 74 lines · On Sun, 26 Jul 2026 07:29:34 +0000 Sourav Panda <[email protected]> wrote:

alloc_buddy_hugetlb_folio_with_mpol() can pass a NULL nodemask to alloc_fresh_hugetlb_folio() as a fallback to allocate from all nodes. If order is gigantic, alloc_fresh_hugetlb_folio() propagates the NULL nodemask down to hugetlb_cma_alloc_frozen_folio() via alloc_gigantic_frozen_folio().

hugetlb_cma_alloc_frozen_folio() blindly dereferences the nodemask in node_isset(nid, *nodemask) and for_each_node_mask(node, *nodemask), leading to a null pointer dereference kernel panic.

Fix this by checking if nodemask is NULL in hugetlb_cma_alloc_frozen_folio() and defaulting it to node_states[N_MEMORY]. This allows hugetlb_cma allocations to fall back to any node with memory, keeping behavior consistent with alloc_contig_frozen_pages() and alloc_buddy_frozen_folio().

Quoted 1 line

From a userspace perspective, this bug allows an unprivileged user to

crash the kernel (trigger a panic) by requesting a gigantic hugepage allocation with MPOL_PREFERRED_MANY on a system where CMA is only configured on a subset of NUMA nodes.

This can be reproduced by booting a VM with two NUMA nodes, restricting CMA to Node 1 (e.g., hugetlb_cma=1:1G default_hugepagesz=1G hugepagesz=1G hugepages=0), and running a program that allocates a 1GB hugepage area without reserving, restricts allocation to Node 0 using mbind() with MPOL_PREFERRED_MANY, and triggers a page fault:

void *ptr = mmap(NULL, 1UL << 30, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB | MAP_HUGE_1GB | MAP_NORESERVE, -1, 0);
unsigned long nodemask = 1; /* Node 0 */ mbind(ptr, 1UL << 30, MPOL_PREFERRED_MANY, &nodemask,

        sizeof(nodemask) * 8, 0);

memset(ptr, 0, 1UL << 30); /* Trigger fault */

This results in a NULL pointer dereference:

  BUG: kernel NULL pointer dereference, address: 0000000000000000
  #PF: supervisor read access in kernel mode
  #PF: error_code(0x0000) - not-present page
  Oops: Oops: 0000 [#1] SMP NOPTI
  RIP: 0010:hugetlb_cma_alloc_frozen_folio+0x75/0x120
  Call Trace:
   <TASK>
   only_alloc_fresh_hugetlb_folio.isra.0+0x2c/0x160
   alloc_surplus_hugetlb_folio+0x6d/0x100
   alloc_hugetlb_folio+0x3c5/0x660
   hugetlb_no_page+0x3d9/0x650
Fixes eb02f14c4a2b ("mm/hugetlb: allow overcommitting gigantic hugepages")

---
Changes in v4:
- Reverted the alloc_fresh_hugetlb_folio() cpuset snapshot approach from v3. As Muchun Song pointed out, snapshotting cpuset_current_mems_allowed does not prevent false-positive allocation failures without complex retry loops, and alloc_contig_frozen_pages() / alloc_buddy_frozen_folio() already handle NULL nodemasks safely internally.
- Handled NULL nodemask directly inside hugetlb_cma_alloc_frozen_folio() by defaulting nodemask to node_states[N_MEMORY] (Option 2), keeping HugeTLB allocators clean and consistent.
- v3: https://lore.kernel.org/linux-mm/[email protected]/
- v2: https://lore.kernel.org/linux-mm/[email protected]/
- v1: https://lore.kernel.org/linux-mm/[email protected]/

 mm/hugetlb_cma.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
mm/hugetlb_cma.c +0 -0
index 39344d6c78d8..5744de0ceeb7 100644

mm/hugetlb_cma.c struct folio *hugetlb_cma_alloc_frozen_folio(int order, gfp_t gfp_mask, · line 38

Quoted 6 lines
mm/hugetlb_cma.c +2 -1
@@ -34,7 +34,10 @@ struct folio *hugetlb_cma_alloc_frozen_folio(int order, gfp_t gfp_mask,
    if (!hugetlb_cma_size)
            return NULL;
 
-   if (hugetlb_cma[nid])
+   if (!nodemask)
+           nodemask = &node_states[N_MEMORY];

Hi Sourav,

Quoted 8 lines
Quoted 8 lines
Quoted 3 lines

hmm what if cpuset.mems only allows allocation from node 0, and hugetlb CMA is only available on node 1. This will no now allow allocating a gigantic page on node 1 when its explicitly not allowed?

That's fair point but should not the user be also responsible in provding a right nodemask containing CMA memory if it prefers avoiding node_states[N_MEMORY] based fallback mechanism in kernel ?

I don't think the task can be made responsible for providing a CMA-aware fallback mask here. Userspace supplies the MPOL_PREFERRED_MANY preference, but the kernel itself changes the second attempt to a NULL nodemask. That permits fallback outside the preferred policy nodes; it does not permit fallback outside the task's hardwall cpuset.

Quoted 6 lines

We have precedence for three options, which makes selecting one difficult :)

1) nodemask = &cpuset_current_mems_allowed is currently being used in:

       only_alloc_fresh_hugetlb_folio --> alloc_buddy_frozen_folio -->

__alloc_frozen_pages_noprof --> prepare_alloc_pages.

Here I think using &cpuset_current_mems_allowed is part of the page allocator's wider cpuset handling.

Quoted 9 lines
Quoted 5 lines

2) Some places use cookies with cpuset_current_mems_allowed to prevent torn writes. But this adds complexity.
An example would be dequeue_hugetlb_folio_nodemask()
3) node_states[N_MEMORY] is sprinkled all over the kernel (simplest).

I would prefer option 2. A NULL mempolicy mask should fall back to cpuset_current_mems_allowed, not all N_MEMORY nodes.

Sounds good Usama :)

I will send a patch that replaces nodemask = &node_states[N_MEMORY]; with the below:

+ unsigned int cpuset_mems_cookie;
+
+ do {
+ cpuset_mems_cookie = read_mems_allowed_begin();
+ local_node_mask = cpuset_current_mems_allowed;
+ } while (read_mems_allowed_retry(cpuset_mems_cookie)); +
+ nodemask = &local_node_mask;

Will send it out tomorrow! Let me know if anyone has any objections.

Quoted 16 lines
Quoted 15 lines
Quoted 15 lines
Quoted 15 lines

Would it not be better to check cpuset as well?

Thanks,
Usama

Quoted 8 lines
mm/hugetlb_cma.c +2 -1
+
+   if (hugetlb_cma[nid] && node_isset(nid, *nodemask))
            page = cma_alloc_frozen_compound(hugetlb_cma[nid], order);
 
    if (!page && !(gfp_mask & __GFP_THISNODE)) {
--

2.55.0

#12 lore raw
Quoted 133 lines · Sourav Panda
Quoted 116 lines · Usama Arif
Quoted 89 lines · Sourav Panda
Quoted 87 lines · Anshuman Khandual
Quoted 85 lines · Usama Arif
Quoted 74 lines · On Sun, 26 Jul 2026 07:29:34 +0000 Sourav Panda <[email protected]> wrote:

alloc_buddy_hugetlb_folio_with_mpol() can pass a NULL nodemask to alloc_fresh_hugetlb_folio() as a fallback to allocate from all nodes. If order is gigantic, alloc_fresh_hugetlb_folio() propagates the NULL nodemask down to hugetlb_cma_alloc_frozen_folio() via alloc_gigantic_frozen_folio().

hugetlb_cma_alloc_frozen_folio() blindly dereferences the nodemask in node_isset(nid, *nodemask) and for_each_node_mask(node, *nodemask), leading to a null pointer dereference kernel panic.

Fix this by checking if nodemask is NULL in hugetlb_cma_alloc_frozen_folio() and defaulting it to node_states[N_MEMORY]. This allows hugetlb_cma allocations to fall back to any node with memory, keeping behavior consistent with alloc_contig_frozen_pages() and alloc_buddy_frozen_folio().

Quoted 1 line

From a userspace perspective, this bug allows an unprivileged user to

crash the kernel (trigger a panic) by requesting a gigantic hugepage allocation with MPOL_PREFERRED_MANY on a system where CMA is only configured on a subset of NUMA nodes.

This can be reproduced by booting a VM with two NUMA nodes, restricting CMA to Node 1 (e.g., hugetlb_cma=1:1G default_hugepagesz=1G hugepagesz=1G hugepages=0), and running a program that allocates a 1GB hugepage area without reserving, restricts allocation to Node 0 using mbind() with MPOL_PREFERRED_MANY, and triggers a page fault:

void *ptr = mmap(NULL, 1UL << 30, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB | MAP_HUGE_1GB | MAP_NORESERVE, -1, 0);
unsigned long nodemask = 1; /* Node 0 */ mbind(ptr, 1UL << 30, MPOL_PREFERRED_MANY, &nodemask,

        sizeof(nodemask) * 8, 0);

memset(ptr, 0, 1UL << 30); /* Trigger fault */

This results in a NULL pointer dereference:

  BUG: kernel NULL pointer dereference, address: 0000000000000000
  #PF: supervisor read access in kernel mode
  #PF: error_code(0x0000) - not-present page
  Oops: Oops: 0000 [#1] SMP NOPTI
  RIP: 0010:hugetlb_cma_alloc_frozen_folio+0x75/0x120
  Call Trace:
   <TASK>
   only_alloc_fresh_hugetlb_folio.isra.0+0x2c/0x160
   alloc_surplus_hugetlb_folio+0x6d/0x100
   alloc_hugetlb_folio+0x3c5/0x660
   hugetlb_no_page+0x3d9/0x650
Fixes eb02f14c4a2b ("mm/hugetlb: allow overcommitting gigantic hugepages")

---
Changes in v4:
- Reverted the alloc_fresh_hugetlb_folio() cpuset snapshot approach from v3. As Muchun Song pointed out, snapshotting cpuset_current_mems_allowed does not prevent false-positive allocation failures without complex retry loops, and alloc_contig_frozen_pages() / alloc_buddy_frozen_folio() already handle NULL nodemasks safely internally.
- Handled NULL nodemask directly inside hugetlb_cma_alloc_frozen_folio() by defaulting nodemask to node_states[N_MEMORY] (Option 2), keeping HugeTLB allocators clean and consistent.
- v3: https://lore.kernel.org/linux-mm/[email protected]/
- v2: https://lore.kernel.org/linux-mm/[email protected]/
- v1: https://lore.kernel.org/linux-mm/[email protected]/

 mm/hugetlb_cma.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
mm/hugetlb_cma.c +0 -0
index 39344d6c78d8..5744de0ceeb7 100644

mm/hugetlb_cma.c struct folio *hugetlb_cma_alloc_frozen_folio(int order, gfp_t gfp_mask, · line 38

Quoted 6 lines
mm/hugetlb_cma.c +2 -1
@@ -34,7 +34,10 @@ struct folio *hugetlb_cma_alloc_frozen_folio(int order, gfp_t gfp_mask,
    if (!hugetlb_cma_size)
            return NULL;
 
-   if (hugetlb_cma[nid])
+   if (!nodemask)
+           nodemask = &node_states[N_MEMORY];

Hi Sourav,

Quoted 8 lines
Quoted 8 lines
Quoted 3 lines

hmm what if cpuset.mems only allows allocation from node 0, and hugetlb CMA is only available on node 1. This will no now allow allocating a gigantic page on node 1 when its explicitly not allowed?

That's fair point but should not the user be also responsible in provding a right nodemask containing CMA memory if it prefers avoiding node_states[N_MEMORY] based fallback mechanism in kernel ?

I don't think the task can be made responsible for providing a CMA-aware fallback mask here. Userspace supplies the MPOL_PREFERRED_MANY preference, but the kernel itself changes the second attempt to a NULL nodemask. That permits fallback outside the preferred policy nodes; it does not permit fallback outside the task's hardwall cpuset.

Quoted 6 lines

We have precedence for three options, which makes selecting one difficult :)

1) nodemask = &cpuset_current_mems_allowed is currently being used in:

       only_alloc_fresh_hugetlb_folio --> alloc_buddy_frozen_folio -->

__alloc_frozen_pages_noprof --> prepare_alloc_pages.

Here I think using &cpuset_current_mems_allowed is part of the page allocator's wider cpuset handling.

Quoted 9 lines
Quoted 5 lines

2) Some places use cookies with cpuset_current_mems_allowed to prevent torn writes. But this adds complexity.
An example would be dequeue_hugetlb_folio_nodemask()
3) node_states[N_MEMORY] is sprinkled all over the kernel (simplest).

I would prefer option 2. A NULL mempolicy mask should fall back to cpuset_current_mems_allowed, not all N_MEMORY nodes.

Sounds good Usama :)

I will send a patch that replaces nodemask = &node_states[N_MEMORY]; with the below:

+ unsigned int cpuset_mems_cookie;

Review

Quoted 7 lines
(quoted diff) +7 -0
+
+ do {
+ cpuset_mems_cookie = read_mems_allowed_begin();
+ local_node_mask = cpuset_current_mems_allowed;
+ } while (read_mems_allowed_retry(cpuset_mems_cookie));
+
+ nodemask = &local_node_mask;

Although complexity increases with the above mechanism but probably it might be better in terms of being compliant with task's hardwall cpuset as explained by Usama earlier.

Quoted 2 lines

Will send it out tomorrow! Let me know if anyone has any objections.

I would say let's wait for a day or two before sending the respin.

Quoted 17 lines
Quoted 17 lines
Quoted 16 lines
Quoted 16 lines
Quoted 16 lines

Would it not be better to check cpuset as well?

Thanks,
Usama

Quoted 8 lines
mm/hugetlb_cma.c +2 -1
+
+   if (hugetlb_cma[nid] && node_isset(nid, *nodemask))
            page = cma_alloc_frozen_compound(hugetlb_cma[nid], order);
 
    if (!page && !(gfp_mask & __GFP_THISNODE)) {
--

2.55.0

#13 lore raw
Quoted 148 lines · Anshuman Khandual
Quoted 133 lines · Sourav Panda
Quoted 116 lines · Usama Arif
Quoted 89 lines · Sourav Panda
Quoted 87 lines · Anshuman Khandual
Quoted 85 lines · Usama Arif
Quoted 74 lines · On Sun, 26 Jul 2026 07:29:34 +0000 Sourav Panda <[email protected]> wrote:

alloc_buddy_hugetlb_folio_with_mpol() can pass a NULL nodemask to alloc_fresh_hugetlb_folio() as a fallback to allocate from all nodes. If order is gigantic, alloc_fresh_hugetlb_folio() propagates the NULL nodemask down to hugetlb_cma_alloc_frozen_folio() via alloc_gigantic_frozen_folio().

hugetlb_cma_alloc_frozen_folio() blindly dereferences the nodemask in node_isset(nid, *nodemask) and for_each_node_mask(node, *nodemask), leading to a null pointer dereference kernel panic.

Fix this by checking if nodemask is NULL in hugetlb_cma_alloc_frozen_folio() and defaulting it to node_states[N_MEMORY]. This allows hugetlb_cma allocations to fall back to any node with memory, keeping behavior consistent with alloc_contig_frozen_pages() and alloc_buddy_frozen_folio().

Quoted 1 line

From a userspace perspective, this bug allows an unprivileged user to

crash the kernel (trigger a panic) by requesting a gigantic hugepage allocation with MPOL_PREFERRED_MANY on a system where CMA is only configured on a subset of NUMA nodes.

This can be reproduced by booting a VM with two NUMA nodes, restricting CMA to Node 1 (e.g., hugetlb_cma=1:1G default_hugepagesz=1G hugepagesz=1G hugepages=0), and running a program that allocates a 1GB hugepage area without reserving, restricts allocation to Node 0 using mbind() with MPOL_PREFERRED_MANY, and triggers a page fault:

void *ptr = mmap(NULL, 1UL << 30, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB | MAP_HUGE_1GB | MAP_NORESERVE, -1, 0);
unsigned long nodemask = 1; /* Node 0 */ mbind(ptr, 1UL << 30, MPOL_PREFERRED_MANY, &nodemask,

        sizeof(nodemask) * 8, 0);

memset(ptr, 0, 1UL << 30); /* Trigger fault */

This results in a NULL pointer dereference:

  BUG: kernel NULL pointer dereference, address: 0000000000000000
  #PF: supervisor read access in kernel mode
  #PF: error_code(0x0000) - not-present page
  Oops: Oops: 0000 [#1] SMP NOPTI
  RIP: 0010:hugetlb_cma_alloc_frozen_folio+0x75/0x120
  Call Trace:
   <TASK>
   only_alloc_fresh_hugetlb_folio.isra.0+0x2c/0x160
   alloc_surplus_hugetlb_folio+0x6d/0x100
   alloc_hugetlb_folio+0x3c5/0x660
   hugetlb_no_page+0x3d9/0x650
Fixes eb02f14c4a2b ("mm/hugetlb: allow overcommitting gigantic hugepages")

---
Changes in v4:
- Reverted the alloc_fresh_hugetlb_folio() cpuset snapshot approach from v3. As Muchun Song pointed out, snapshotting cpuset_current_mems_allowed does not prevent false-positive allocation failures without complex retry loops, and alloc_contig_frozen_pages() / alloc_buddy_frozen_folio() already handle NULL nodemasks safely internally.
- Handled NULL nodemask directly inside hugetlb_cma_alloc_frozen_folio() by defaulting nodemask to node_states[N_MEMORY] (Option 2), keeping HugeTLB allocators clean and consistent.
- v3: https://lore.kernel.org/linux-mm/[email protected]/
- v2: https://lore.kernel.org/linux-mm/[email protected]/
- v1: https://lore.kernel.org/linux-mm/[email protected]/

 mm/hugetlb_cma.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
mm/hugetlb_cma.c +0 -0
index 39344d6c78d8..5744de0ceeb7 100644

mm/hugetlb_cma.c struct folio *hugetlb_cma_alloc_frozen_folio(int order, gfp_t gfp_mask, · line 38

Quoted 6 lines
mm/hugetlb_cma.c +2 -1
@@ -34,7 +34,10 @@ struct folio *hugetlb_cma_alloc_frozen_folio(int order, gfp_t gfp_mask,
    if (!hugetlb_cma_size)
            return NULL;
 
-   if (hugetlb_cma[nid])
+   if (!nodemask)
+           nodemask = &node_states[N_MEMORY];

Hi Sourav,

Quoted 8 lines
Quoted 8 lines
Quoted 3 lines

hmm what if cpuset.mems only allows allocation from node 0, and hugetlb CMA is only available on node 1. This will no now allow allocating a gigantic page on node 1 when its explicitly not allowed?

That's fair point but should not the user be also responsible in provding a right nodemask containing CMA memory if it prefers avoiding node_states[N_MEMORY] based fallback mechanism in kernel ?

I don't think the task can be made responsible for providing a CMA-aware fallback mask here. Userspace supplies the MPOL_PREFERRED_MANY preference, but the kernel itself changes the second attempt to a NULL nodemask. That permits fallback outside the preferred policy nodes; it does not permit fallback outside the task's hardwall cpuset.

Quoted 6 lines

We have precedence for three options, which makes selecting one difficult :)

1) nodemask = &cpuset_current_mems_allowed is currently being used in:

       only_alloc_fresh_hugetlb_folio --> alloc_buddy_frozen_folio -->

__alloc_frozen_pages_noprof --> prepare_alloc_pages.

Here I think using &cpuset_current_mems_allowed is part of the page allocator's wider cpuset handling.

Quoted 9 lines
Quoted 5 lines

2) Some places use cookies with cpuset_current_mems_allowed to prevent torn writes. But this adds complexity.
An example would be dequeue_hugetlb_folio_nodemask()
3) node_states[N_MEMORY] is sprinkled all over the kernel (simplest).

I would prefer option 2. A NULL mempolicy mask should fall back to cpuset_current_mems_allowed, not all N_MEMORY nodes.

Sounds good Usama :)

I will send a patch that replaces nodemask = &node_states[N_MEMORY]; with the below:

+ unsigned int cpuset_mems_cookie;

Review

Quoted 7 lines
(quoted diff) +7 -0
+
+ do {
+ cpuset_mems_cookie = read_mems_allowed_begin();
+ local_node_mask = cpuset_current_mems_allowed;
+ } while (read_mems_allowed_retry(cpuset_mems_cookie));
+
+ nodemask = &local_node_mask;

Although complexity increases with the above mechanism but probably it might be better in terms of being compliant with task's hardwall cpuset as explained by Usama earlier.

Quoted 1 line
Quoted 4 lines
Quoted 1 line

Will send it out tomorrow! Let me know if anyone has any objections.

I would say let's wait for a day or two before sending the respin.

Ack!

Thanks Usama and Anshuman :)

Quoted 17 lines
Quoted 17 lines
Quoted 17 lines
Quoted 16 lines
Quoted 16 lines
Quoted 16 lines

Would it not be better to check cpuset as well?

Thanks,
Usama

Quoted 8 lines
mm/hugetlb_cma.c +2 -1
+
+   if (hugetlb_cma[nid] && node_isset(nid, *nodemask))
            page = cma_alloc_frozen_compound(hugetlb_cma[nid], order);
 
    if (!page && !(gfp_mask & __GFP_THISNODE)) {
--

2.55.0