[PATCH 06/11] of: reserved_mem: save /memreserve/ entries into reserved_mem array

Chen Wandun
2026-04-29T06:59:43Z

Save /memreserve/ entries from the FDT header into the reserved_mem
array so they can be consumed as vmcore filtering metadata by kdump.

/memreserve/ regions hold firmware or bootloader state that is not
useful for kernel crash analysis, so saved /memreserve/ entries
default to no_dump=true and are tagged with name="memreserve" so
consumers can distinguish them from /reserved-memory/ child nodes.

Some DTBs declare the same or overlapping range in both
/memreserve/ and a /reserved-memory/ child. Commit b41328187629
("of: fdt: Scan /memreserve/ last") describes one such case on
Khadas Vim3 where the range is in /memreserve/ and also in a
/reserved-memory/ child carrying no-map. The /reserved-memory/
node's attributes (no-map, reusable, linux,no-dump) are the
explicit declaration and must win over the firmware default,
fdt_reserved_mem_save_memreserve() therefore inherits no_dump from
the overlapping /reserved-memory/ entry rather than silently
applying no_dump=true.

Signed-off-by: Chen Wandun <chenwandun@lixiang.com>
Tested-by: Zhao Meijing <zhaomeijing@lixiang.com>
---
drivers/of/of_reserved_mem.c | 107 +++++++++++++++++++++++++++++------
1 file changed, 91 insertions(+), 16 deletions(-)

diff --git a/drivers/of/of_reserved_mem.c b/drivers/of/of_reserved_mem.c
index ac3d8b837d61..4b80420da2d2 100644
--- a/drivers/of/of_reserved_mem.c
+++ b/drivers/of/of_reserved_mem.c
@@ -252,6 +252,49 @@ static void __init __rmem_check_for_overlap(void)
}
}

+/**
+ * fdt_reserved_mem_save_memreserve() - save a /memreserve/ entry
+ * @base: base address
+ * @size: size
+ *
+ * Save a /memreserve/ range into reserved_mem[] with no_dump=true
+ * as the firmware default. If the range overlaps a /reserved-memory/
+ * child already saved in this pass, inherit that entry's no_dump so
+ * node-level attributes (no-map, reusable, linux,no-dump) win over
+ * the firmware default.
+ */
+static void __init fdt_reserved_mem_save_memreserve(phys_addr_t base,
+ phys_addr_t size)
+{
+ struct reserved_mem *rmem;
+ phys_addr_t end = base + size;
+ bool no_dump = true;
+ int i;
+
+ for (i = 0; i < reserved_mem_count; i++) {
+ phys_addr_t r_base = reserved_mem[i].base;
+ phys_addr_t r_end = r_base + reserved_mem[i].size;
+
+ if (base < r_end && end > r_base) {
+ no_dump = reserved_mem[i].no_dump;
+ break;
+ }
+ }
+
+ if (reserved_mem_count == total_reserved_mem_cnt) {
+ pr_err("not enough space for all defined regions.\n");
+ return;
+ }
+
+ rmem = &reserved_mem[reserved_mem_count];
+ rmem->name = "memreserve";
+ rmem->base = base;
+ rmem->size = size;
+ rmem->no_dump = no_dump;
+
+ reserved_mem_count++;
+}
+
/**
* fdt_scan_reserved_mem_late() - Scan FDT and initialize remaining reserved
* memory regions.
@@ -260,6 +303,9 @@ static void __init __rmem_check_for_overlap(void)
* "static" reserved memory regions, that are defined using the "reg"
* property. Each such region is then initialized with its specific init
* function and stored in the global reserved_mem array.
+ *
+ * In addition, /memreserve/ entries from the FDT header are saved into
+ * the reserved_mem array so they can be consumed as vmcore metadata.
*/
void __init fdt_scan_reserved_mem_late(void)
{
@@ -270,28 +316,32 @@ void __init fdt_scan_reserved_mem_late(void)
if (!fdt)
return;

+ /*
+ * fdt_scan_reserved_mem() has set total_reserved_mem_cnt to the
+ * total number of entries to be saved (reg-based + /memreserve/).
+ * If it is zero there is nothing to allocate, save or check.
+ */
+ if (!total_reserved_mem_cnt)
+ return;
+
+ /*
+ * Allocate up front: /memreserve/ saves below may run on any
+ * path and must write into a memblock-backed array, not the
+ * __initdata reserved_mem_array which is freed at free_initmem().
+ */
+ alloc_reserved_mem_array();
+
node = fdt_path_offset(fdt, "/reserved-memory");
if (node < 0) {
pr_info("Reserved memory: No reserved-memory node in the DT\n");
- return;
+ goto memreserve;
}

if (__reserved_mem_check_root(node)) {
pr_err("Reserved memory: unsupported node format, ignoring\n");
- return;
+ goto memreserve;
}

- /*
- * fdt_scan_reserved_mem() sets total_reserved_mem_cnt to the
- * number of entries that need a slot in reserved_mem[]. If it is
- * zero there is nothing to allocate or save.
- */
- if (!total_reserved_mem_cnt)
- return;
-
- /* Attempt dynamic allocation of a new reserved_mem array */
- alloc_reserved_mem_array();
-
fdt_for_each_subnode(child, fdt, node) {
const char *uname;
int i, len;
@@ -342,6 +392,18 @@ void __init fdt_scan_reserved_mem_late(void)

/* check for overlapping reserved regions */
__rmem_check_for_overlap();
+
+memreserve:
+ /* Save /memreserve/ entries (independent of /reserved-memory) */
+ for (int i = 0; ; i++) {
+ u64 mbase, msize;
+
+ if (fdt_get_mem_rsv(fdt, i, &mbase, &msize))
+ break;
+ if (!msize)
+ break;
+ fdt_reserved_mem_save_memreserve(mbase, msize);
+ }
}

static int __init __reserved_mem_alloc_size(unsigned long node, const char *uname);
@@ -365,11 +427,11 @@ int __init fdt_scan_reserved_mem(void)

node = fdt_path_offset(fdt, "/reserved-memory");
if (node < 0)
- return -ENODEV;
+ goto memreserve;

if (__reserved_mem_check_root(node) != 0) {
pr_err("Reserved memory: unsupported node format, ignoring\n");
- return -EINVAL;
+ goto memreserve;
}

fdt_for_each_subnode(child, fdt, node) {
@@ -406,8 +468,21 @@ int __init fdt_scan_reserved_mem(void)
if (!err)
count++;
}
+
+memreserve:
+ /* Count /memreserve/ entries (independent of /reserved-memory) */
+ for (int i = 0; ; i++) {
+ u64 base, size;
+
+ if (fdt_get_mem_rsv(fdt, i, &base, &size))
+ break;
+ if (!size)
+ break;
+ count++;
+ }
+
total_reserved_mem_cnt = count;
- return 0;
+ return count ? 0 : -ENODEV;
}

/*
--
2.43.0