From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from out-184.mta0.migadu.com (out-184.mta0.migadu.com [91.218.175.184]) (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 1568F32470E for ; Thu, 30 Jul 2026 12:49:45 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=91.218.175.184 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1785415788; cv=none; b=ui5qOmiCB2RKPBZHzw5gWr6eMxUOFW9wqNjnRtIbAIv/rE70ZLdpiPpM05RVowk23a60XA3cje9jF+7JkD6QRFIArGwdKEEGlqRtFW/mgYLW/v8dx9v29oFP2gOWVoz3TqP40onGAzskOWjOJcsM4y95aBEgYTIbywikNZHN/PQ= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1785415788; c=relaxed/simple; bh=9BkQcBMtnzuA5LFrl1Idgn4LnD0GEcs/23X+u5et2Ps=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=UWbYbxMVqp8GVfiiFEMtEWOMhfnEEUXuXg7Ta/wYl6efosYPjDTZID0imIPI0QhSYElPIfhb/aglh3N9Pk+8q/3GKkvIH2U6pwlARq3v8Mce5d54+5ujmru3J0KElw39Rp2F0mSMMjpRl41YJfr1RksBlwZwzHFNwG2AInR4b4E= 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=CDsJyu8N; arc=none smtp.client-ip=91.218.175.184 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="CDsJyu8N" 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=1785415784; 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=CmEwD1aH0H0rZlxyJ22DUchnx362h5tsqtqK+qI1YZw=; b=CDsJyu8N1O5uh/jYakqQrwBIlvNzeiUJyveqTHqyxOlk1SkRBXGNtG4aHs9NauQpOOMaOU qTy9rMJuLj1yF4Yed1/11c/SqAL0qooK3tuDMpn1a65GG6QUDX+cJm8h8g5PVKnXgOubc+ xt5FYyGweLABBXA8HossoZexF4cK0ho= 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 v3] mm/hugetlb_cma: support percentage-based hugetlb_cma reservation Date: Thu, 30 Jul 2026 05:49:37 -0700 Message-ID: <20260730124938.2619968-1-usama.arif@linux.dev> In-Reply-To: <20260729163148.3271755-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 Wed, 29 Jul 2026 16:31:48 +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 > --- > 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] > > 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 | 126 ++++++++++++++++-- > 2 files changed, 123 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%). > + 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..99d05eb82abc 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; > > @@ -163,6 +251,20 @@ void __init hugetlb_cma_reserve(void) > */ > VM_WARN_ON(order <= MAX_PAGE_ORDER); > > + if (hugetlb_cma_percent) { > + hugetlb_cma_size = ALIGN_DOWN(hugetlb_cma_size, PAGE_SIZE << order); > + } else if (has_node_specific_param) { Hello, What will be done here if you have the following in kernel commandline? hugetlb_cma=20% hugetlb_cma=0:20%,1:20% It looks like the later node form doesn't clear hugetlb_cma_percent, so node specific sizes will be ignored, which I think is not the right behaviour. > + hugetlb_cma_size = 0; > + for (nid = 0; nid < MAX_NUMNODES; nid++) { > + if (hugetlb_cma_percent_in_node[nid]) { > + hugetlb_cma_size_in_node[nid] = > + ALIGN_DOWN(hugetlb_cma_size_in_node[nid], > + PAGE_SIZE << order); Maybe print a warning here if you round down to 0? For example, 5% of a 16G machine will round down to 0. > + } > + hugetlb_cma_size += hugetlb_cma_size_in_node[nid]; > + } > + } > + > hugetlb_bootmem_set_nodes(); > > for (nid = 0; nid < MAX_NUMNODES; nid++) { > @@ -205,8 +307,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 +347,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; > -- > 2.55.0.rc0.799.gd6f94ed593-goog > >