mm/hugetlb_cma: restrict hugetlb_cma parameter to gigantic-page alignment

Existing hugetlb_cma parameter handling logic rejects sizes smaller than
one gigantic page, but rounds up larger sizes that are not a multiple of
it.  The two behaviors are inconsistent and neither is documented.

To remove existing inconsistent and undefined behavior, restrict
hugetlb_cma parameter to only accept multiples of the gigantic page size.

After this restriction, the redundant round_up() in the allocation loop
can be removed.

The new restriction is also documented in kernel-parameters.txt.

Also, including other minor changes for readability improvement with no
functional change.

Link: https://lore.kernel.org/20260503084225.415980-1-ekffu200098@gmail.com
Signed-off-by: Sang-Heon Jeon <ekffu200098@gmail.com>
Suggested-by: Muchun Song <muchun.song@linux.dev>
Acked-by: Muchun Song <muchun.song@linux.dev>
Acked-by: Oscar Salvador <osalvador@suse.de>
Cc: David Hildenbrand <david@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt
index 4d0f545fb3ec5a1750d9112a851deb8fd976d32d..23be2f64439ca7a33ab80f767bd0335a8e5f6cf9 100644 (file)
--- a/Documentation/admin-guide/kernel-parameters.txt
+++ b/Documentation/admin-guide/kernel-parameters.txt
@@ -2100,6 +2100,10 @@ Kernel parameters
                        Format: nn[KMGTPE] or (node format)
                                <node>:nn[KMGTPE][,<node>:nn[KMGTPE]]
 
+                       The size must be a multiple of the gigantic page size.
+                       When using node format, this applies to each per-node size.
+                       Missaligned values are dropped with a warning.
+
                        Reserve a CMA area of given size and allocate gigantic
                        hugepages using the CMA allocator. If enabled, the
                        boot-time allocation of gigantic hugepages is skipped.

diff --git a/mm/hugetlb_cma.c b/mm/hugetlb_cma.c
index 7693ccefd0c64f8e20f71764dc8aae57afbb416f..39344d6c78d84e8e728025b00f8e6e66e80a3ab1 100644 (file)
--- a/mm/hugetlb_cma.c
+++ b/mm/hugetlb_cma.c
@@ -142,7 +142,7 @@ unsigned int __weak arch_hugetlb_cma_order(void)
 
 void __init hugetlb_cma_reserve(void)
 {
-       unsigned long size, reserved, per_node, order;
+       unsigned long size, reserved, per_node, order, gigantic_page_size;
        bool node_specific_cma_alloc = false;
        int nid;
 
@@ -162,37 +162,36 @@ void __init hugetlb_cma_reserve(void)
         * breaking this assumption.
         */
        VM_WARN_ON(order <= MAX_PAGE_ORDER);
+       gigantic_page_size = PAGE_SIZE << order;
 
        hugetlb_bootmem_set_nodes();
 
        for (nid = 0; nid < MAX_NUMNODES; nid++) {
-               if (hugetlb_cma_size_in_node[nid] == 0)
+               size = hugetlb_cma_size_in_node[nid];
+               if (size == 0)
                        continue;
 
                if (!node_isset(nid, hugetlb_bootmem_nodes)) {
                        pr_warn("hugetlb_cma: invalid node %d specified\n", nid);
-                       hugetlb_cma_size -= hugetlb_cma_size_in_node[nid];
-                       hugetlb_cma_size_in_node[nid] = 0;
-                       continue;
-               }
-
-               if (hugetlb_cma_size_in_node[nid] < (PAGE_SIZE << order)) {
-                       pr_warn("hugetlb_cma: cma area of node %d should be at least %lu MiB\n",
-                               nid, (PAGE_SIZE << order) / SZ_1M);
-                       hugetlb_cma_size -= hugetlb_cma_size_in_node[nid];
-                       hugetlb_cma_size_in_node[nid] = 0;
+               } else if (!IS_ALIGNED(size, gigantic_page_size)) {
+                       pr_warn("hugetlb_cma: cma area of node %d must be a multiple of %lu MiB\n",
+                               nid, gigantic_page_size / SZ_1M);
                } else {
                        node_specific_cma_alloc = true;
+                       continue;
                }
+
+               hugetlb_cma_size -= size;
+               hugetlb_cma_size_in_node[nid] = 0;
        }
 
        /* Validate the CMA size again in case some invalid nodes specified. */
        if (!hugetlb_cma_size)
                return;
 
-       if (hugetlb_cma_size < (PAGE_SIZE << order)) {
-               pr_warn("hugetlb_cma: cma area should be at least %lu MiB\n",
-                       (PAGE_SIZE << order) / SZ_1M);
+       if (!IS_ALIGNED(hugetlb_cma_size, gigantic_page_size)) {
+               pr_warn("hugetlb_cma: cma area must be a multiple of %lu MiB\n",
+                       gigantic_page_size / SZ_1M);
                hugetlb_cma_size = 0;
                return;
        }
@@ -204,7 +203,7 @@ void __init hugetlb_cma_reserve(void)
                 */
                per_node = DIV_ROUND_UP(hugetlb_cma_size,
                                        nodes_weight(hugetlb_bootmem_nodes));
-               per_node = round_up(per_node, PAGE_SIZE << order);
+               per_node = round_up(per_node, gigantic_page_size);
                pr_info("hugetlb_cma: reserve %lu MiB, up to %lu MiB per node\n",
                        hugetlb_cma_size / SZ_1M, per_node / SZ_1M);
        }
@@ -223,15 +222,13 @@ void __init hugetlb_cma_reserve(void)
                        size = min(per_node, hugetlb_cma_size - reserved);
                }
 
-               size = round_up(size, PAGE_SIZE << order);
-
                snprintf(name, sizeof(name), "hugetlb%d", nid);
                /*
                 * Note that 'order per bit' is based on smallest size that
                 * may be returned to CMA allocator in the case of
                 * huge page demotion.
                 */
-               res = cma_declare_contiguous_multi(size, PAGE_SIZE << order,
+               res = cma_declare_contiguous_multi(size, gigantic_page_size,
                                        HUGETLB_PAGE_ORDER, name,
                                        &hugetlb_cma[nid], nid);
                if (res) {