From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from out-188.mta0.migadu.com (out-188.mta0.migadu.com [91.218.175.188]) (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 5CE15366541 for ; Tue, 30 Jun 2026 17:40:00 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=91.218.175.188 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1782841202; cv=none; b=jm+N39dNi+0ZzYGk3dF6V1EXuMzNZnYu7GJmgodalCNrqDKvK39apHUjDqTQYdFf4gMb3TUdOh5jqblbHKP9G/gO3iThe8t+/joMx8G9rK7/KntfFnodZaonKtXYbos2EQzPt6guGwvpdX5Q4CsKS4PB0qH3p0BhXOr8eB+jZBI= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1782841202; c=relaxed/simple; bh=KaYDfkZ/3q68SXK8KXEtHkmVCx34thkT933VzTPEU+k=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=QhBbAnM4S2ztlJL5HBBecnWwjcn9EsAfpY0C7poXvwO2Uq3ga2GLugflI2FyVgL/NmvNF+vy8WQ76xRMyTtwQC9qzDnyuoxUuxgG4QP5ZCl9RenzlnoZi6pvOoUXDIB6x/3g/O742nbpA0it0wq9SuOHjvP7pZzTlGw1bEbhGVo= 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=Sr0wdT6V; arc=none smtp.client-ip=91.218.175.188 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="Sr0wdT6V" X-Report-Abuse: Please report any abuse attempt to abuse@migadu.com and include these headers. DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux.dev; s=key1; t=1782841198; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=0qW1a37iNA3MeU1ejC3DqxBAWc5gePXhychoyezKqHo=; b=Sr0wdT6VReJ2L6E1Kf/XUnnltL0YWj1HwAjjM0pLuaOxBd+2DP7+aKiCKfZWNPJnMuoTtE CVBmwanSeX7Ai7Apfw6L4QTFp7yq0fioOSnQluFrcDAntu3kBPgRgq/ybr6GWQCxSPwBnu dry1Pyn/z4qLacmlL7UPNbuBFxAgGnU= From: Usama Arif To: Sourav Panda Cc: Usama Arif , muchun.song@linux.dev, osalvador@suse.de, akpm@linux-foundation.org, david@kernel.org, surenb@google.com, fvdl@google.com, gthelen@google.com, rientjes@google.com, linux-mm@kvack.org, linux-kernel@vger.kernel.org Subject: Re: [PATCH v2] mm/hugetlb_cma: support percentage-based hugetlb_cma reservation Date: Tue, 30 Jun 2026 10:39:51 -0700 Message-ID: <20260630173953.642186-1-usama.arif@linux.dev> In-Reply-To: <20260628190155.3655895-1-souravpanda@google.com> References: Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Migadu-Flow: FLOW_OUT On Sun, 28 Jun 2026 19:01:55 +0000 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 > Reported-by: kernel test robot > Closes: https://lore.kernel.org/oe-kbuild-all/202606262023.IKUrn01I-lkp@intel.com/ > --- > Link: https://lore.kernel.org/linux-mm/20260625215900.2151690-1-souravpanda@google.com/ [v1] > > v2: > - Use mul_u64_u32_div() instead of mult_frac() to avoid 64-bit division on 32-bit architectures (Reported by kernel test robot). > - Fix physical memory size truncation on 32-bit PAE by using phys_addr_t in memblock_node_memory_size() (Sashiko). > - Fix boot parameter override logic to respect standard last-one-wins precedence by clearing opposite values during parsing and clearing node-specific values when global values are parsed. > .../admin-guide/kernel-parameters.txt | 7 +- > mm/hugetlb_cma.c | 96 ++++++++++++++++++- > 2 files changed, 97 insertions(+), 6 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%). > + 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..684ffa3537d2 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,28 @@ 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); > > 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 +157,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 +204,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; Can this round percentage-derived sizes to the gigantic page size before the existing alignment checks run? For example, on an x86_64 machine with 64 GiB of memory, hugetlb_cma=20% computes 12.8 GiB. The later hugetlb_cma_reserve() alignment check requires the total to be a multiple of the gigantic_page_size, so the documented 20% example is rejected and the reservation is disabled? > > -- > 2.55.0.rc0.799.gd6f94ed593-goog > >