The kexec metadata subtree currently uses a monolithic u32 version field to identify the metadata structure layout. Any change to the structure, even an optional additive field, requires incrementing the version and breaks compatibility between adjacent kernels. Replace the u32 version field in struct kho_kexec_metadata with struct kho_ser_hdr using DECLARE_KHO_SER. Later fields can be appended under new feature indices without breaking compatibility across kexec. Also make the 3-byte padding hole between previous_release and kexec_count explicit as reserved[3]. During deserialization, validate the blob size against the header size and reject unknown required features. A legacy v1 metadata blob is ignored with a warning. Signed-off-by: Tarun Sahu --- include/linux/kho/abi/kexec_metadata.h | 17 +++++++----- kernel/liveupdate/kexec_handover.c | 38 ++++++++++++++------------ 2 files changed, 31 insertions(+), 24 deletions(-) diff --git a/include/linux/kho/abi/kexec_metadata.h b/include/linux/kho/abi/kexec_metadata.h index e9e3f7e38a7c..316b3e5ad01b 100644 --- a/include/linux/kho/abi/kexec_metadata.h +++ b/include/linux/kho/abi/kexec_metadata.h @@ -18,28 +18,31 @@ #ifndef _LINUX_KHO_ABI_KEXEC_METADATA_H #define _LINUX_KHO_ABI_KEXEC_METADATA_H +#include +#include #include #include -#define KHO_KEXEC_METADATA_VERSION 1 - /** * struct kho_kexec_metadata - Kexec metadata passed between kernels - * @version: ABI version of this struct (must be first field) * @previous_release: Kernel version string that initiated the kexec + * @reserved: Reserved for structure alignment; must be zero * @kexec_count: Number of kexec boots since last cold boot * - * This structure is preserved across kexec and allows the new kernel to + * This structure is preserved across kexec and allows the target kernel to * identify which kernel it was booted from and how many kexec reboots - * have occurred. + * have occurred. Preceded by &struct kho_ser_hdr. * * __NEW_UTS_LEN is part of uABI, so it safe to use it in here. */ struct kho_kexec_metadata { - u32 version; char previous_release[__NEW_UTS_LEN + 1]; + u8 reserved[3]; u32 kexec_count; -} __packed; +} __aligned(8); + +/* Register kho_kexec_metadata with KHO serialization accessors */ +DECLARE_KHO_SER(kho_kexec_metadata, 72, 0, 0); #define KHO_METADATA_NODE_NAME "kexec-metadata" diff --git a/kernel/liveupdate/kexec_handover.c b/kernel/liveupdate/kexec_handover.c index 4b1d173d48ff..641a3b4c88fb 100644 --- a/kernel/liveupdate/kexec_handover.c +++ b/kernel/liveupdate/kexec_handover.c @@ -1762,6 +1762,7 @@ static __init int kho_out_fdt_setup(void) static void __init kho_in_kexec_metadata(void) { + DECLARE_KHO_SER_HDR(kho_kexec_metadata, *fhdr); struct kho_kexec_metadata *metadata; phys_addr_t metadata_phys; size_t blob_size; @@ -1773,27 +1774,28 @@ static void __init kho_in_kexec_metadata(void) /* This is fine, previous kernel didn't export metadata */ return; - /* Check that, at least, "version" is present */ - if (blob_size < sizeof(u32)) { + if (blob_size < sizeof(*fhdr)) { pr_warn("kexec-metadata blob too small (%zu bytes)\n", blob_size); return; } - metadata = phys_to_virt(metadata_phys); - - if (metadata->version != KHO_KEXEC_METADATA_VERSION) { - pr_warn("kexec-metadata version %u not supported (expected %u)\n", - metadata->version, KHO_KEXEC_METADATA_VERSION); + fhdr = phys_to_virt(metadata_phys); + if (fhdr->size != blob_size) { + pr_warn("kexec-metadata size invalid (%u != %zu), ignoring metadata\n", + fhdr->size, blob_size); return; } - if (blob_size < sizeof(*metadata)) { - pr_warn("kexec-metadata blob too small for v%u (%zu < %zu)\n", - metadata->version, blob_size, sizeof(*metadata)); + err = kho_ser_validate(fhdr, kho_kexec_metadata); + if (err) { + pr_warn("kexec-metadata feature validation failed: %pe\n", + ERR_PTR(err)); return; } + metadata = kho_ser_payload(fhdr, kho_kexec_metadata); + /* * Copy data to the kernel structure that will persist during * kernel lifetime. @@ -1813,23 +1815,25 @@ static void __init kho_in_kexec_metadata(void) */ static __init int kho_out_kexec_metadata(void) { + DECLARE_KHO_SER_HDR(kho_kexec_metadata, *fhdr); struct kho_kexec_metadata *metadata; int err; - metadata = kho_alloc_preserve(sizeof(*metadata)); - if (IS_ERR(metadata)) - return PTR_ERR(metadata); + fhdr = kho_alloc_preserve(kho_ser_size(kho_kexec_metadata)); + if (IS_ERR(fhdr)) + return PTR_ERR(fhdr); + kho_ser_init(fhdr, kho_kexec_metadata); - metadata->version = KHO_KEXEC_METADATA_VERSION; + metadata = kho_ser_payload(fhdr, kho_kexec_metadata); strscpy(metadata->previous_release, init_uts_ns.name.release, sizeof(metadata->previous_release)); + memset(metadata->reserved, 0, sizeof(metadata->reserved)); /* kho_in.kexec_count is set to 0 on cold boot */ metadata->kexec_count = kho_in.kexec_count + 1; - err = kho_add_subtree(KHO_METADATA_NODE_NAME, metadata, - sizeof(*metadata)); + err = kho_add_subtree(KHO_METADATA_NODE_NAME, fhdr, fhdr->size); if (err) - kho_unpreserve_free(metadata); + kho_unpreserve_free(fhdr); return err; } -- 2.56.0.506.g506a7eabc5-goog