kho: persist blob size in KHO FDT

kho_add_subtree() accepts a size parameter but only forwards it to
debugfs.  The size is not persisted in the KHO FDT, so it is lost across
kexec.  This makes it impossible for the incoming kernel to determine the
blob size without understanding the blob format.

Store the blob size as a "blob-size" property in the KHO FDT alongside the
"preserved-data" physical address.  This allows the receiving kernel to
recover the size for any blob regardless of format.

Also extend kho_retrieve_subtree() with an optional size output parameter
so callers can learn the blob size without needing to understand the blob
format.  Update all callers to pass NULL for the new parameter.

Link: https://lore.kernel.org/20260316-kho-v9-3-ed6dcd951988@debian.org
Signed-off-by: Breno Leitao <leitao@debian.org>
Reviewed-by: Mike Rapoport (Microsoft) <rppt@kernel.org>
Reviewed-by: Pratyush Yadav <pratyush@kernel.org>
Cc: Alexander Graf <graf@amazon.com>
Cc: David Hildenbrand <david@kernel.org>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: "Liam R. Howlett" <Liam.Howlett@oracle.com>
Cc: Lorenzo Stoakes <ljs@kernel.org>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Pasha Tatashin <pasha.tatashin@soleen.com>
Cc: SeongJae Park <sj@kernel.org>
Cc: Shuah Khan <skhan@linuxfoundation.org>
Cc: Suren Baghdasaryan <surenb@google.com>
Cc: Vlastimil Babka <vbabka@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/include/linux/kexec_handover.h b/include/linux/kexec_handover.h
index 0666cf298c7f41ec9e952468e3b1ac95d0dc64c1..8968c56d2d73e1e6232fe108b17103a89a51bf31 100644 (file)
--- a/include/linux/kexec_handover.h
+++ b/include/linux/kexec_handover.h
@@ -34,7 +34,7 @@ struct page *kho_restore_pages(phys_addr_t phys, unsigned long nr_pages);
 void *kho_restore_vmalloc(const struct kho_vmalloc *preservation);
 int kho_add_subtree(const char *name, void *blob, size_t size);
 void kho_remove_subtree(void *blob);
-int kho_retrieve_subtree(const char *name, phys_addr_t *phys);
+int kho_retrieve_subtree(const char *name, phys_addr_t *phys, size_t *size);
 
 void kho_memory_init(void);
 
@@ -104,7 +104,8 @@ static inline int kho_add_subtree(const char *name, void *blob, size_t size)
 
 static inline void kho_remove_subtree(void *blob) { }
 
-static inline int kho_retrieve_subtree(const char *name, phys_addr_t *phys)
+static inline int kho_retrieve_subtree(const char *name, phys_addr_t *phys,
+                                      size_t *size)
 {
        return -EOPNOTSUPP;
 }

diff --git a/include/linux/kho/abi/kexec_handover.h b/include/linux/kho/abi/kexec_handover.h
index 6b7d8ef550f985110e88c3f157ad1a69f8de25a3..7e847a2339b092ca1b77dd39c73c13253a0e5d8b 100644 (file)
--- a/include/linux/kho/abi/kexec_handover.h
+++ b/include/linux/kho/abi/kexec_handover.h
@@ -41,25 +41,28 @@
  *   restore the preserved data.::
  *
  *     / {
- *         compatible = "kho-v2";
+ *         compatible = "kho-v3";
  *
  *         preserved-memory-map = <0x...>;
  *
  *         <subnode-name-1> {
  *             preserved-data = <0x...>;
+ *             blob-size = <0x...>;
  *         };
  *
  *         <subnode-name-2> {
  *             preserved-data = <0x...>;
+ *             blob-size = <0x...>;
  *         };
  *               ... ...
  *         <subnode-name-N> {
  *             preserved-data = <0x...>;
+ *             blob-size = <0x...>;
  *         };
  *     };
  *
  *   Root KHO Node (/):
- *     - compatible: "kho-v2"
+ *     - compatible: "kho-v3"
  *
  *       Indentifies the overall KHO ABI version.
  *
@@ -78,16 +81,25 @@
  *
  *       Physical address pointing to a subnode data blob that is also
  *       being preserved.
+ *
+ *     - blob-size: u64
+ *
+ *       Size in bytes of the preserved data blob. This is needed because
+ *       blobs may use arbitrary formats (not just FDT), so the size
+ *       cannot be determined from the blob content alone.
  */
 
 /* The compatible string for the KHO FDT root node. */
-#define KHO_FDT_COMPATIBLE "kho-v2"
+#define KHO_FDT_COMPATIBLE "kho-v3"
 
 /* The FDT property for the preserved memory map. */
 #define KHO_FDT_MEMORY_MAP_PROP_NAME "preserved-memory-map"
 
 /* The FDT property for preserved data blobs. */
-#define KHO_FDT_SUB_TREE_PROP_NAME "preserved-data"
+#define KHO_SUB_TREE_PROP_NAME "preserved-data"
+
+/* The FDT property for the size of preserved data blobs. */
+#define KHO_SUB_TREE_SIZE_PROP_NAME "blob-size"
 
 /**
  * DOC: Kexec Handover ABI for vmalloc Preservation

diff --git a/kernel/liveupdate/kexec_handover.c b/kernel/liveupdate/kexec_handover.c
index 711b6c3376e7102ebd2b43da944e0d8405a04b11..adf6541f70f96d86a375e8c1da37ae2ef943f7de 100644 (file)
--- a/kernel/liveupdate/kexec_handover.c
+++ b/kernel/liveupdate/kexec_handover.c
@@ -743,6 +743,7 @@ int kho_add_subtree(const char *name, void *blob, size_t size)
 {
        phys_addr_t phys = virt_to_phys(blob);
        void *root_fdt = kho_out.fdt;
+       u64 size_u64 = size;
        int err = -ENOMEM;
        int off, fdt_err;
 
@@ -759,11 +760,16 @@ int kho_add_subtree(const char *name, void *blob, size_t size)
                goto out_pack;
        }
 
-       err = fdt_setprop(root_fdt, off, KHO_FDT_SUB_TREE_PROP_NAME,
+       err = fdt_setprop(root_fdt, off, KHO_SUB_TREE_PROP_NAME,
                          &phys, sizeof(phys));
        if (err < 0)
                goto out_pack;
 
+       err = fdt_setprop(root_fdt, off, KHO_SUB_TREE_SIZE_PROP_NAME,
+                         &size_u64, sizeof(size_u64));
+       if (err < 0)
+               goto out_pack;
+
        WARN_ON_ONCE(kho_debugfs_blob_add(&kho_out.dbg, name, blob,
                                          size, false));
 
@@ -792,7 +798,7 @@ void kho_remove_subtree(void *blob)
                const u64 *val;
                int len;
 
-               val = fdt_getprop(root_fdt, off, KHO_FDT_SUB_TREE_PROP_NAME, &len);
+               val = fdt_getprop(root_fdt, off, KHO_SUB_TREE_PROP_NAME, &len);
                if (!val || len != sizeof(phys_addr_t))
                        continue;
 
@@ -1297,13 +1303,14 @@ EXPORT_SYMBOL_GPL(is_kho_boot);
  * kho_retrieve_subtree - retrieve a preserved sub blob by its name.
  * @name: the name of the sub blob passed to kho_add_subtree().
  * @phys: if found, the physical address of the sub blob is stored in @phys.
+ * @size: if not NULL and found, the size of the sub blob is stored in @size.
  *
  * Retrieve a preserved sub blob named @name and store its physical
- * address in @phys.
+ * address in @phys and optionally its size in @size.
  *
  * Return: 0 on success, error code on failure
  */
