* [PATCH] mm/hugetlb: allow crashkernel to reuse hugetlb CMA memory
@ 2026-11-04 14:27 Usama Arif
2026-11-04 15:20 ` Kiryl Shutsemau
0 siblings, 1 reply; 5+ messages in thread
From: Usama Arif @ 2026-11-04 14:27 UTC (permalink / raw)
To: Andrew Morton, baoquan.he, rppt, pasha.tatashin, pratyush,
ruirui.yang, corbet, skhan, rdunlap, muchun.song, osalvador,
david, jbohac, sourabhjain, ruanjinjie, leitao, linux-kernel,
kexec, linux-doc, linux-mm, kas, hannes, riel, shakeel.butt,
kernel-team
Cc: Usama Arif
crashkernel=size,cma reserves a separate CMA pool. On systems that
already reserve several gigabytes with hugetlb_cma= (which is common in
the Meta fleet), the crash kernel cannot use that existing memory as
part of its working set. With hugetlb_cma=6G, requesting another 2G
with crashkernel=2G,cma brings the total CMA reservation to 8G, none of
which can serve unmovable kernel allocations.
Allow crashkernel=size,hugetlb_cma to reuse existing hugetlb CMA memory.
For example:
hugetlb_cma=6G crashkernel=256M crashkernel=2G,hugetlb_cma
The full 6G remains available to HugeTLB and movable allocations during
normal operation. After a crash, the capture kernel can use 2G of it
as additional working memory. The conventional reservation is still
required to hold the kernel image and initrd.
Use a separate suffix to make the exclusion of existing HugeTLB
allocations from the vmcore an explicit choice. The capture kernel
can overwrite the selected ranges, including allocated HugeTLB pages.
The dump completeness and pending DMA risks of crashkernel=size,cma
apply here as well.
Register the physical ranges in crashk_cma_ranges[] from an early
initcall, after dedicated crash CMA reservations and before CMA
activation. Use the existing crashkernel CMA code for the capture
kernel's memory map, vmcore exclusion and DMA delay.
Use the remaining slots within the four-range limit, clip the final
range to the page-aligned request and report any shortfall. Reject
sizes that would overflow page rounding.
Suggested-by: Breno Leitao <leitao@debian.org>
Signed-off-by: Usama Arif <usama.arif@linux.dev>
---
.../ABI/testing/sysfs-kernel-kexec-kdump | 3 ++
Documentation/admin-guide/kdump/kdump.rst | 21 ++++++++
.../admin-guide/kernel-parameters.txt | 25 ++++++++++
include/linux/hugetlb.h | 12 +++++
kernel/crash_reserve.c | 49 +++++++++++++++++-
mm/hugetlb_cma.c | 50 +++++++++++++++++++
6 files changed, 158 insertions(+), 2 deletions(-)
diff --git a/Documentation/ABI/testing/sysfs-kernel-kexec-kdump b/Documentation/ABI/testing/sysfs-kernel-kexec-kdump
index f59051b5d96d7..b8aa614ddde48 100644
--- a/Documentation/ABI/testing/sysfs-kernel-kexec-kdump
+++ b/Documentation/ABI/testing/sysfs-kernel-kexec-kdump
@@ -58,4 +58,7 @@ Description: read only
the Contiguous Memory Allocator (CMA) area that are allocated
to the crash (kdump) kernel. It lists the start and end physical
addresses of CMA regions assigned for crashkernel use.
+ This includes existing HugeTLB CMA memory selected with
+ crashkernel=size,hugetlb_cma. These ranges remain usable
+ by the running kernel and are excluded from the vmcore.
User: kdump service
diff --git a/Documentation/admin-guide/kdump/kdump.rst b/Documentation/admin-guide/kdump/kdump.rst
index 7587caadbae1a..44f11ff338766 100644
--- a/Documentation/admin-guide/kdump/kdump.rst
+++ b/Documentation/admin-guide/kdump/kdump.rst
@@ -332,6 +332,27 @@ crashkernel syntax
less reliable and possibly incomplete kdump is preferable to no kdump at
all.
+5) crashkernel=size,hugetlb_cma
+
+ Reuse existing HugeTLB CMA memory as additional crash kernel memory after
+ a crash. For example, to reuse 2G of a 6G HugeTLB CMA reservation::
+
+ hugetlb_cma=6G crashkernel=256M crashkernel=2G,hugetlb_cma
+
+ A standard crashkernel reservation is still required for the kernel image
+ and initrd. The selected ranges remain available to HugeTLB and movable
+ allocations during normal operation. After a crash, the capture kernel
+ can overwrite their contents, including allocated HugeTLB pages, and the
+ ranges are excluded from the vmcore. The dump completeness and DMA risks
+ described for crashkernel=size,cma apply here too.
+
+ The kernel selects up to the requested size from the existing hugetlb CMA
+ areas. Both CMA options use the same limit of four physical ranges, with
+ crashkernel=size,cma ranges added first. If there is insufficient memory
+ or too few range slots, the kernel reports the shortfall and reuses the
+ available ranges. Unused pages in contributing CMA areas remain reserved
+ if CMA activation fails.
+
Boot into System Kernel
-----------------------
1) Update the boot loader (such as grub, yaboot, or lilo) configuration
diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt
index 0b3c140babd94..06b76125b5646 100644
--- a/Documentation/admin-guide/kernel-parameters.txt
+++ b/Documentation/admin-guide/kernel-parameters.txt
@@ -1121,6 +1121,31 @@ Kernel parameters
possibly incomplete kdump is preferable to no kdump at
all.
+ crashkernel=size[KMG],hugetlb_cma
+ [KNL, X86, ARM64, RISCV, PPC] Use up to the specified
+ amount of existing hugetlb_cma memory as additional crash
+ kernel memory. Requires hugetlb_cma= and a standard
+ crashkernel reservation for the kernel image and initrd.
+ For example:
+ hugetlb_cma=6G crashkernel=256M crashkernel=2G,hugetlb_cma
+
+ The selected memory remains available to HugeTLB and
+ movable allocations during normal operation. After a
+ crash, the capture kernel can overwrite these pages,
+ including allocated HugeTLB pages. The selected ranges
+ are excluded from the vmcore. The dump completeness
+ and DMA risks described for crashkernel=size,cma also
+ apply to this option.
+
+ Both CMA options use the same limit of four physical
+ ranges, with crashkernel=size,cma ranges added first.
+ If the available hugetlb CMA memory or range slots
+ cannot cover the requested size, the kernel reuses
+ what is available and reports the shortfall. Additional
+ CMA memory is not reserved by this option. Unused pages
+ in contributing CMA areas remain reserved if activation
+ fails.
+
cryptomgr.notests
[KNL] Disable crypto self-tests
diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h
index 58f755e70e966..69732e4cc03e2 100644
--- a/include/linux/hugetlb.h
+++ b/include/linux/hugetlb.h
@@ -1349,12 +1349,24 @@ static inline spinlock_t *huge_pte_lock(struct hstate *h,
return ptl;
}
+struct range;
+
#if defined(CONFIG_HUGETLB_PAGE) && defined(CONFIG_CMA)
extern void __init hugetlb_cma_reserve(void);
+unsigned long long __init
+hugetlb_cma_add_crashkernel_ranges(unsigned long long size, struct range *ranges,
+ int *nr_ranges, int max_ranges);
#else
static inline __init void hugetlb_cma_reserve(void)
{
}
+
+static inline unsigned long long
+hugetlb_cma_add_crashkernel_ranges(unsigned long long size, struct range *ranges,
+ int *nr_ranges, int max_ranges)
+{
+ return 0;
+}
#endif
#ifdef CONFIG_HUGETLB_PMD_PAGE_TABLE_SHARING
diff --git a/kernel/crash_reserve.c b/kernel/crash_reserve.c
index eee37a11380ce..a03f0a4305a4e 100644
--- a/kernel/crash_reserve.c
+++ b/kernel/crash_reserve.c
@@ -16,6 +16,7 @@
#include <linux/kmemleak.h>
#include <linux/cma.h>
#include <linux/crash_reserve.h>
+#include <linux/hugetlb.h>
#include <asm/page.h>
#include <asm/sections.h>
@@ -173,18 +174,20 @@ static int __init parse_crashkernel_simple(char *cmdline,
#define SUFFIX_HIGH 0
#define SUFFIX_LOW 1
#define SUFFIX_CMA 2
-#define SUFFIX_NULL 3
+#define SUFFIX_HUGETLB_CMA 3
+#define SUFFIX_NULL 4
static __initdata char *suffix_tbl[] = {
[SUFFIX_HIGH] = ",high",
[SUFFIX_LOW] = ",low",
[SUFFIX_CMA] = ",cma",
+ [SUFFIX_HUGETLB_CMA] = ",hugetlb_cma",
[SUFFIX_NULL] = NULL,
};
/*
* That function parses "suffix" crashkernel command lines like
*
- * crashkernel=size,[high|low|cma]
+ * crashkernel=size,[high|low|cma|hugetlb_cma]
*
* It returns 0 on success and -EINVAL on failure.
*/
@@ -519,6 +522,48 @@ void __init reserve_crashkernel_cma(unsigned long long cma_size)
}
#endif
+/* hugetlb CMA and the dedicated crash CMA reservation are both set up now. */
+static int __init crashk_hugetlb_cma_init(void)
+{
+ unsigned long long size, base;
+#ifdef CRASHKERNEL_CMA
+ unsigned long long reused_size;
+ int cnt = crashk_cma_cnt;
+#endif
+
+ /* The kernel image and initrd still need a dedicated reservation. */
+ if (crashk_res.start >= crashk_res.end)
+ return 0;
+
+ if (__parse_crashkernel(boot_command_line, 0, &size, &base,
+ suffix_tbl[SUFFIX_HUGETLB_CMA]) || !size)
+ return 0;
+
+ if (size > ULLONG_MAX - (PAGE_SIZE - 1)) {
+ pr_warn("crashkernel hugetlb CMA size is too large\n");
+ return 0;
+ }
+ size = roundup(size, PAGE_SIZE);
+
+#ifdef CRASHKERNEL_CMA
+ reused_size = hugetlb_cma_add_crashkernel_ranges(size, crashk_cma_ranges,
+ &crashk_cma_cnt,
+ CRASHKERNEL_CMA_RANGES_MAX);
+
+ if (reused_size < size)
+ pr_warn("crashkernel hugetlb CMA reuse failed: %llu MB requested, %llu MB reused in %d ranges\n",
+ size >> 20, reused_size >> 20, crashk_cma_cnt - cnt);
+ else
+ pr_info("crashkernel hugetlb CMA reused: %llu MB in %d ranges\n",
+ reused_size >> 20, crashk_cma_cnt - cnt);
+#else
+ pr_warn("crashkernel hugetlb CMA reuse not supported\n");
+#endif
+
+ return 0;
+}
+early_initcall(crashk_hugetlb_cma_init);
+
#ifndef HAVE_ARCH_ADD_CRASH_RES_TO_IOMEM_EARLY
static __init int insert_crashkernel_resources(void)
{
diff --git a/mm/hugetlb_cma.c b/mm/hugetlb_cma.c
index cd6a64986278a..cd6f64da31a2c 100644
--- a/mm/hugetlb_cma.c
+++ b/mm/hugetlb_cma.c
@@ -11,6 +11,8 @@
#include <linux/memblock.h>
#include <linux/math.h>
#include <linux/math64.h>
+#include <linux/range.h>
+#include "cma.h"
#include "internal.h"
#include "hugetlb_cma.h"
@@ -387,6 +389,54 @@ void __init hugetlb_cma_reserve(void)
hugetlb_cma_size = 0;
}
+/**
+ * hugetlb_cma_add_crashkernel_ranges - share HugeTLB CMA with the crash kernel
+ * @size: maximum number of bytes to share, aligned to PAGE_SIZE
+ * @ranges: crash kernel memory ranges
+ * @nr_ranges: number of entries already in @ranges, updated on return
+ * @max_ranges: capacity of @ranges
+ *
+ * The shared memory remains available to the HugeTLB allocator until a crash.
+ * Only physical ranges belonging to successfully reserved CMA areas are added.
+ *
+ * Return: number of bytes shared.
+ */
+unsigned long long __init
+hugetlb_cma_add_crashkernel_ranges(unsigned long long size, struct range *ranges,
+ int *nr_ranges, int max_ranges)
+{
+ unsigned long long shared_size = 0;
+ int nid, i;
+
+ for_each_node_mask(nid, hugetlb_bootmem_nodes) {
+ struct cma *cma = hugetlb_cma[nid];
+
+ if (!cma)
+ continue;
+
+ for (i = 0; i < cma->nranges; i++) {
+ struct cma_memrange *cmr = &cma->ranges[i];
+ unsigned long long range_size;
+ struct range *range;
+
+ if (shared_size == size || *nr_ranges == max_ranges)
+ return shared_size;
+
+ range_size = min_t(unsigned long long,
+ PFN_PHYS(cmr->count), size - shared_size);
+ range = &ranges[(*nr_ranges)++];
+ range->start = PFN_PHYS(cmr->base_pfn);
+ range->end = range->start + range_size - 1;
+ shared_size += range_size;
+
+ /* Keep shared pages reserved if CMA activation fails. */
+ cma_reserve_pages_on_error(cma);
+ }
+ }
+
+ return shared_size;
+}
+
bool hugetlb_cma_exclusive_alloc(void)
{
return hugetlb_cma_only;
--
2.53.0-Meta
^ permalink raw reply related [flat|nested] 5+ messages in thread
* Re: [PATCH] mm/hugetlb: allow crashkernel to reuse hugetlb CMA memory
2026-11-04 14:27 Usama Arif
@ 2026-11-04 15:20 ` Kiryl Shutsemau
2026-11-04 16:07 ` David Hildenbrand (Arm)
2026-11-04 16:15 ` Usama Arif
0 siblings, 2 replies; 5+ messages in thread
From: Kiryl Shutsemau @ 2026-11-04 15:20 UTC (permalink / raw)
To: Usama Arif
Cc: Andrew Morton, baoquan.he, rppt, pasha.tatashin, pratyush,
ruirui.yang, corbet, skhan, rdunlap, muchun.song, osalvador,
david, jbohac, sourabhjain, ruanjinjie, leitao, linux-kernel,
kexec, linux-doc, linux-mm, hannes, riel, shakeel.butt,
kernel-team
On Wed, Nov 04, 2026 at 06:27:27AM -0800, Usama Arif wrote:
> Use a separate suffix to make the exclusion of existing HugeTLB
> allocations from the vmcore an explicit choice.
The crashkernel=size,cma documentation already says that pages allocated
from the range are not in the vmcore and that it should not be used if
dumping of userspace memory is intended. HugeTLB pages are userspace
memory. I don't see what a new suffix makes explicit that ",cma" does
not already.
Why not let crashkernel=size,cma take hugetlb CMA first and reserve a
dedicated area only for what hugetlb CMA does not cover? With
hugetlb_cma=6G crashkernel=2G,cma there would be no extra CMA at all.
With hugetlb_cma=2G crashkernel=4G,cma the crash kernel would reuse the
2G and a dedicated 2G area would be reserved for the rest. Either way,
nobody has to learn a new option.
The catch is ordering. reserve_crashkernel_cma() runs from setup_arch(),
but hugetlb_cma_reserve() runs later, from mm_core_init_early(). The arch
code could record the size and leave the reservation to generic code
right after hugetlb_cma_reserve(). That is still memblock time, so the
remainder can be declared there. An early_initcall is too late for that.
--
Kiryl Shutsemau / Kirill A. Shutemov
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH] mm/hugetlb: allow crashkernel to reuse hugetlb CMA memory
2026-11-04 15:20 ` Kiryl Shutsemau
@ 2026-11-04 16:07 ` David Hildenbrand (Arm)
2026-11-04 16:15 ` Usama Arif
1 sibling, 0 replies; 5+ messages in thread
From: David Hildenbrand (Arm) @ 2026-11-04 16:07 UTC (permalink / raw)
To: Kiryl Shutsemau, Usama Arif
Cc: Andrew Morton, baoquan.he, rppt, pasha.tatashin, pratyush,
ruirui.yang, corbet, skhan, rdunlap, muchun.song, osalvador,
jbohac, sourabhjain, ruanjinjie, leitao, linux-kernel, kexec,
linux-doc, linux-mm, hannes, riel, shakeel.butt, kernel-team
On 11/4/26 16:20, Kiryl Shutsemau wrote:
> On Wed, Nov 04, 2026 at 06:27:27AM -0800, Usama Arif wrote:
>> Use a separate suffix to make the exclusion of existing HugeTLB
>> allocations from the vmcore an explicit choice.
>
> The crashkernel=size,cma documentation already says that pages allocated
> from the range are not in the vmcore and that it should not be used if
> dumping of userspace memory is intended. HugeTLB pages are userspace
> memory. I don't see what a new suffix makes explicit that ",cma" does
> not already.
>
> Why not let crashkernel=size,cma take hugetlb CMA first and reserve a
> dedicated area only for what hugetlb CMA does not cover? With
> hugetlb_cma=6G crashkernel=2G,cma there would be no extra CMA at all.
Hiding that complexity from the user would indeed be nice.
--
Cheers,
David
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH] mm/hugetlb: allow crashkernel to reuse hugetlb CMA memory
2026-11-04 15:20 ` Kiryl Shutsemau
2026-11-04 16:07 ` David Hildenbrand (Arm)
@ 2026-11-04 16:15 ` Usama Arif
1 sibling, 0 replies; 5+ messages in thread
From: Usama Arif @ 2026-11-04 16:15 UTC (permalink / raw)
To: Kiryl Shutsemau
Cc: Andrew Morton, baoquan.he, rppt, pasha.tatashin, pratyush,
ruirui.yang, corbet, skhan, rdunlap, muchun.song, osalvador,
david, jbohac, sourabhjain, ruanjinjie, leitao, linux-kernel,
kexec, linux-doc, linux-mm, hannes, riel, shakeel.butt,
kernel-team
On 04/11/2026 15:20, Kiryl Shutsemau wrote:
> On Wed, Nov 04, 2026 at 06:27:27AM -0800, Usama Arif wrote:
>> Use a separate suffix to make the exclusion of existing HugeTLB
>> allocations from the vmcore an explicit choice.
>
> The crashkernel=size,cma documentation already says that pages allocated
> from the range are not in the vmcore and that it should not be used if
> dumping of userspace memory is intended. HugeTLB pages are userspace
> memory. I don't see what a new suffix makes explicit that ",cma" does
> not already.
>
> Why not let crashkernel=size,cma take hugetlb CMA first and reserve a
> dedicated area only for what hugetlb CMA does not cover? With
> hugetlb_cma=6G crashkernel=2G,cma there would be no extra CMA at all.
> With hugetlb_cma=2G crashkernel=4G,cma the crash kernel would reuse the
> 2G and a dedicated 2G area would be reserved for the rest. Either way,
> nobody has to learn a new option.
>
> The catch is ordering. reserve_crashkernel_cma() runs from setup_arch(),
> but hugetlb_cma_reserve() runs later, from mm_core_init_early(). The arch
> code could record the size and leave the reservation to generic code
> right after hugetlb_cma_reserve(). That is still memblock time, so the
> remainder can be declared there. An early_initcall is too late for that.
>
Makes sense to me, I will rewrite it in the above way and send v2.
Thanks for the review!
Usama
^ permalink raw reply [flat|nested] 5+ messages in thread
* [PATCH] mm/hugetlb: allow crashkernel to reuse hugetlb CMA memory
@ 2026-11-16 19:42 Andrew Morton
0 siblings, 0 replies; 5+ messages in thread
From: Andrew Morton @ 2026-11-16 19:42 UTC (permalink / raw)
To: Mike Rapoport (Microsoft)
Cc: linux-mm, Andrew Morton, Usama Arif, Breno Leitao, Bradley Morgan,
Kiryl Shutsemau (Meta), Baoquan He, Pasha Tatashin,
Pratyush Yadav, ruirui.yang, Jonathan Corbet, skhan, Randy Dunlap,
Muchun Song, Oscar Salvador, David Hildenbrand, Jiri Bohac,
Sourabh Jain, Jinjie Ruan, Johannes Weiner, Rik van Riel,
Shakeel Butt, Mikhail Zaslonko
From: Usama Arif <usama.arif@linux.dev>
Subject: mm/hugetlb: allow crashkernel to reuse hugetlb CMA memory
Date: Fri, 06 Nov 2026 08:51:42 -0800
crashkernel=size,cma reserves a separate CMA pool. On systems that
already reserve several gigabytes with hugetlb_cma= (which is common in
the Meta fleet), the crash kernel cannot use that existing memory as part
of its working set. With hugetlb_cma=6G, requesting another 2G with
crashkernel=2G,cma brings the total CMA reservation to 8G, none of which
can serve unmovable kernel allocations.
Use existing HugeTLB CMA memory first for crashkernel=size,cma and reserve
dedicated CMA areas only for the remainder. With hugetlb_cma=6G, a 2G
request reuses 2G without reserving more CMA. With hugetlb_cma=2G, a 4G
request reuses 2G and reserves another 2G.
The full HugeTLB CMA pool remains available to HugeTLB and movable
allocations during normal operation. After a crash, the capture kernel
can use the selected ranges as working memory. The conventional
reservation is still required to hold the kernel image and initrd.
The ,cma option already opts into excluding userspace memory from the
vmcore. This includes allocated HugeTLB pages in the selected ranges,
which the capture kernel can overwrite. The existing dump completeness
and pending DMA risks apply to these ranges as well.
Have architecture code record the requested CMA size and perform the
reservation in mm_core_init_early(), immediately after
hugetlb_cma_reserve(). The HugeTLB CMA areas are then available for reuse
while memblock can still reserve any remainder.
Use the existing four range slots for both reused and dedicated memory.
Limit reused memory to the page-aligned request, account for dedicated CMA
alignment, and report any shortfall. Ignore malformed optional sizes and
reject requests that would overflow page rounding.
Link: https://lore.kernel.org/20261106165142.2847916-1-usama.arif@linux.dev
Signed-off-by: Usama Arif <usama.arif@linux.dev>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Suggested-by: Breno Leitao <leitao@debian.org>
Reviewed-by: Bradley Morgan <bradley.morgan@linux.dev>
Acked-by: Kiryl Shutsemau (Meta) <kas@kernel.org>
Acked-by: Mike Rapoport (Microsoft) <rppt@kernel.org>
Cc: Baoquan He <baoquan.he@linux.dev>
Cc: Pasha Tatashin <pasha.tatashin@soleen.com>
Cc: Pratyush Yadav <pratyush@kernel.org>
Cc: <ruirui.yang@linux.dev>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: <skhan@linuxfoundation.org>
Cc: Randy Dunlap <rdunlap@infradead.org>
Cc: Muchun Song <muchun.song@linux.dev>
Cc: Oscar Salvador <osalvador@suse.de>
Cc: David Hildenbrand <david@kernel.org>
Cc: Jiri Bohac <jbohac@suse.cz>
Cc: Sourabh Jain <sourabhjain@linux.ibm.com>
Cc: Jinjie Ruan <ruanjinjie@huawei.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Rik van Riel <riel@surriel.com>
Cc: Shakeel Butt <shakeel.butt@linux.dev>
Cc: Mikhail Zaslonko <zaslonko@linux.ibm.com>
Documentation/ABI/testing/sysfs-kernel-kexec-kdump | 3
Documentation/admin-guide/kdump/kdump.rst | 22 ++++
Documentation/admin-guide/kernel-parameters.txt | 16 +++
arch/arm64/mm/init.c | 2
arch/powerpc/include/asm/kexec.h | 2
arch/powerpc/kexec/core.c | 12 --
arch/powerpc/mm/mem.c | 6 -
arch/riscv/mm/init.c | 2
arch/x86/kernel/setup.c | 2
include/linux/crash_reserve.h | 14 ++-
include/linux/hugetlb.h | 12 ++
kernel/crash_reserve.c | 51 +++++++----
mm/hugetlb_cma.c | 50 ++++++++++
mm/mm_init.c | 2
14 files changed, 159 insertions(+), 37 deletions(-)
--- a/arch/arm64/mm/init.c~mm-hugetlb-allow-crashkernel-to-reuse-hugetlb-cma-memory
+++ a/arch/arm64/mm/init.c
@@ -114,7 +114,7 @@ static void __init arch_reserve_crashker
return;
reserve_crashkernel_generic(crash_size, crash_base, low_size, high);
- reserve_crashkernel_cma(cma_size);
+ crashkernel_cma_set_size(cma_size);
}
static phys_addr_t __init max_zone_phys(phys_addr_t zone_limit)
--- a/arch/powerpc/include/asm/kexec.h~mm-hugetlb-allow-crashkernel-to-reuse-hugetlb-cma-memory
+++ a/arch/powerpc/include/asm/kexec.h
@@ -117,11 +117,9 @@ int setup_new_fdt_ppc64(const struct kim
#ifdef CONFIG_CRASH_RESERVE
int __init overlaps_crashkernel(unsigned long start, unsigned long size);
extern void arch_reserve_crashkernel(void);
-extern void kdump_cma_reserve(void);
#else
static inline void arch_reserve_crashkernel(void) {}
static inline int overlaps_crashkernel(unsigned long start, unsigned long size) { return 0; }
-static inline void kdump_cma_reserve(void) { }
#endif
#if defined(CONFIG_CRASH_DUMP)
--- a/arch/powerpc/kexec/core.c~mm-hugetlb-allow-crashkernel-to-reuse-hugetlb-cma-memory
+++ a/arch/powerpc/kexec/core.c
@@ -62,8 +62,6 @@ void machine_kexec(struct kimage *image)
#ifdef CONFIG_CRASH_RESERVE
-static unsigned long long crashk_cma_size;
-
static unsigned long long __init get_crash_base(unsigned long long crash_base)
{
@@ -107,6 +105,7 @@ static unsigned long long __init get_cra
void __init arch_reserve_crashkernel(void)
{
unsigned long long crash_size, crash_base, crash_end;
+ unsigned long long cma_size = 0;
unsigned long long kernel_start, kernel_size;
unsigned long long total_mem_sz;
int ret;
@@ -115,7 +114,7 @@ void __init arch_reserve_crashkernel(voi
/* use common parsing */
ret = parse_crashkernel(boot_command_line, total_mem_sz, &crash_size,
- &crash_base, NULL, &crashk_cma_size, NULL);
+ &crash_base, NULL, &cma_size, NULL);
if (ret)
return;
@@ -133,12 +132,7 @@ void __init arch_reserve_crashkernel(voi
}
reserve_crashkernel_generic(crash_size, crash_base, 0, false);
-}
-
-void __init kdump_cma_reserve(void)
-{
- if (crashk_cma_size)
- reserve_crashkernel_cma(crashk_cma_size);
+ crashkernel_cma_set_size(cma_size);
}
int __init overlaps_crashkernel(unsigned long start, unsigned long size)
--- a/arch/powerpc/mm/mem.c~mm-hugetlb-allow-crashkernel-to-reuse-hugetlb-cma-memory
+++ a/arch/powerpc/mm/mem.c
@@ -271,12 +271,10 @@ void __init arch_mm_preinit(void)
{
/*
- * Reserve large chunks of memory for use by CMA for kdump, fadump, KVM
- * and hugetlb. These must be called after pageblock_order is
- * initialised.
+ * Reserve large chunks of memory for use by CMA for fadump and KVM.
+ * These must be called after pageblock_order is initialised.
*/
fadump_cma_init();
- kdump_cma_reserve();
kvm_cma_reserve();
/*
--- a/arch/riscv/mm/init.c~mm-hugetlb-allow-crashkernel-to-reuse-hugetlb-cma-memory
+++ a/arch/riscv/mm/init.c
@@ -1357,7 +1357,7 @@ static void __init arch_reserve_crashker
return;
reserve_crashkernel_generic(crash_size, crash_base, low_size, high);
- reserve_crashkernel_cma(cma_size);
+ crashkernel_cma_set_size(cma_size);
}
void __init paging_init(void)
--- a/arch/x86/kernel/setup.c~mm-hugetlb-allow-crashkernel-to-reuse-hugetlb-cma-memory
+++ a/arch/x86/kernel/setup.c
@@ -627,7 +627,7 @@ static void __init arch_reserve_crashker
}
reserve_crashkernel_generic(crash_size, crash_base, low_size, high);
- reserve_crashkernel_cma(cma_size);
+ crashkernel_cma_set_size(cma_size);
}
static struct resource standard_io_resources[] = {
--- a/Documentation/ABI/testing/sysfs-kernel-kexec-kdump~mm-hugetlb-allow-crashkernel-to-reuse-hugetlb-cma-memory
+++ a/Documentation/ABI/testing/sysfs-kernel-kexec-kdump
@@ -58,4 +58,7 @@ Description: read only
the Contiguous Memory Allocator (CMA) area that are allocated
to the crash (kdump) kernel. It lists the start and end physical
addresses of CMA regions assigned for crashkernel use.
+ This includes existing HugeTLB CMA memory selected with
+ crashkernel=size,cma. These ranges remain usable
+ by the running kernel and are excluded from the vmcore.
User: kdump service
--- a/Documentation/admin-guide/kdump/kdump.rst~mm-hugetlb-allow-crashkernel-to-reuse-hugetlb-cma-memory
+++ a/Documentation/admin-guide/kdump/kdump.rst
@@ -313,9 +313,25 @@ crashkernel syntax
4) crashkernel=size,cma
- Reserve additional crash kernel memory from CMA. This reservation is
- usable by the first system's userspace memory and kernel movable
- allocations (memory balloon, zswap). Pages allocated from this memory
+ Reserve additional crash kernel memory from CMA. Existing HugeTLB CMA
+ memory is used first, and dedicated CMA areas are reserved for any
+ remaining amount. For example, this reuses 2G from the existing 6G pool
+ without reserving additional CMA memory::
+
+ hugetlb_cma=6G crashkernel=256M crashkernel=2G,cma
+
+ With a smaller HugeTLB CMA pool, the remainder is reserved separately::
+
+ hugetlb_cma=2G crashkernel=256M crashkernel=4G,cma
+
+ This reuses the existing 2G and reserves another 2G of dedicated CMA.
+ Both kinds of area use the same limit of four physical ranges. If there
+ is insufficient memory or too few range slots, the kernel reports the
+ shortfall. Normal CMA alignment applies to dedicated reservations.
+
+ The selected memory remains usable by the first system's userspace,
+ including HugeTLB allocations, and kernel movable allocations
+ (memory balloon, zswap). Pages allocated from this memory
range will not be included in the vmcore so this should not be used if
dumping of userspace memory is intended and it has to be expected that
some movable kernel pages may be missing from the dump.
--- a/Documentation/admin-guide/kernel-parameters.txt~mm-hugetlb-allow-crashkernel-to-reuse-hugetlb-cma-memory
+++ a/Documentation/admin-guide/kernel-parameters.txt
@@ -1100,7 +1100,21 @@ Kernel parameters
or memory reserved is below 4G.
crashkernel=size[KMG],cma
[KNL, X86, ARM64, RISCV, PPC] Reserve additional crash
- kernel memory from CMA. This reservation is usable by
+ kernel memory from CMA. Existing hugetlb_cma memory is
+ used first, and dedicated CMA areas are reserved for any
+ remaining amount. For example:
+ hugetlb_cma=6G crashkernel=256M crashkernel=2G,cma
+ reuses 2G without reserving more CMA, while:
+ hugetlb_cma=2G crashkernel=256M crashkernel=4G,cma
+ reuses 2G and reserves another 2G of dedicated CMA.
+
+ Both kinds of area use the same limit of four physical
+ ranges. If the available memory or range slots cannot
+ cover the requested size, the kernel reports the
+ shortfall. Normal CMA alignment applies to dedicated
+ reservations.
+
+ The selected memory remains usable by
the first system's userspace memory and kernel movable
allocations (memory balloon, zswap). Pages allocated
from this memory range will not be included in the vmcore
--- a/include/linux/crash_reserve.h~mm-hugetlb-allow-crashkernel-to-reuse-hugetlb-cma-memory
+++ a/include/linux/crash_reserve.h
@@ -5,6 +5,7 @@
#include <linux/linkage.h>
#include <linux/elfcore.h>
#include <linux/elf.h>
+#include <linux/range.h>
#ifdef CONFIG_ARCH_HAS_GENERIC_CRASHKERNEL_RESERVATION
#include <asm/crash_reserve.h>
#endif
@@ -31,7 +32,18 @@ int __init parse_crashkernel(char *cmdli
unsigned long long *low_size, unsigned long long *cma_size,
bool *high);
-void __init reserve_crashkernel_cma(unsigned long long cma_size);
+#if defined(CONFIG_CRASH_RESERVE) && defined(CONFIG_ARCH_HAS_GENERIC_CRASHKERNEL_RESERVATION)
+void __init crashkernel_cma_set_size(unsigned long long size);
+void __init reserve_crashkernel_cma(void);
+#else
+static inline void __init crashkernel_cma_set_size(unsigned long long size)
+{
+}
+
+static inline void __init reserve_crashkernel_cma(void)
+{
+}
+#endif
#ifdef CONFIG_ARCH_HAS_GENERIC_CRASHKERNEL_RESERVATION
#ifndef arch_add_crash_res_to_iomem
--- a/include/linux/hugetlb.h~mm-hugetlb-allow-crashkernel-to-reuse-hugetlb-cma-memory
+++ a/include/linux/hugetlb.h
@@ -1349,12 +1349,24 @@ static inline spinlock_t *huge_pte_lock(
return ptl;
}
+struct range;
+
#if defined(CONFIG_HUGETLB_PAGE) && defined(CONFIG_CMA)
extern void __init hugetlb_cma_reserve(void);
+unsigned long long __init
+hugetlb_cma_add_crashkernel_ranges(unsigned long long size, struct range *ranges,
+ int *nr_ranges, int max_ranges);
#else
static inline __init void hugetlb_cma_reserve(void)
{
}
+
+static inline unsigned long long
+hugetlb_cma_add_crashkernel_ranges(unsigned long long size, struct range *ranges,
+ int *nr_ranges, int max_ranges)
+{
+ return 0;
+}
#endif
#ifdef CONFIG_HUGETLB_PMD_PAGE_TABLE_SHARING
--- a/kernel/crash_reserve.c~mm-hugetlb-allow-crashkernel-to-reuse-hugetlb-cma-memory
+++ a/kernel/crash_reserve.c
@@ -16,6 +16,7 @@
#include <linux/kmemleak.h>
#include <linux/cma.h>
#include <linux/crash_reserve.h>
+#include <linux/hugetlb.h>
#include <asm/page.h>
#include <asm/sections.h>
@@ -340,9 +341,9 @@ int __init parse_crashkernel(char *cmdli
* optional CMA reservation
* cma_base is ignored
*/
- if (cma_size)
- __parse_crashkernel(cmdline, 0, cma_size,
- &cma_base, suffix_tbl[SUFFIX_CMA]);
+ if (cma_size && __parse_crashkernel(cmdline, 0, cma_size,
+ &cma_base, suffix_tbl[SUFFIX_CMA]))
+ *cma_size = 0;
#endif
if (!*crash_size)
ret = -EINVAL;
@@ -470,21 +471,41 @@ retry:
}
struct range crashk_cma_ranges[CRASHKERNEL_CMA_RANGES_MAX];
+static unsigned long long crashkernel_cma_size __initdata;
+
+void __init crashkernel_cma_set_size(unsigned long long cma_size)
+{
+ crashkernel_cma_size = cma_size;
+}
+
#ifdef CRASHKERNEL_CMA
int crashk_cma_cnt;
-void __init reserve_crashkernel_cma(unsigned long long cma_size)
+void __init reserve_crashkernel_cma(void)
{
- unsigned long long request_size = roundup(cma_size, PAGE_SIZE);
- unsigned long long reserved_size = 0;
+ unsigned long long cma_size = crashkernel_cma_size;
+ unsigned long long request_size, reserved_size, reused_size;
- if (!cma_size)
+ if (!cma_size || crashk_res.start >= crashk_res.end)
return;
+ if (cma_size > ULLONG_MAX - (PAGE_SIZE - 1)) {
+ pr_warn("crashkernel CMA size is too large\n");
+ return;
+ }
+ cma_size = roundup(cma_size, PAGE_SIZE);
+ reused_size = hugetlb_cma_add_crashkernel_ranges(cma_size,
+ crashk_cma_ranges,
+ &crashk_cma_cnt,
+ CRASHKERNEL_CMA_RANGES_MAX);
+ reserved_size = reused_size;
+ request_size = cma_size - reused_size;
+
while (cma_size > reserved_size &&
crashk_cma_cnt < CRASHKERNEL_CMA_RANGES_MAX) {
struct cma *res;
+ request_size = min(request_size, cma_size - reserved_size);
if (cma_declare_contiguous(0, request_size, 0, 0, 0, false,
"crashkernel", &res)) {
/* reservation failed, try half-sized blocks */
@@ -500,21 +521,23 @@ void __init reserve_crashkernel_cma(unsi
crashk_cma_ranges[crashk_cma_cnt].start +
cma_get_size(res) - 1;
++crashk_cma_cnt;
- reserved_size += request_size;
+ reserved_size += cma_get_size(res);
}
if (cma_size > reserved_size)
- pr_warn("crashkernel CMA reservation failed: %lld MB requested, %lld MB reserved in %d ranges\n",
- cma_size >> 20, reserved_size >> 20, crashk_cma_cnt);
+ pr_warn("crashkernel CMA reservation failed: %llu MB requested, %llu MB reused, %llu MB newly reserved in %d ranges\n",
+ cma_size >> 20, reused_size >> 20,
+ (reserved_size - reused_size) >> 20, crashk_cma_cnt);
else
- pr_info("crashkernel CMA reserved: %lld MB in %d ranges\n",
- reserved_size >> 20, crashk_cma_cnt);
+ pr_info("crashkernel CMA: %llu MB reused, %llu MB newly reserved in %d ranges\n",
+ reused_size >> 20, (reserved_size - reused_size) >> 20,
+ crashk_cma_cnt);
}
#else /* CRASHKERNEL_CMA */
-void __init reserve_crashkernel_cma(unsigned long long cma_size)
+void __init reserve_crashkernel_cma(void)
{
- if (cma_size)
+ if (crashkernel_cma_size)
pr_warn("crashkernel CMA reservation not supported\n");
}
#endif
--- a/mm/hugetlb_cma.c~mm-hugetlb-allow-crashkernel-to-reuse-hugetlb-cma-memory
+++ a/mm/hugetlb_cma.c
@@ -11,6 +11,8 @@
#include <linux/memblock.h>
#include <linux/math.h>
#include <linux/math64.h>
+#include <linux/range.h>
+#include "cma.h"
#include "internal.h"
#include "hugetlb_cma.h"
@@ -387,6 +389,54 @@ void __init hugetlb_cma_reserve(void)
hugetlb_cma_size = 0;
}
+/**
+ * hugetlb_cma_add_crashkernel_ranges - share HugeTLB CMA with the crash kernel
+ * @size: maximum number of bytes to share, aligned to PAGE_SIZE
+ * @ranges: crash kernel memory ranges
+ * @nr_ranges: number of entries already in @ranges, updated on return
+ * @max_ranges: capacity of @ranges
+ *
+ * The shared memory remains available to the HugeTLB allocator until a crash.
+ * Only physical ranges belonging to successfully reserved CMA areas are added.
+ *
+ * Return: number of bytes shared.
+ */
+unsigned long long __init
+hugetlb_cma_add_crashkernel_ranges(unsigned long long size, struct range *ranges,
+ int *nr_ranges, int max_ranges)
+{
+ unsigned long long shared_size = 0;
+ int nid, i;
+
+ for_each_node_mask(nid, hugetlb_bootmem_nodes) {
+ struct cma *cma = hugetlb_cma[nid];
+
+ if (!cma)
+ continue;
+
+ for (i = 0; i < cma->nranges; i++) {
+ struct cma_memrange *cmr = &cma->ranges[i];
+ unsigned long long range_size;
+ struct range *range;
+
+ if (shared_size == size || *nr_ranges == max_ranges)
+ return shared_size;
+
+ range_size = min_t(unsigned long long,
+ PFN_PHYS(cmr->count), size - shared_size);
+ range = &ranges[(*nr_ranges)++];
+ range->start = PFN_PHYS(cmr->base_pfn);
+ range->end = range->start + range_size - 1;
+ shared_size += range_size;
+
+ /* Keep shared pages reserved if CMA activation fails. */
+ cma_reserve_pages_on_error(cma);
+ }
+ }
+
+ return shared_size;
+}
+
bool hugetlb_cma_exclusive_alloc(void)
{
return hugetlb_cma_only;
--- a/mm/mm_init.c~mm-hugetlb-allow-crashkernel-to-reuse-hugetlb-cma-memory
+++ a/mm/mm_init.c
@@ -28,6 +28,7 @@
#include <linux/swap.h>
#include <linux/cma.h>
#include <linux/crash_dump.h>
+#include <linux/crash_reserve.h>
#include <linux/execmem.h>
#include <linux/sizes.h>
#include <linux/vmstat.h>
@@ -2686,6 +2687,7 @@ void __init mm_core_init_early(void)
free_area_init();
hugetlb_cma_reserve();
+ reserve_crashkernel_cma();
hugetlb_bootmem_alloc();
sparse_init();
_
^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2026-11-16 19:43 UTC | newest]
Thread overview: 5+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-16 19:42 [PATCH] mm/hugetlb: allow crashkernel to reuse hugetlb CMA memory Andrew Morton
-- strict thread matches above, loose matches on Subject: below --
2026-11-04 14:27 Usama Arif
2026-11-04 15:20 ` Kiryl Shutsemau
2026-11-04 16:07 ` David Hildenbrand (Arm)
2026-11-04 16:15 ` Usama Arif
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox