mm/hugetlb_cma: Fix null nodemask dereference in hugetlb_cma_alloc_frozen_folio
Subsystems (2)
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
---
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
@@ -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
Andrew Morton
maintainerQuoted 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 toalloc_fresh_hugetlb_folio()as a fallback to allocate from all nodes. If order is gigantic,alloc_fresh_hugetlb_folio()propagates the NULL nodemask down tohugetlb_cma_alloc_frozen_folio()viaalloc_gigantic_frozen_folio().
hugetlb_cma_alloc_frozen_folio()blindly dereferences the nodemask innode_isset(nid, *nodemask)andfor_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 allowshugetlb_cmaallocations to fall back to any node with memory, keeping behavior consistent withalloc_contig_frozen_pages()andalloc_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_MANYon 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()withMPOL_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
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 toalloc_fresh_hugetlb_folio()as a fallback to allocate from all nodes. If order is gigantic,alloc_fresh_hugetlb_folio()propagates the NULL nodemask down tohugetlb_cma_alloc_frozen_folio()viaalloc_gigantic_frozen_folio().
hugetlb_cma_alloc_frozen_folio()blindly dereferences the nodemask innode_isset(nid, *nodemask)andfor_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 allowshugetlb_cmaallocations to fall back to any node with memory, keeping behavior consistent withalloc_contig_frozen_pages()andalloc_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_MANYon 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()withMPOL_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
Quoted 9 lines · Sourav Panda
alloc_buddy_hugetlb_folio_with_mpol()can pass a NULL nodemask toalloc_fresh_hugetlb_folio()as a fallback to allocate from all nodes. If order is gigantic,alloc_fresh_hugetlb_folio()propagates the NULL nodemask down tohugetlb_cma_alloc_frozen_folio()viaalloc_gigantic_frozen_folio().
hugetlb_cma_alloc_frozen_folio()blindly dereferences the nodemask innode_isset(nid, *nodemask)andfor_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 allowshugetlb_cmaallocations to fall back to any node with memory, keeping behavior consistent withalloc_contig_frozen_pages()andalloc_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_MANYon 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()withMPOL_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/0x650Fixes eb02f14c4a2b ("mm/hugetlb: allow overcommitting gigantic hugepages")Signed-off-by Sourav Panda <[email protected]>---
Changes in v4:
- Reverted thealloc_fresh_hugetlb_folio()cpuset snapshot approach from v3. As Muchun Song pointed out, snapshottingcpuset_current_mems_alloweddoes not prevent false-positive allocation failures without complex retry loops, andalloc_contig_frozen_pages()/alloc_buddy_frozen_folio()already handle NULL nodemasks safely internally.
- Handled NULL nodemask directly insidehugetlb_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@@ -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
Quoted 8 lines · Anshuman Khandual
Quoted 6 lines · Sourav Panda
alloc_buddy_hugetlb_folio_with_mpol()can pass a NULL nodemask toalloc_fresh_hugetlb_folio()as a fallback to allocate from all nodes. If order is gigantic,alloc_fresh_hugetlb_folio()propagates the NULL nodemask down tohugetlb_cma_alloc_frozen_folio()viaalloc_gigantic_frozen_folio().
Quoted 9 lines
Quoted 3 lines
hugetlb_cma_alloc_frozen_folio()blindly dereferences the nodemask innode_isset(nid, *nodemask)andfor_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 vianode_isset()which could have been called on a NULL valued nodemask ? Although subsequentfor_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 allowshugetlb_cmaallocations to fall back to any node with memory, keeping behavior consistent withalloc_contig_frozen_pages()andalloc_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_MANYon 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()withMPOL_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/0x650Fixes eb02f14c4a2b ("mm/hugetlb: allow overcommitting gigantic hugepages")Signed-off-by Sourav Panda <[email protected]>---
Changes in v4:
- Reverted thealloc_fresh_hugetlb_folio()cpuset snapshot approach from v3. As Muchun Song pointed out, snapshottingcpuset_current_mems_alloweddoes not prevent false-positive allocation failures without complex retry loops, andalloc_contig_frozen_pages()/alloc_buddy_frozen_folio()already handle NULL nodemasks safely internally.
- Handled NULL nodemask directly insidehugetlb_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@@ -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
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 toalloc_fresh_hugetlb_folio()as a fallback to allocate from all nodes. If order is gigantic,alloc_fresh_hugetlb_folio()propagates the NULL nodemask down tohugetlb_cma_alloc_frozen_folio()viaalloc_gigantic_frozen_folio().Quoted 9 lines
Quoted 3 lines
hugetlb_cma_alloc_frozen_folio()blindly dereferences the nodemask innode_isset(nid, *nodemask)andfor_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 vianode_isset()which could have been called on a NULL valued nodemask ? Although subsequentfor_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)andfor_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!
SouravQuoted 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 allowshugetlb_cmaallocations to fall back to any node with memory, keeping behavior consistent withalloc_contig_frozen_pages()andalloc_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_MANYon 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()withMPOL_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/0x650Fixes eb02f14c4a2b ("mm/hugetlb: allow overcommitting gigantic hugepages")Signed-off-by Sourav Panda <[email protected]>---
Changes in v4:
- Reverted thealloc_fresh_hugetlb_folio()cpuset snapshot approach from v3. As Muchun Song pointed out, snapshottingcpuset_current_mems_alloweddoes not prevent false-positive allocation failures without complex retry loops, andalloc_contig_frozen_pages()/alloc_buddy_frozen_folio()already handle NULL nodemasks safely internally.
- Handled NULL nodemask directly insidehugetlb_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@@ -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
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 toalloc_fresh_hugetlb_folio()as a fallback to allocate from all nodes. If order is gigantic,alloc_fresh_hugetlb_folio()propagates the NULL nodemask down tohugetlb_cma_alloc_frozen_folio()viaalloc_gigantic_frozen_folio().
hugetlb_cma_alloc_frozen_folio()blindly dereferences the nodemask innode_isset(nid, *nodemask)andfor_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 allowshugetlb_cmaallocations to fall back to any node with memory, keeping behavior consistent withalloc_contig_frozen_pages()andalloc_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_MANYon 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()withMPOL_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/0x650Fixes eb02f14c4a2b ("mm/hugetlb: allow overcommitting gigantic hugepages")Signed-off-by Sourav Panda <[email protected]>---
Changes in v4:
- Reverted thealloc_fresh_hugetlb_folio()cpuset snapshot approach from v3. As Muchun Song pointed out, snapshottingcpuset_current_mems_alloweddoes not prevent false-positive allocation failures without complex retry loops, andalloc_contig_frozen_pages()/alloc_buddy_frozen_folio()already handle NULL nodemasks safely internally.
- Handled NULL nodemask directly insidehugetlb_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
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
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 toalloc_fresh_hugetlb_folio()as a fallback to allocate from all nodes. If order is gigantic,alloc_fresh_hugetlb_folio()propagates the NULL nodemask down tohugetlb_cma_alloc_frozen_folio()viaalloc_gigantic_frozen_folio().
hugetlb_cma_alloc_frozen_folio()blindly dereferences the nodemask innode_isset(nid, *nodemask)andfor_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 allowshugetlb_cmaallocations to fall back to any node with memory, keeping behavior consistent withalloc_contig_frozen_pages()andalloc_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_MANYon 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()withMPOL_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/0x650Fixes eb02f14c4a2b ("mm/hugetlb: allow overcommitting gigantic hugepages")Signed-off-by Sourav Panda <[email protected]>---
Changes in v4:
- Reverted thealloc_fresh_hugetlb_folio()cpuset snapshot approach from v3. As Muchun Song pointed out, snapshottingcpuset_current_mems_alloweddoes not prevent false-positive allocation failures without complex retry loops, andalloc_contig_frozen_pages()/alloc_buddy_frozen_folio()already handle NULL nodemasks safely internally.
- Handled NULL nodemask directly insidehugetlb_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
-0mm/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
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 toalloc_fresh_hugetlb_folio()as a fallback to allocate from all nodes. If order is gigantic,alloc_fresh_hugetlb_folio()propagates the NULL nodemask down tohugetlb_cma_alloc_frozen_folio()viaalloc_gigantic_frozen_folio().
hugetlb_cma_alloc_frozen_folio()blindly dereferences the nodemask innode_isset(nid, *nodemask)andfor_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 allowshugetlb_cmaallocations to fall back to any node with memory, keeping behavior consistent withalloc_contig_frozen_pages()andalloc_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_MANYon 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()withMPOL_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/0x650Fixes eb02f14c4a2b ("mm/hugetlb: allow overcommitting gigantic hugepages")Signed-off-by Sourav Panda <[email protected]>---
Changes in v4:
- Reverted thealloc_fresh_hugetlb_folio()cpuset snapshot approach from v3. As Muchun Song pointed out, snapshottingcpuset_current_mems_alloweddoes not prevent false-positive allocation failures without complex retry loops, andalloc_contig_frozen_pages()/alloc_buddy_frozen_folio()already handle NULL nodemasks safely internally.
- Handled NULL nodemask directly insidehugetlb_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
-0mm/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,
UsamaQuoted 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
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 toalloc_fresh_hugetlb_folio()as a fallback to allocate from all nodes. If order is gigantic,alloc_fresh_hugetlb_folio()propagates the NULL nodemask down tohugetlb_cma_alloc_frozen_folio()viaalloc_gigantic_frozen_folio().
hugetlb_cma_alloc_frozen_folio()blindly dereferences the nodemask innode_isset(nid, *nodemask)andfor_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 allowshugetlb_cmaallocations to fall back to any node with memory, keeping behavior consistent withalloc_contig_frozen_pages()andalloc_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_MANYon 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()withMPOL_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/0x650Fixes eb02f14c4a2b ("mm/hugetlb: allow overcommitting gigantic hugepages")Signed-off-by Sourav Panda <[email protected]>---
Changes in v4:
- Reverted thealloc_fresh_hugetlb_folio()cpuset snapshot approach from v3. As Muchun Song pointed out, snapshottingcpuset_current_mems_alloweddoes not prevent false-positive allocation failures without complex retry loops, andalloc_contig_frozen_pages()/alloc_buddy_frozen_folio()already handle NULL nodemasks safely internally.
- Handled NULL nodemask directly insidehugetlb_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
-0mm/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,
UsamaQuoted 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
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 toalloc_fresh_hugetlb_folio()as a fallback to allocate from all nodes. If order is gigantic,alloc_fresh_hugetlb_folio()propagates the NULL nodemask down tohugetlb_cma_alloc_frozen_folio()viaalloc_gigantic_frozen_folio().
hugetlb_cma_alloc_frozen_folio()blindly dereferences the nodemask innode_isset(nid, *nodemask)andfor_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 allowshugetlb_cmaallocations to fall back to any node with memory, keeping behavior consistent withalloc_contig_frozen_pages()andalloc_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_MANYon 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()withMPOL_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/0x650Fixes eb02f14c4a2b ("mm/hugetlb: allow overcommitting gigantic hugepages")Signed-off-by Sourav Panda <[email protected]>---
Changes in v4:
- Reverted thealloc_fresh_hugetlb_folio()cpuset snapshot approach from v3. As Muchun Song pointed out, snapshottingcpuset_current_mems_alloweddoes not prevent false-positive allocation failures without complex retry loops, andalloc_contig_frozen_pages()/alloc_buddy_frozen_folio()already handle NULL nodemasks safely internally.
- Handled NULL nodemask directly insidehugetlb_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
-0mm/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_allowedis 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_allowedto prevent torn writes. But this adds complexity.
An example would bedequeue_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,
UsamaQuoted 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
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 toalloc_fresh_hugetlb_folio()as a fallback to allocate from all nodes. If order is gigantic,alloc_fresh_hugetlb_folio()propagates the NULL nodemask down tohugetlb_cma_alloc_frozen_folio()viaalloc_gigantic_frozen_folio().
hugetlb_cma_alloc_frozen_folio()blindly dereferences the nodemask innode_isset(nid, *nodemask)andfor_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 allowshugetlb_cmaallocations to fall back to any node with memory, keeping behavior consistent withalloc_contig_frozen_pages()andalloc_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_MANYon 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()withMPOL_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/0x650Fixes eb02f14c4a2b ("mm/hugetlb: allow overcommitting gigantic hugepages")Signed-off-by Sourav Panda <[email protected]>---
Changes in v4:
- Reverted thealloc_fresh_hugetlb_folio()cpuset snapshot approach from v3. As Muchun Song pointed out, snapshottingcpuset_current_mems_alloweddoes not prevent false-positive allocation failures without complex retry loops, andalloc_contig_frozen_pages()/alloc_buddy_frozen_folio()already handle NULL nodemasks safely internally.
- Handled NULL nodemask directly insidehugetlb_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
-0mm/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_MANYpreference, 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_allowedis 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_allowedis part of the page allocator's wider cpuset handling.
Quoted 9 lines
Quoted 5 lines
2) Some places use cookies with
cpuset_current_mems_allowedto prevent torn writes. But this adds complexity.
An example would bedequeue_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 allN_MEMORYnodes.
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,
UsamaQuoted 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
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 toalloc_fresh_hugetlb_folio()as a fallback to allocate from all nodes. If order is gigantic,alloc_fresh_hugetlb_folio()propagates the NULL nodemask down tohugetlb_cma_alloc_frozen_folio()viaalloc_gigantic_frozen_folio().
hugetlb_cma_alloc_frozen_folio()blindly dereferences the nodemask innode_isset(nid, *nodemask)andfor_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 allowshugetlb_cmaallocations to fall back to any node with memory, keeping behavior consistent withalloc_contig_frozen_pages()andalloc_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_MANYon 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()withMPOL_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/0x650Fixes eb02f14c4a2b ("mm/hugetlb: allow overcommitting gigantic hugepages")Signed-off-by Sourav Panda <[email protected]>---
Changes in v4:
- Reverted thealloc_fresh_hugetlb_folio()cpuset snapshot approach from v3. As Muchun Song pointed out, snapshottingcpuset_current_mems_alloweddoes not prevent false-positive allocation failures without complex retry loops, andalloc_contig_frozen_pages()/alloc_buddy_frozen_folio()already handle NULL nodemasks safely internally.
- Handled NULL nodemask directly insidehugetlb_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
-0mm/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_MANYpreference, 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_allowedis 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_allowedis part of the page allocator's wider cpuset handling.Quoted 9 lines
Quoted 5 lines
2) Some places use cookies with
cpuset_current_mems_allowedto prevent torn writes. But this adds complexity.
An example would bedequeue_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 allN_MEMORYnodes.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,
UsamaQuoted 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
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 toalloc_fresh_hugetlb_folio()as a fallback to allocate from all nodes. If order is gigantic,alloc_fresh_hugetlb_folio()propagates the NULL nodemask down tohugetlb_cma_alloc_frozen_folio()viaalloc_gigantic_frozen_folio().
hugetlb_cma_alloc_frozen_folio()blindly dereferences the nodemask innode_isset(nid, *nodemask)andfor_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 allowshugetlb_cmaallocations to fall back to any node with memory, keeping behavior consistent withalloc_contig_frozen_pages()andalloc_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_MANYon 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()withMPOL_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/0x650Fixes eb02f14c4a2b ("mm/hugetlb: allow overcommitting gigantic hugepages")Signed-off-by Sourav Panda <[email protected]>---
Changes in v4:
- Reverted thealloc_fresh_hugetlb_folio()cpuset snapshot approach from v3. As Muchun Song pointed out, snapshottingcpuset_current_mems_alloweddoes not prevent false-positive allocation failures without complex retry loops, andalloc_contig_frozen_pages()/alloc_buddy_frozen_folio()already handle NULL nodemasks safely internally.
- Handled NULL nodemask directly insidehugetlb_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
-0mm/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_MANYpreference, 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_allowedis 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_allowedis part of the page allocator's wider cpuset handling.Quoted 9 lines
Quoted 5 lines
2) Some places use cookies with
cpuset_current_mems_allowedto prevent torn writes. But this adds complexity.
An example would bedequeue_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 allN_MEMORYnodes.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,
UsamaQuoted 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