-int kho_retrieve_subtree(const char *name, phys_addr_t *phys)
+int kho_retrieve_subtree(const char *name, phys_addr_t *phys, size_t *size)
 {
        const void *fdt = kho_get_fdt();
        const u64 *val;
@@ -1319,12 +1326,22 @@ int kho_retrieve_subtree(const char *name, phys_addr_t *phys)
        if (offset < 0)
                return -ENOENT;
 
-       val = fdt_getprop(fdt, offset, KHO_FDT_SUB_TREE_PROP_NAME, &len);
+       val = fdt_getprop(fdt, offset, KHO_SUB_TREE_PROP_NAME, &len);
        if (!val || len != sizeof(*val))
                return -EINVAL;
 
        *phys = (phys_addr_t)*val;
 
+       val = fdt_getprop(fdt, offset, KHO_SUB_TREE_SIZE_PROP_NAME, &len);
+       if (!val || len != sizeof(*val)) {
+               pr_warn("broken KHO subnode '%s': missing or invalid blob-size property\n",
+                       name);
+               return -EINVAL;
+       }
+
+       if (size)
+               *size = (size_t)*val;
+
        return 0;
 }
 EXPORT_SYMBOL_GPL(kho_retrieve_subtree);

diff --git a/kernel/liveupdate/kexec_handover_debugfs.c b/kernel/liveupdate/kexec_handover_debugfs.c
index cab923e4f5c8dd59f24ff9a5da4284e06b53cc5d..b416846810d785e741584a208772527bc4e6a5fa 100644 (file)
--- a/kernel/liveupdate/kexec_handover_debugfs.c
+++ b/kernel/liveupdate/kexec_handover_debugfs.c
@@ -125,7 +125,8 @@ __init void kho_in_debugfs_init(struct kho_debugfs *dbg, const void *fdt)
                const u64 *fdt_phys;
                void *sub_fdt;
 
-               fdt_phys = fdt_getprop(fdt, child, KHO_FDT_SUB_TREE_PROP_NAME, &len);
+               fdt_phys = fdt_getprop(fdt, child,
+                                       KHO_SUB_TREE_PROP_NAME, &len);
                if (!fdt_phys)
                        continue;
                if (len != sizeof(*fdt_phys)) {

diff --git a/kernel/liveupdate/luo_core.c b/kernel/liveupdate/luo_core.c
index 04d06a0906c0ee75b45c21bfa84c4ca0869c82d4..48b25c9abeda349ff35b6da457c4369d4f75e46a 100644 (file)
--- a/kernel/liveupdate/luo_core.c
+++ b/kernel/liveupdate/luo_core.c
@@ -88,7 +88,7 @@ static int __init luo_early_startup(void)
        }
 
        /* Retrieve LUO subtree, and verify its format. */
-       err = kho_retrieve_subtree(LUO_FDT_KHO_ENTRY_NAME, &fdt_phys);
+       err = kho_retrieve_subtree(LUO_FDT_KHO_ENTRY_NAME, &fdt_phys, NULL);
        if (err) {
                if (err != -ENOENT) {
                        pr_err("failed to retrieve FDT '%s' from KHO: %pe\n",

diff --git a/lib/test_kho.c b/lib/test_kho.c
index 263182437315205b48ae43caf94298278a0e7156..aa6a0956bb8b7aa7437170681dda456f27f04235 100644 (file)
--- a/lib/test_kho.c
+++ b/lib/test_kho.c
@@ -319,7 +319,7 @@ static int __init kho_test_init(void)
        if (!kho_is_enabled())
                return 0;
 
-       err = kho_retrieve_subtree(KHO_TEST_FDT, &fdt_phys);
+       err = kho_retrieve_subtree(KHO_TEST_FDT, &fdt_phys, NULL);
        if (!err) {
                err = kho_test_restore(fdt_phys);
                if (err)

diff --git a/mm/memblock.c b/mm/memblock.c
index 91d4162eec63f7dd070020a72641c175ead9a82e..a1c6dd0f6fad8356de0842ca10ebe05879a4d34c 100644 (file)
--- a/mm/memblock.c
+++ b/mm/memblock.c
@@ -2555,7 +2555,7 @@ static void *__init reserve_mem_kho_retrieve_fdt(void)
        if (fdt)
                return fdt;
 
-       err = kho_retrieve_subtree(MEMBLOCK_KHO_FDT, &fdt_phys);
+       err = kho_retrieve_subtree(MEMBLOCK_KHO_FDT, &fdt_phys, NULL);
        if (err) {
                if (err != -ENOENT)
                        pr_warn("failed to retrieve FDT '%s' from KHO: %d\n",