Commit 53f8f064 authored by Pasha Tatashin's avatar Pasha Tatashin Committed by Andrew Morton
Browse files

kho: verify deserialization status and fix FDT alignment access 

During boot, kho_restore_folio() relies on the memory map having been
successfully deserialized.  If deserialization fails or no map is present,
attempting to restore the FDT folio is unsafe.

Update kho_mem_deserialize() to return a boolean indicating success.  Use
this return value in kho_memory_init() to disable KHO if deserialization
fails.  Also, the incoming FDT folio is never used, there is no reason to
restore it.

Additionally, use get_unaligned() to retrieve the memory map pointer from
the FDT.  FDT properties are not guaranteed to be naturally aligned, and
accessing a 64-bit value via a pointer that is only 32-bit aligned can
cause faults.

Link: https://lkml.kernel.org/r/20251114190002.3311679-6-pasha.tatashin@soleen.com


Signed-off-by: default avatarPasha Tatashin <pasha.tatashin@soleen.com>
Reviewed-by: default avatarMike Rapoport (Microsoft) <rppt@kernel.org>
Reviewed-by: default avatarPratyush Yadav <pratyush@kernel.org>
Cc: Alexander Graf <graf@amazon.com>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Baoquan He <bhe@redhat.com>
Cc: Coiby Xu <coxu@redhat.com>
Cc: Dave Vasilevsky <dave@vasilevsky.ca>
Cc: Eric Biggers <ebiggers@google.com>
Cc: Kees Cook <kees@kernel.org>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
parent 85de0090

kernel/liveupdate/kexec_handover.c

+19 −13
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ 
#include <linux/list.h>

#include <linux/memblock.h>

#include <linux/page-isolation.h>

#include <linux/unaligned.h>

#include <linux/vmalloc.h>



#include <asm/early_ioremap.h>
@@ -451,20 +452,27 @@ static void __init deserialize_bitmap(unsigned int order, 
	}

}



static void __init kho_mem_deserialize(const void *fdt)

/* Return true if memory was deserizlied */

static bool __init kho_mem_deserialize(const void *fdt)

{

	struct khoser_mem_chunk *chunk;

	const phys_addr_t *mem;

	const void *mem_ptr;

	u64 mem;

	int len;



	mem = fdt_getprop(fdt, 0, PROP_PRESERVED_MEMORY_MAP, &len);



	if (!mem || len != sizeof(*mem)) {

	mem_ptr = fdt_getprop(fdt, 0, PROP_PRESERVED_MEMORY_MAP, &len);

	if (!mem_ptr || len != sizeof(u64)) {

		pr_err("failed to get preserved memory bitmaps\n");

		return;

		return false;

	}



	chunk = *mem ? phys_to_virt(*mem) : NULL;

	mem = get_unaligned((const u64 *)mem_ptr);

	chunk = mem ? phys_to_virt(mem) : NULL;



	/* No preserved physical pages were passed, no deserialization */

	if (!chunk)

		return false;



	while (chunk) {

		unsigned int i;
@@ -473,6 +481,8 @@ static void __init kho_mem_deserialize(const void *fdt) 
					   &chunk->bitmaps[i]);

		chunk = KHOSER_LOAD_PTR(chunk->hdr.next);

	}



	return true;

}



/*
@@ -1458,16 +1468,12 @@ static void __init kho_release_scratch(void) 


void __init kho_memory_init(void)

{

	struct folio *folio;



	if (kho_in.scratch_phys) {

		kho_scratch = phys_to_virt(kho_in.scratch_phys);

		kho_release_scratch();



		kho_mem_deserialize(kho_get_fdt());

		folio = kho_restore_folio(kho_in.fdt_phys);

		if (!folio)

			pr_warn("failed to restore folio for KHO fdt\n");

		if (!kho_mem_deserialize(kho_get_fdt()))

			kho_in.fdt_phys = 0;

	} else {

		kho_reserve_scratch();

	}