[PATCH 13/22] mm/hugetlb: restrict pool growth to common memory

From: Gregory Price (Meta)

Date: Sat Nov 14 2026 - 02:11:35 EST


Fresh HugeTLB pool folios come from ordinary allocations, which only
N_MEMORY_COMMON nodes serve.

Restrict HugeTLB allocations and pool-growth to N_MEMORY_COMMON nodes.

Keep the original allowed mask for pool shrinking and demotion so
existing pool folios can still be found on any online-memory node.

The result of this change is that hugepage allocations will fail on
nodes without N_MEMORY_COMMON. This restriction can be loosened later
when/if it grows a user.

All memory is common at this point, so behavior is unchanged.

Signed-off-by: Gregory Price (Meta) <gourry@xxxxxxxxxx>
---
mm/hugetlb.c | 44 ++++++++++++++++++++------------------------
1 file changed, 20 insertions(+), 24 deletions(-)

diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index cb2de24affdc4..cc1468f68901b 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -3452,13 +3452,13 @@ static void __init hugetlb_hstate_alloc_pages_onenode(struct hstate *h, int nid)
gfp_t gfp_mask = htlb_alloc_mask(h) | __GFP_THISNODE;

folio = only_alloc_fresh_hugetlb_folio(h, gfp_mask, nid,
- &node_states[N_MEMORY], NULL);
+ &node_states[N_MEMORY_COMMON], NULL);
if (!folio && !list_empty(&folio_list) &&
hugetlb_vmemmap_optimizable(h)) {
prep_and_add_allocated_folios(h, &folio_list);
INIT_LIST_HEAD(&folio_list);
folio = only_alloc_fresh_hugetlb_folio(h, gfp_mask, nid,
- &node_states[N_MEMORY], NULL);
+ &node_states[N_MEMORY_COMMON], NULL);
}
if (!folio)
break;
@@ -3528,7 +3528,7 @@ static void __init hugetlb_pages_alloc_boot_node(unsigned long start, unsigned l
prep_and_add_allocated_folios(h, &folio_list);
INIT_LIST_HEAD(&folio_list);
}
- folio = alloc_pool_huge_folio(h, &node_states[N_MEMORY],
+ folio = alloc_pool_huge_folio(h, &node_states[N_MEMORY_COMMON],
&node_alloc_noretry, &next_node);
if (!folio)
break;
@@ -3672,13 +3672,12 @@ static void __init hugetlb_init_hstates(void)

for_each_hstate(h) {
/*
- * Always reset to first_memory_node here, even if
- * next_nid_to_alloc was set before - we can't
- * reference hugetlb_bootmem_nodes after init, and
- * first_memory_node is right for all further allocations.
+ * Always reset the allocation cursor here, even if it was set
+ * before: hugetlb_bootmem_nodes cannot be referenced after init,
+ * and further pool allocations use common memory.
*/
- h->next_nid_to_alloc = first_memory_node;
- h->next_nid_to_free = first_memory_node;
+ h->next_nid_to_alloc = first_node_state(N_MEMORY_COMMON);
+ h->next_nid_to_free = first_node_state(N_MEMORY_COMMON);

/* oversize hugepages were init'ed in early boot */
if (!hstate_is_gigantic(h))
@@ -3802,23 +3801,21 @@ static int set_max_huge_pages(struct hstate *h, unsigned long count, int nid,
unsigned long allocated;
struct folio *folio;
LIST_HEAD(page_list);
- NODEMASK_ALLOC(nodemask_t, node_alloc_noretry, GFP_KERNEL);
+ NODEMASK_ALLOC(struct nodemask_scratch, scratch, GFP_KERNEL);

- /*
- * Bit mask controlling how hard we retry per-node allocations.
- * If we can not allocate the bit mask, do not attempt to allocate
- * the requested huge pages.
- */
- if (node_alloc_noretry)
- nodes_clear(*node_alloc_noretry);
- else
+ /* Scratch masks for allocation eligibility and per-node retries. */
+ if (!scratch)
return -ENOMEM;
+ nodes_clear(scratch->mask2);

/*
* resize_lock mutex prevents concurrent adjustments to number of
* pages in hstate via the proc/sysfs interfaces.
*/
mutex_lock(&h->resize_lock);
+
+ /* Fresh pool pages come from the ordinary allocation domain. */
+ nodes_and(scratch->mask1, *nodes_allowed, node_states[N_MEMORY_COMMON]);
flush_free_hpage_work(h);
spin_lock_irq(&hugetlb_lock);

@@ -3855,7 +3852,7 @@ static int set_max_huge_pages(struct hstate *h, unsigned long count, int nid,
if (count > persistent_huge_pages(h)) {
spin_unlock_irq(&hugetlb_lock);
mutex_unlock(&h->resize_lock);
- NODEMASK_FREE(node_alloc_noretry);
+ NODEMASK_FREE(scratch);
return -EINVAL;
}
/* Fall through to decrease pool */
@@ -3873,7 +3870,7 @@ static int set_max_huge_pages(struct hstate *h, unsigned long count, int nid,
* within all the constraints specified by the sysctls.
*/
while (h->surplus_huge_pages && count > persistent_huge_pages(h)) {
- if (!adjust_pool_surplus(h, nodes_allowed, -1))
+ if (!adjust_pool_surplus(h, &scratch->mask1, -1))
break;
}

@@ -3889,9 +3886,8 @@ static int set_max_huge_pages(struct hstate *h, unsigned long count, int nid,
/* yield cpu to avoid soft lockup */
cond_resched();

- folio = alloc_pool_huge_folio(h, nodes_allowed,
- node_alloc_noretry,
- &h->next_nid_to_alloc);
+ folio = alloc_pool_huge_folio(h, &scratch->mask1, &scratch->mask2,
+ &h->next_nid_to_alloc);
if (!folio) {
prep_and_add_allocated_folios(h, &page_list);
spin_lock_irq(&hugetlb_lock);
@@ -3978,7 +3974,7 @@ static int set_max_huge_pages(struct hstate *h, unsigned long count, int nid,
spin_unlock_irq(&hugetlb_lock);
mutex_unlock(&h->resize_lock);

- NODEMASK_FREE(node_alloc_noretry);
+ NODEMASK_FREE(scratch);

return 0;
}
--
2.53.1-Meta