From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from out-186.mta1.migadu.com (mta1.migadu.com [37.59.57.117]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 67E373F4830 for ; Thu, 6 Aug 2026 12:15:51 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=37.59.57.117 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786018554; cv=none; b=VqirC1Vvr9KL+NGvKJGjbhm4WsyzvJy7eTcH8jzZ6l1n7zULdioosQd9AAl7QIEh0SU/vmABpVHRvJoxVA8PrNfIt08guVNLJREt23H96zbqriCCn62Gy+1FmVwbyGlpbSzd6RI6MYaMFnJAHtNML7aOIct/6mOzOAsB5jwaVfc= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786018554; c=relaxed/simple; bh=H00F4aNcGtCnGUh2jkHC8x+V8FkK75qcbCR6iT91WIc=; h=Message-ID:Date:MIME-Version:Subject:To:Cc:References:From: In-Reply-To:Content-Type; b=hd8tJBnSrfVes53t0ugTtqhMhrIgLFsF/e3U/mxpiuJIgGEtQviKNSVKTSj6uLcQ6yIkQi7NxsP3nK89SZXMbCdHWwv4as7VF32pwQE5E/o41qg1cvTVFaQifZeaQlr9tADsAI53zeqhx8CY6smezF3/v417it7buAgCMrxZ0M0= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.dev; spf=pass smtp.mailfrom=linux.dev; dkim=pass (1024-bit key) header.d=linux.dev header.i=@linux.dev header.b=b5Gr0A4R; arc=none smtp.client-ip=37.59.57.117 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.dev Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linux.dev Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=linux.dev header.i=@linux.dev header.b="b5Gr0A4R" Message-ID: <0dee4ba8-d68d-453d-91d8-b2c937c8682f@linux.dev> DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux.dev; s=key1; t=1786018548; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=605lfRxY80KM3RTeJ1+8Cpx6iUAXZG0EblYK5U5G/Ew=; b=b5Gr0A4R16Cu2hhktEPd1Ih1+3Bwwf35WmtMb2cjDsC+VCsi7pOadIHeKnf2y7l5QbwRzN vHUzJQGcootnl4PRHJ0Q5ewtDGDb7q0EeJZ+b8qZWgkw+U0NMMkBYfKcgHYU69LUkUuO4l DEvX0GHcNsZ4IPY9KwjdblwWj1QNRHg= Date: Thu, 6 Aug 2026 13:15:28 +0100 Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Subject: Re: [PATCH v4] mm/hugetlb_cma: support percentage-based hugetlb_cma reservation To: Sourav Panda , muchun.song@linux.dev, osalvador@suse.de, akpm@linux-foundation.org Cc: david@kernel.org, surenb@google.com, fvdl@google.com, gthelen@google.com, rientjes@google.com, linux-mm@kvack.org, linux-kernel@vger.kernel.org References: <20260806085651.4068433-1-souravpanda@google.com> Content-Language: en-US X-Report-Abuse: Please report any abuse attempt to abuse@migadu.com and include these headers. From: Usama Arif In-Reply-To: <20260806085651.4068433-1-souravpanda@google.com> Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-Migadu-Flow: FLOW_OUT On 06/08/2026 09:56, Sourav Panda wrote: > Currently, hugetlb_cma reservation only supports absolute sizes (e.g., > hugetlb_cma=2G or hugetlb_cma=0:1G,1:1G). This can be restrictive in > heterogeneous environments or when deploying common kernel command lines > across machines with different memory capacities. > > Add support for percentage-based hugetlb_cma reservation (e.g., > hugetlb_cma=20% or hugetlb_cma=0:20%,1:10%). > > The percentage is calculated against the total memory (for global > settings) or against the node-specific memory (for node-specific > settings) using memblock APIs during early boot. > > Signed-off-by: Sourav Panda > --- > Link: https://lore.kernel.org/linux-mm/20260729163148.3271755-1-souravpanda@google.com/ [v3] > Link: https://lore.kernel.org/linux-mm/20260628190155.3655895-1-souravpanda@google.com/ [v2] > Link: https://lore.kernel.org/linux-mm/20260625215900.2151690-1-souravpanda@google.com/ [v1] > > v4: > - Clear global hugetlb_cma_percent and hugetlb_cma_size when node-specific parameters are parsed so the last command line configuration wins (Usama Arif). > - Warn when ALIGN_DOWN rounds down a non-zero percentage-derived reservation size to 0 MiB (Usama Arif). > > v3: > - Enhance pr_info logs to explicitly show percentage-derived sizes per Andrew Morton"s suggestions. > - Explicitly align percentage-derived sizes down to the gigantic page size to prevent allocation failures (Usama Arif). > > .../admin-guide/kernel-parameters.txt | 7 +- > mm/hugetlb_cma.c | 141 +++++++++++++++++- > 2 files changed, 138 insertions(+), 10 deletions(-) > > diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt > index 5a05b48d1684..846940ce2858 100644 > --- a/Documentation/admin-guide/kernel-parameters.txt > +++ b/Documentation/admin-guide/kernel-parameters.txt > @@ -2064,8 +2064,11 @@ Kernel parameters > hugetlb_cma= [HW,CMA,EARLY] The size of a CMA area used for allocation > of gigantic hugepages. Or using node format, the size > of a CMA area per node can be specified. > - Format: nn[KMGTPE] or (node format) > - :nn[KMGTPE][,:nn[KMGTPE]] > + The size can be an absolute value (e.g., 2G) or a > + percentage of the total memory or node memory (e.g., 20%). I think it would be good to add something like below in the doc as well: Percentage-derived sizes are rounded down to a multiple of the architecture's gigantic hugepage size and may become zero. And thanks for the patch! This is very useful to have in a heterogeneous fleet. Acked-by: Usama Arif > + Format: nn[KMGTPE] or nn% or (node format) > + :nn[KMGTPE][,:nn[KMGTPE]] or > + :nn%[,:nn%] > > Reserve a CMA area of given size and allocate gigantic > hugepages using the CMA allocator. If enabled, the > diff --git a/mm/hugetlb_cma.c b/mm/hugetlb_cma.c > index 7693ccefd0c6..2ca014a0a3b8 100644 > --- a/mm/hugetlb_cma.c > +++ b/mm/hugetlb_cma.c > @@ -9,6 +9,9 @@ > #include > > #include > +#include > +#include > +#include > #include "internal.h" > #include "hugetlb_cma.h" > > @@ -18,6 +21,28 @@ static unsigned long hugetlb_cma_size_in_node[MAX_NUMNODES] __initdata; > static bool hugetlb_cma_only __ro_after_init; > static unsigned long hugetlb_cma_size __ro_after_init; > > +static unsigned int hugetlb_cma_percent __initdata; > +static unsigned int hugetlb_cma_percent_in_node[MAX_NUMNODES] __initdata; > + > +#ifdef CONFIG_NUMA > +static phys_addr_t __init memblock_node_memory_size(int nid) > +{ > + struct memblock_region *reg; > + phys_addr_t size = 0; > + > + for_each_mem_region(reg) { > + if (reg->nid == nid) > + size += reg->size; > + } > + return size; > +} > +#else > +static phys_addr_t __init memblock_node_memory_size(int nid) > +{ > + return memblock_phys_mem_size(); > +} > +#endif > + > void hugetlb_cma_free_frozen_folio(struct folio *folio) > { > WARN_ON_ONCE(!cma_release_frozen(hugetlb_cma[folio_nid(folio)], > @@ -100,14 +125,31 @@ static int __init cmdline_parse_hugetlb_cma(char *p) > break; > > if (s[count] == ':') { > + char *next; > + > if (tmp >= MAX_NUMNODES) > break; > nid = array_index_nospec(tmp, MAX_NUMNODES); > > + hugetlb_cma_size = 0; > + hugetlb_cma_percent = 0; > + > s += count + 1; > - tmp = memparse(s, &s); > - hugetlb_cma_size_in_node[nid] = tmp; > - hugetlb_cma_size += tmp; > + tmp = memparse(s, &next); > + if (*next == '%') { > + if (tmp > 100) { > + pr_warn("hugetlb_cma: invalid percentage %lu for node %d\n", > + tmp, nid); > + break; > + } > + hugetlb_cma_percent_in_node[nid] = tmp; > + hugetlb_cma_size_in_node[nid] = 0; > + s = next + 1; > + } else { > + hugetlb_cma_size_in_node[nid] = tmp; > + hugetlb_cma_percent_in_node[nid] = 0; > + s = next; > + } > > /* > * Skip the separator if have one, otherwise > @@ -118,7 +160,28 @@ static int __init cmdline_parse_hugetlb_cma(char *p) > else > break; > } else { > - hugetlb_cma_size = memparse(p, &p); > + char *next; > + > + tmp = memparse(p, &next); > + if (*next == '%') { > + if (tmp > 100) { > + pr_warn("hugetlb_cma: invalid percentage %lu\n", tmp); > + } else { > + hugetlb_cma_percent = tmp; > + hugetlb_cma_size = 0; > + for (nid = 0; nid < MAX_NUMNODES; nid++) { > + hugetlb_cma_size_in_node[nid] = 0; > + hugetlb_cma_percent_in_node[nid] = 0; > + } > + } > + } else { > + hugetlb_cma_size = tmp; > + hugetlb_cma_percent = 0; > + for (nid = 0; nid < MAX_NUMNODES; nid++) { > + hugetlb_cma_size_in_node[nid] = 0; > + hugetlb_cma_percent_in_node[nid] = 0; > + } > + } > break; > } > } > @@ -144,8 +207,36 @@ void __init hugetlb_cma_reserve(void) > { > unsigned long size, reserved, per_node, order; > bool node_specific_cma_alloc = false; > + bool has_node_specific_param = false; > int nid; > > + for (nid = 0; nid < MAX_NUMNODES; nid++) { > + if (hugetlb_cma_size_in_node[nid] || hugetlb_cma_percent_in_node[nid]) { > + has_node_specific_param = true; > + break; > + } > + } > + > + if (has_node_specific_param) { > + hugetlb_cma_size = 0; > + for (nid = 0; nid < MAX_NUMNODES; nid++) { > + if (hugetlb_cma_percent_in_node[nid]) { > + phys_addr_t node_gfp_mem = memblock_node_memory_size(nid); > + u64 s; > + > + s = mul_u64_u32_div((u64)node_gfp_mem, > + hugetlb_cma_percent_in_node[nid], > + 100); > + > + hugetlb_cma_size_in_node[nid] = s; > + } > + hugetlb_cma_size += hugetlb_cma_size_in_node[nid]; > + } > + } else if (hugetlb_cma_percent) { > + hugetlb_cma_size = mul_u64_u32_div((u64)memblock_phys_mem_size(), > + hugetlb_cma_percent, 100); > + } > + > if (!hugetlb_cma_size) > return; > > @@ -163,6 +254,32 @@ void __init hugetlb_cma_reserve(void) > */ > VM_WARN_ON(order <= MAX_PAGE_ORDER); > > + if (hugetlb_cma_percent) { > + unsigned long orig_size = hugetlb_cma_size; > + > + hugetlb_cma_size = ALIGN_DOWN(hugetlb_cma_size, PAGE_SIZE << order); > + if (orig_size && !hugetlb_cma_size) > + pr_warn("hugetlb_cma: reservation size rounded down to 0 from %lu MiB (%u%%)\n", > + orig_size / SZ_1M, hugetlb_cma_percent); > + } else if (has_node_specific_param) { > + hugetlb_cma_size = 0; > + for (nid = 0; nid < MAX_NUMNODES; nid++) { > + if (hugetlb_cma_percent_in_node[nid]) { > + unsigned long orig_size = hugetlb_cma_size_in_node[nid]; > + > + hugetlb_cma_size_in_node[nid] = > + ALIGN_DOWN(hugetlb_cma_size_in_node[nid], > + PAGE_SIZE << order); > + if (orig_size && !hugetlb_cma_size_in_node[nid]) > + pr_warn("hugetlb_cma: reservation size rounded down to 0 from %lu MiB (%u%%) on node %d\n", > + orig_size / SZ_1M, > + hugetlb_cma_percent_in_node[nid], > + nid); > + } > + hugetlb_cma_size += hugetlb_cma_size_in_node[nid]; > + } > + } > + > hugetlb_bootmem_set_nodes(); > > for (nid = 0; nid < MAX_NUMNODES; nid++) { > @@ -205,8 +322,12 @@ 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); > + if (hugetlb_cma_percent) > + pr_info("hugetlb_cma: reserve %lu MiB (%u%%), up to %lu MiB per node\n", > + hugetlb_cma_size / SZ_1M, hugetlb_cma_percent, per_node / SZ_1M); > + else > + pr_info("hugetlb_cma: reserve %lu MiB, up to %lu MiB per node\n", > + hugetlb_cma_size / SZ_1M, per_node / SZ_1M); > } > > reserved = 0; > @@ -241,8 +362,12 @@ void __init hugetlb_cma_reserve(void) > } > > reserved += size; > - pr_info("hugetlb_cma: reserved %lu MiB on node %d\n", > - size / SZ_1M, nid); > + if (hugetlb_cma_percent_in_node[nid]) > + pr_info("hugetlb_cma: reserved %lu MiB (%u%%) on node %d\n", > + size / SZ_1M, hugetlb_cma_percent_in_node[nid], nid); > + else > + pr_info("hugetlb_cma: reserved %lu MiB on node %d\n", > + size / SZ_1M, nid); > > if (reserved >= hugetlb_cma_size) > break;