[RFC PATCH] mm/hugetlb_cma: round up per_node before logging it

[Sang-Heon Jeon <ekffu200098@gmail.com>]

When the user requests a total hugetlb CMA size without per-node
specification, hugetlb_cma_reserve() computes per_node from
hugetlb_cma_size and the number of nodes that have memory

        per_node = DIV_ROUND_UP(hugetlb_cma_size,
                                nodes_weight(hugetlb_bootmem_nodes));

The reservation loop later computes

        size = round_up(min(per_node, hugetlb_cma_size - reserved),
                          PAGE_SIZE << order);

So the actually reserved per_node size is multiple of (PAGE_SIZE <<
order), but the logged per_node is not rounded up, so it may be smaller
than the actual reserved size.

For example, as the existing comment describes, if a 3 GB area is
requested on a machine with 4 NUMA nodes that have memory, 1 GB is
allocated on the first three nodes, but the printed log is

        hugetlb_cma: reserve 3072 MiB, up to 768 MiB per node

Round per_node up to (PAGE_SIZE << order) before logging so that the
printed log always matches the actual reserved size. No functional change
to the actual reservation size, as the following case analysis shows

1. remaining (hugetlb_cma_size - reserved) >= rounded per_node
 - AS-IS: min() picks unrounded per_node; 
    round_up() returns rounded per_node
 - TO-BE: min() picks rounded per_node;
    round_up() returns rounded per_node (no-op)
2. remaining < unrounded per_node
 - AS-IS: min() picks remaining;
    round_up() returns round_up(remaining)
 - TO-BE: min() picks remaining;
    round_up() returns round_up(remaining)
3. unrounded per_node <= remaining < rounded per_node
 - AS-IS: min() picks unrounded per_node;
    round_up() returns rounded per_node
 - TO-BE: min() picks remaining;
    round_up() returns round_up(remaining) equals rounded per_node

Signed-off-by: Sang-Heon Jeon <ekffu200098@gmail.com>
---
Hello,

While looking into boot information, I found a minor issue.
I am sending this patch as an RFC because of the two additional
questions below (one directly related, the other indirectly related)

1. This patch only fixes the log output, not the reservation result itself.
Do I need to add Fixes tag on this case? (i.e., Does this patch need backporting?)
If so, I'll add below commit.

  Fixes: cf11e85fc08c ("mm: hugetlb: optionally allocate gigantic hugepages using cma") # 5.7

2. When node_specific_cma_alloc is true, the reservation loop can break
out early due to round_up() before all specified nodes are reserved.
Is this intentional or a bug?

For example, with hugetlb_cma=0:1300M,1:1300M,2:1300M and (PAGE_SIZE
<< order) is 1GB

  hugetlb_cma_size_in_node[0..2] = 1300MB
  hugetlb_cma_size = 3900MB

Actual reserved size is rounded up from 1300MB to 2GB

  iter 1 (node 0): reserved: 2GB, 2GB < 3900MB, continue
  iter 2 (node 1): reserved: 4GB, 4GB >= 3900MB, break

As a result, node 2 was specified but no CMA area is reserved. If this is
unintended, I would be happy to send a follow-up patch to fix it.

If I misunderstood anything, please feel free to let me know.

Best Regards,
Sang-Heon Jeon
---
 mm/hugetlb_cma.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/mm/hugetlb_cma.c b/mm/hugetlb_cma.c
index f83ae4998990..4a92a9e38500 100644
--- a/mm/hugetlb_cma.c
+++ b/mm/hugetlb_cma.c
@@ -204,6 +204,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)
 		pr_info("hugetlb_cma: reserve %lu MiB, up to %lu MiB per node\n",
 			hugetlb_cma_size / SZ_1M, per_node / SZ_1M);
 	}
-- 
2.43.0