From 63461eb73eaf4a193370072bbe446c2d773366e4 Mon Sep 17 00:00:00 2001 From: Wandun Chen Date: Wed, 27 May 2026 11:29:07 +0800 Subject: [PATCH 01/11] of: reserved_mem: handle NULL name in of_reserved_mem_lookup() Prepare for an upcoming change that appends /memreserve/ entries to reserved_mem[]; such entries have no name. No functional change. Signed-off-by: Wandun Chen Signed-off-by: Linux RISC-V bot --- drivers/of/of_reserved_mem.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/drivers/of/of_reserved_mem.c b/drivers/of/of_reserved_mem.c index 8d5777cb5d1b3d..313cbc57aa4534 100644 --- a/drivers/of/of_reserved_mem.c +++ b/drivers/of/of_reserved_mem.c @@ -788,7 +788,8 @@ struct reserved_mem *of_reserved_mem_lookup(struct device_node *np) name = kbasename(np->full_name); for (i = 0; i < reserved_mem_count; i++) - if (!strcmp(reserved_mem[i].name, name)) + if (reserved_mem[i].name && + !strcmp(reserved_mem[i].name, name)) return &reserved_mem[i]; return NULL; From 4f5d233d004ef8e9546866a6b2eac57a18a5adf6 Mon Sep 17 00:00:00 2001 From: Wandun Chen Date: Wed, 27 May 2026 11:29:08 +0800 Subject: [PATCH 02/11] kexec/crash: provide crash_exclude_mem_range() stub when CONFIG_CRASH_DUMP=n Prepare for an upcoming change that excludes non-dumpable reserved regions from the kdump vmcore and will call crash_exclude_mem_range() from generic, non-arch code. No functional change. Signed-off-by: Wandun Chen Signed-off-by: Linux RISC-V bot --- include/linux/crash_core.h | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/include/linux/crash_core.h b/include/linux/crash_core.h index c1dee3f971a918..0033d477764873 100644 --- a/include/linux/crash_core.h +++ b/include/linux/crash_core.h @@ -87,6 +87,12 @@ static inline int kexec_should_crash(struct task_struct *p) { return 0; } static inline int kexec_crash_loaded(void) { return 0; } static inline void crash_save_cpu(struct pt_regs *regs, int cpu) {}; static inline int kimage_crash_copy_vmcoreinfo(struct kimage *image) { return 0; }; +static inline int crash_exclude_mem_range(struct crash_mem *mem, + unsigned long long mstart, + unsigned long long mend) +{ + return 0; +} #endif /* CONFIG_CRASH_DUMP*/ #ifdef CONFIG_CRASH_DM_CRYPT From 745252cb549529a51fbd2cf56638ce335a5e5956 Mon Sep 17 00:00:00 2001 From: Wandun Chen Date: Wed, 27 May 2026 11:29:09 +0800 Subject: [PATCH 03/11] of: reserved_mem: avoid post-init UAF when alloc_reserved_mem_array() fails The global pointer 'reserved_mem' continues to reference the reserved_mem_array which lives in __initdata if alloc_reserved_mem_array() fails. of_reserved_mem_lookup() is exported for post-init use, that would dereference freed memory and trigger a use-after-free. So reset reserved_mem_count to 0 when alloc_reserved_mem_array() fails. Fixes: 00c9a452a235 ("of: reserved_mem: Add code to dynamically allocate reserved_mem array") Signed-off-by: Wandun Chen Signed-off-by: Linux RISC-V bot --- drivers/of/of_reserved_mem.c | 20 ++++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-) diff --git a/drivers/of/of_reserved_mem.c b/drivers/of/of_reserved_mem.c index 313cbc57aa4534..6d479381ff1fd1 100644 --- a/drivers/of/of_reserved_mem.c +++ b/drivers/of/of_reserved_mem.c @@ -69,29 +69,31 @@ static int __init early_init_dt_alloc_reserved_memory_arch(phys_addr_t size, * the initial static array is copied over to this new array and * the new array is used from this point on. */ -static void __init alloc_reserved_mem_array(void) +static bool __init alloc_reserved_mem_array(void) { struct reserved_mem *new_array; size_t alloc_size, copy_size, memset_size; + if (!total_reserved_mem_cnt) + return true; + alloc_size = array_size(total_reserved_mem_cnt, sizeof(*new_array)); if (alloc_size == SIZE_MAX) { pr_err("Failed to allocate memory for reserved_mem array with err: %d", -EOVERFLOW); - return; + goto fail; } new_array = memblock_alloc(alloc_size, SMP_CACHE_BYTES); if (!new_array) { pr_err("Failed to allocate memory for reserved_mem array with err: %d", -ENOMEM); - return; + goto fail; } copy_size = array_size(reserved_mem_count, sizeof(*new_array)); if (copy_size == SIZE_MAX) { memblock_free(new_array, alloc_size); - total_reserved_mem_cnt = MAX_RESERVED_REGIONS; pr_err("Failed to allocate memory for reserved_mem array with err: %d", -EOVERFLOW); - return; + goto fail; } memset_size = alloc_size - copy_size; @@ -100,6 +102,11 @@ static void __init alloc_reserved_mem_array(void) memset(new_array + reserved_mem_count, 0, memset_size); reserved_mem = new_array; + return true; + +fail: + reserved_mem_count = 0; + return false; } static void fdt_init_reserved_mem_node(unsigned long node, const char *uname, @@ -266,7 +273,8 @@ void __init fdt_scan_reserved_mem_late(void) } /* Attempt dynamic allocation of a new reserved_mem array */ - alloc_reserved_mem_array(); + if (!alloc_reserved_mem_array()) + return; if (__reserved_mem_check_root(node)) { pr_err("Reserved memory: unsupported node format, ignoring\n"); From 4ca98ad5adf410f829b525d2cd82b8d67db74a6e Mon Sep 17 00:00:00 2001 From: Wandun Chen Date: Wed, 27 May 2026 11:29:10 +0800 Subject: [PATCH 04/11] of: reserved_mem: zero total_reserved_mem_cnt if no valid /reserved-memory entry Prepare for storing /memreserve/ entries in the reserved_mem array. Zero total_reserved_mem_cnt if no valid /reserved-memory entry, instead of keeping it's initial value of MAX_RESERVED_REGIONS, this allows accounting /memreserve entries based on total_reserved_mem_cnt in a follow-up patch. No functional change. Signed-off-by: Wandun Chen Signed-off-by: Linux RISC-V bot --- drivers/of/of_reserved_mem.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/drivers/of/of_reserved_mem.c b/drivers/of/of_reserved_mem.c index 6d479381ff1fd1..05defc91e90155 100644 --- a/drivers/of/of_reserved_mem.c +++ b/drivers/of/of_reserved_mem.c @@ -329,11 +329,14 @@ int __init fdt_scan_reserved_mem(void) const void *fdt = initial_boot_params; node = fdt_path_offset(fdt, "/reserved-memory"); - if (node < 0) + if (node < 0) { + total_reserved_mem_cnt = 0; return -ENODEV; + } if (__reserved_mem_check_root(node) != 0) { pr_err("Reserved memory: unsupported node format, ignoring\n"); + total_reserved_mem_cnt = 0; return -EINVAL; } From 85f7084e21e8ba9835f1aa8b8c48122291aa518b Mon Sep 17 00:00:00 2001 From: Wandun Chen Date: Wed, 27 May 2026 11:29:11 +0800 Subject: [PATCH 05/11] of: reserved_mem: split alloc_reserved_mem_array() from fdt_scan_reserved_mem_late() Prepare for storing /memreserve/ entries in the reserved_mem array. alloc_reserved_mem_array is skipped if the device tree lacks a /reserved-memory node, pointer 'reserved_mem' continues to reference the reserved_mem_array which lives in __initdata, storing /memreserve/ entries into reserved_mem_array would result in metadata loss, and an out-of-bounds memory access will occur if the device tree contains more than MAX_RESERVED_REGIONS /memreserve/ entries. So split alloc_reserved_mem_array() from fdt_scan_reserved_mem_late(), and call alloc_reserved_mem_array() whether or not there is a /reserved-memory node. No functional change. The actual /memreserve/ population is added in a follow-up patch. Signed-off-by: Wandun Chen Signed-off-by: Linux RISC-V bot --- drivers/of/fdt.c | 7 +++++-- drivers/of/of_private.h | 1 + drivers/of/of_reserved_mem.c | 6 +----- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/drivers/of/fdt.c b/drivers/of/fdt.c index 82f7327c59ea90..83a2a474831e5b 100644 --- a/drivers/of/fdt.c +++ b/drivers/of/fdt.c @@ -1284,8 +1284,11 @@ void __init unflatten_device_tree(void) { void *fdt = initial_boot_params; - /* Save the statically-placed regions in the reserved_mem array */ - fdt_scan_reserved_mem_late(); + /* Attempt dynamic allocation of a new reserved_mem array */ + if (fdt && alloc_reserved_mem_array()) { + /* Save the statically-placed regions in the reserved_mem array */ + fdt_scan_reserved_mem_late(); + } /* Populate an empty root node when bootloader doesn't provide one */ if (!fdt) { diff --git a/drivers/of/of_private.h b/drivers/of/of_private.h index 0ae16da066e2c7..50e5a533e0591e 100644 --- a/drivers/of/of_private.h +++ b/drivers/of/of_private.h @@ -187,6 +187,7 @@ static inline struct device_node *__of_get_dma_parent(const struct device_node * int fdt_scan_reserved_mem(void); void __init fdt_scan_reserved_mem_late(void); +bool __init alloc_reserved_mem_array(void); bool of_fdt_device_is_available(const void *blob, unsigned long node); diff --git a/drivers/of/of_reserved_mem.c b/drivers/of/of_reserved_mem.c index 05defc91e90155..888dcb6bdce5b5 100644 --- a/drivers/of/of_reserved_mem.c +++ b/drivers/of/of_reserved_mem.c @@ -69,7 +69,7 @@ static int __init early_init_dt_alloc_reserved_memory_arch(phys_addr_t size, * the initial static array is copied over to this new array and * the new array is used from this point on. */ -static bool __init alloc_reserved_mem_array(void) +bool __init alloc_reserved_mem_array(void) { struct reserved_mem *new_array; size_t alloc_size, copy_size, memset_size; @@ -272,10 +272,6 @@ void __init fdt_scan_reserved_mem_late(void) return; } - /* Attempt dynamic allocation of a new reserved_mem array */ - if (!alloc_reserved_mem_array()) - return; - if (__reserved_mem_check_root(node)) { pr_err("Reserved memory: unsupported node format, ignoring\n"); return; From 201368e0a84e89bfb77fe36299f8a42958937256 Mon Sep 17 00:00:00 2001 From: Wandun Chen Date: Wed, 27 May 2026 11:29:12 +0800 Subject: [PATCH 06/11] of: reserved_mem: add dumpable flag to opt-in vmcore Add a 'dumpable' flag to struct reserved_mem so the kernel can decide whether a reserved area should be included in the kdump vmcore. Most reserved regions are owned by devices and do not contain data useful for kernel crash analysis, so excluding them by default is the right behaviour. Reusable CMA regions are different: pages in a CMA region are handed back to the buddy allocator and may contain key data for crash analysis, so set dumpable to true in rmem_cma_setup(). Suggested-by: Rob Herring Signed-off-by: Wandun Chen Tested-by: Meijing Zhao Acked-by: Marek Szyprowski Link: https://lore.kernel.org/all/20260506144542.GA2072596-robh@kernel.org/ Signed-off-by: Linux RISC-V bot --- include/linux/of_reserved_mem.h | 1 + kernel/dma/contiguous.c | 1 + 2 files changed, 2 insertions(+) diff --git a/include/linux/of_reserved_mem.h b/include/linux/of_reserved_mem.h index e8b20b29fa68c2..55a67cee41ea0d 100644 --- a/include/linux/of_reserved_mem.h +++ b/include/linux/of_reserved_mem.h @@ -15,6 +15,7 @@ struct reserved_mem { phys_addr_t base; phys_addr_t size; void *priv; + bool dumpable; }; struct reserved_mem_ops { diff --git a/kernel/dma/contiguous.c b/kernel/dma/contiguous.c index 03f52bd1712062..eddec89eb41465 100644 --- a/kernel/dma/contiguous.c +++ b/kernel/dma/contiguous.c @@ -579,6 +579,7 @@ static int __init rmem_cma_setup(unsigned long node, struct reserved_mem *rmem) dma_contiguous_default_area = cma; rmem->priv = cma; + rmem->dumpable = true; pr_info("Reserved memory: created CMA memory pool at %pa, size %ld MiB\n", &rmem->base, (unsigned long)rmem->size / SZ_1M); From 883a957a437b99d704054415123cf656f6efb221 Mon Sep 17 00:00:00 2001 From: Wandun Chen Date: Wed, 27 May 2026 11:29:13 +0800 Subject: [PATCH 07/11] of: reserved_mem: save /memreserve/ entries into the reserved_mem array /memreserve/ is used by firmware or bootloaders, such regions hold no useful data for crash analysis, they should be excluded from the kdump vmcore, so save /memreserve/ entries into the reserved_mem array for later exclusion. If a /memreserve/ entry overlaps any dumpable reserved region, mark the whole memreserve entry dumpable as well. This may keep slightly more memory in vmcore than strictly necessary, but avoids splitting entries and never drops data that may be useful for crash analysis. Signed-off-by: Wandun Chen Tested-by: Meijing Zhao Signed-off-by: Linux RISC-V bot --- drivers/of/fdt.c | 4 +++ drivers/of/of_private.h | 2 ++ drivers/of/of_reserved_mem.c | 55 ++++++++++++++++++++++++++++++++++++ 3 files changed, 61 insertions(+) diff --git a/drivers/of/fdt.c b/drivers/of/fdt.c index 83a2a474831e5b..745e53b1c564d9 100644 --- a/drivers/of/fdt.c +++ b/drivers/of/fdt.c @@ -499,6 +499,7 @@ void __init early_init_fdt_scan_reserved_mem(void) int n; int res; u64 base, size; + int nr_memreserve = 0; if (!initial_boot_params) return; @@ -516,7 +517,9 @@ void __init early_init_fdt_scan_reserved_mem(void) if (!size) break; memblock_reserve(base, size); + nr_memreserve++; } + fdt_reserved_mem_account_memreserve(nr_memreserve); } /** @@ -1288,6 +1291,7 @@ void __init unflatten_device_tree(void) if (fdt && alloc_reserved_mem_array()) { /* Save the statically-placed regions in the reserved_mem array */ fdt_scan_reserved_mem_late(); + fdt_reserved_mem_save_memreserve_entries(); } /* Populate an empty root node when bootloader doesn't provide one */ diff --git a/drivers/of/of_private.h b/drivers/of/of_private.h index 50e5a533e0591e..30954e85968966 100644 --- a/drivers/of/of_private.h +++ b/drivers/of/of_private.h @@ -188,6 +188,8 @@ static inline struct device_node *__of_get_dma_parent(const struct device_node * int fdt_scan_reserved_mem(void); void __init fdt_scan_reserved_mem_late(void); bool __init alloc_reserved_mem_array(void); +void __init fdt_reserved_mem_account_memreserve(int n); +void __init fdt_reserved_mem_save_memreserve_entries(void); bool of_fdt_device_is_available(const void *blob, unsigned long node); diff --git a/drivers/of/of_reserved_mem.c b/drivers/of/of_reserved_mem.c index 888dcb6bdce5b5..5e27f9403786ca 100644 --- a/drivers/of/of_reserved_mem.c +++ b/drivers/of/of_reserved_mem.c @@ -248,6 +248,43 @@ static void __init __rmem_check_for_overlap(void) } } +static void __init fdt_reserved_mem_add_memreserve(phys_addr_t base, + phys_addr_t size) +{ + struct reserved_mem *rmem; + bool dumpable = false; + int i; + + if (reserved_mem_count == total_reserved_mem_cnt) { + pr_err("not enough space for memreserve regions.\n"); + return; + } + + for (i = 0; i < reserved_mem_count; i++) { + rmem = &reserved_mem[i]; + + if (!rmem->dumpable) + continue; + + if (base < rmem->base + rmem->size && rmem->base < base + size) { + dumpable = true; + break; + } + } + + rmem = &reserved_mem[reserved_mem_count]; + rmem->base = base; + rmem->size = size; + rmem->dumpable = dumpable; + + reserved_mem_count++; +} + +void __init fdt_reserved_mem_account_memreserve(int n) +{ + total_reserved_mem_cnt += n; +} + /** * fdt_scan_reserved_mem_late() - Scan FDT and initialize remaining reserved * memory regions. @@ -305,6 +342,24 @@ void __init fdt_scan_reserved_mem_late(void) __rmem_check_for_overlap(); } +void __init fdt_reserved_mem_save_memreserve_entries(void) +{ + const void *fdt = initial_boot_params; + u64 base, size; + int n; + + if (!fdt) + return; + + for (n = 0; ; n++) { + if (fdt_get_mem_rsv(fdt, n, &base, &size)) + break; + if (!size) + break; + fdt_reserved_mem_add_memreserve(base, size); + } +} + static int __init __reserved_mem_alloc_size(unsigned long node, const char *uname); /* From dd08034e20a3c7857cfe7469217ea051360878fc Mon Sep 17 00:00:00 2001 From: Wandun Chen Date: Wed, 27 May 2026 11:29:14 +0800 Subject: [PATCH 08/11] of: reserved_mem: add kdump helpers to exclude non-dumpable regions Add two helpers to exclude non-dumpable regions for arch-specific code. - of_reserved_mem_kdump_nr_ranges() returns the count of regions that are not dumpable. Each excluded region may split an existing crash_mem range into two, so callers use this to calculate crash_mem allocation size. - of_reserved_mem_kdump_exclude() walks reserved_mem[] and calls crash_exclude_mem_range() for every non-dumpable region. Signed-off-by: Wandun Chen Tested-by: Meijing Zhao Signed-off-by: Linux RISC-V bot --- drivers/of/of_reserved_mem.c | 34 +++++++++++++++++++++++++++++++++ include/linux/of_reserved_mem.h | 14 ++++++++++++++ 2 files changed, 48 insertions(+) diff --git a/drivers/of/of_reserved_mem.c b/drivers/of/of_reserved_mem.c index 5e27f9403786ca..1d9aa332325b74 100644 --- a/drivers/of/of_reserved_mem.c +++ b/drivers/of/of_reserved_mem.c @@ -24,6 +24,7 @@ #include #include #include +#include #include "of_private.h" @@ -858,6 +859,39 @@ struct reserved_mem *of_reserved_mem_lookup(struct device_node *np) } EXPORT_SYMBOL_GPL(of_reserved_mem_lookup); +/* + * Count non-dumpable reserved regions. Excluding each one may split a + * crash_mem range in two, callers use this to size the allocation. + */ +unsigned int of_reserved_mem_kdump_nr_ranges(void) +{ + unsigned int i, n = 0; + + for (i = 0; i < reserved_mem_count; i++) + if (reserved_mem[i].size && !reserved_mem[i].dumpable) + n++; + return n; +} + +/* Exclude non-dumpable reserved regions from @cmem. */ +int of_reserved_mem_kdump_exclude(struct crash_mem *cmem) +{ + unsigned int i; + int ret; + + for (i = 0; i < reserved_mem_count; i++) { + struct reserved_mem *r = &reserved_mem[i]; + + if (!r->size || r->dumpable) + continue; + ret = crash_exclude_mem_range(cmem, r->base, + r->base + r->size - 1); + if (ret) + return ret; + } + return 0; +} + /** * of_reserved_mem_region_to_resource() - Get a reserved memory region as a resource * @np: node containing 'memory-region' property diff --git a/include/linux/of_reserved_mem.h b/include/linux/of_reserved_mem.h index 55a67cee41ea0d..70db99f1fbff08 100644 --- a/include/linux/of_reserved_mem.h +++ b/include/linux/of_reserved_mem.h @@ -8,6 +8,7 @@ struct of_phandle_args; struct reserved_mem_ops; struct resource; +struct crash_mem; struct reserved_mem { const char *name; @@ -48,6 +49,9 @@ int of_reserved_mem_region_to_resource_byname(const struct device_node *np, const char *name, struct resource *res); int of_reserved_mem_region_count(const struct device_node *np); +unsigned int of_reserved_mem_kdump_nr_ranges(void); +int of_reserved_mem_kdump_exclude(struct crash_mem *cmem); + #else #define RESERVEDMEM_OF_DECLARE(name, compat, ops) \ @@ -92,6 +96,16 @@ static inline int of_reserved_mem_region_count(const struct device_node *np) { return 0; } + +static inline unsigned int of_reserved_mem_kdump_nr_ranges(void) +{ + return 0; +} + +static inline int of_reserved_mem_kdump_exclude(struct crash_mem *cmem) +{ + return 0; +} #endif /** From c72d01c08688430def0b43ad48bd84fb13d159ef Mon Sep 17 00:00:00 2001 From: Wandun Chen Date: Wed, 27 May 2026 11:29:15 +0800 Subject: [PATCH 09/11] arm64: kdump: exclude non-dumpable reserved memory regions from vmcore Reserved memory regions are excluded from vmcore by default unless marked dumpable. Honor the dumpable flag to filter out device firmware regions (e.g., GPU, DSP, modem) reserved via device tree, since they typically contain data not useful for kernel crash analysis and can significantly increase vmcore size. Use of_reserved_mem_kdump_exclude() to perform the exclusion, and pre-size the crash_mem array via of_reserved_mem_kdump_nr_ranges(). Signed-off-by: Wandun Chen Tested-by: Meijing Zhao Signed-off-by: Linux RISC-V bot --- arch/arm64/kernel/machine_kexec_file.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/arch/arm64/kernel/machine_kexec_file.c b/arch/arm64/kernel/machine_kexec_file.c index e31fabed378a59..1d65320c6ba484 100644 --- a/arch/arm64/kernel/machine_kexec_file.c +++ b/arch/arm64/kernel/machine_kexec_file.c @@ -17,6 +17,7 @@ #include #include #include +#include #include #include #include @@ -51,6 +52,7 @@ static int prepare_elf_headers(void **addr, unsigned long *sz) nr_ranges = 2; /* for exclusion of crashkernel region */ for_each_mem_range(i, &start, &end) nr_ranges++; + nr_ranges += of_reserved_mem_kdump_nr_ranges(); cmem = kmalloc_flex(*cmem, ranges, nr_ranges); if (!cmem) @@ -75,6 +77,10 @@ static int prepare_elf_headers(void **addr, unsigned long *sz) goto out; } + ret = of_reserved_mem_kdump_exclude(cmem); + if (ret) + goto out; + ret = crash_prepare_elf64_headers(cmem, true, addr, sz); out: From 00f51285c1b44cb580d5a6f14691f298f95ccacc Mon Sep 17 00:00:00 2001 From: Wandun Chen Date: Wed, 27 May 2026 11:29:16 +0800 Subject: [PATCH 10/11] riscv: kdump: exclude non-dumpable reserved memory regions from vmcore Apply the same non-dumpable reserved memory filtering to RISC-V kdump as was done for arm64. Use of_reserved_mem_kdump_exclude() to drop flagged regions from the elfcorehdr PT_LOAD segments, and of_reserved_mem_kdump_nr_ranges() to pre-size the crash_mem array. Signed-off-by: Wandun Chen Signed-off-by: Linux RISC-V bot --- arch/riscv/kernel/machine_kexec_file.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/arch/riscv/kernel/machine_kexec_file.c b/arch/riscv/kernel/machine_kexec_file.c index 59d4bbc848a896..25359d583bc3b2 100644 --- a/arch/riscv/kernel/machine_kexec_file.c +++ b/arch/riscv/kernel/machine_kexec_file.c @@ -10,6 +10,7 @@ #include #include #include +#include #include #include #include @@ -64,6 +65,7 @@ static int prepare_elf_headers(void **addr, unsigned long *sz) nr_ranges = 1; /* For exclusion of crashkernel region */ walk_system_ram_res(0, -1, &nr_ranges, get_nr_ram_ranges_callback); + nr_ranges += of_reserved_mem_kdump_nr_ranges(); cmem = kmalloc_flex(*cmem, ranges, nr_ranges); if (!cmem) @@ -77,6 +79,8 @@ static int prepare_elf_headers(void **addr, unsigned long *sz) /* Exclude crashkernel region */ ret = crash_exclude_mem_range(cmem, crashk_res.start, crashk_res.end); + if (!ret) + ret = of_reserved_mem_kdump_exclude(cmem); if (!ret) ret = crash_prepare_elf64_headers(cmem, true, addr, sz); From e4a206d905c903ffe54f13a3e119bb73706a7466 Mon Sep 17 00:00:00 2001 From: Wandun Chen Date: Wed, 27 May 2026 11:29:17 +0800 Subject: [PATCH 11/11] loongarch: kdump: exclude non-dumpable reserved memory regions from vmcore Apply the same non-dumpable reserved memory filtering to LoongArch kdump as was done for arm64. Use of_reserved_mem_kdump_exclude() to drop flagged regions from the elfcorehdr PT_LOAD segments, and of_reserved_mem_kdump_nr_ranges() to pre-size the crash_mem array. Signed-off-by: Wandun Chen Signed-off-by: Linux RISC-V bot --- arch/loongarch/kernel/machine_kexec_file.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/arch/loongarch/kernel/machine_kexec_file.c b/arch/loongarch/kernel/machine_kexec_file.c index 5584b798ba4645..4b918c3d4a2851 100644 --- a/arch/loongarch/kernel/machine_kexec_file.c +++ b/arch/loongarch/kernel/machine_kexec_file.c @@ -14,6 +14,7 @@ #include #include #include +#include #include #include #include @@ -67,6 +68,7 @@ static int prepare_elf_headers(void **addr, unsigned long *sz) nr_ranges = 2; /* for exclusion of crashkernel region */ for_each_mem_range(i, &start, &end) nr_ranges++; + nr_ranges += of_reserved_mem_kdump_nr_ranges(); cmem = kmalloc_flex(*cmem, ranges, nr_ranges); if (!cmem) @@ -91,6 +93,10 @@ static int prepare_elf_headers(void **addr, unsigned long *sz) goto out; } + ret = of_reserved_mem_kdump_exclude(cmem); + if (ret) + goto out; + ret = crash_prepare_elf64_headers(cmem, true, addr, sz); out: