762cd288fc
Before commit
d0f9ca9be1 ("ARM: decompressor: run decompressor in place if loaded via UEFI")
we were rather limited in the choice of base address for the uncompressed
kernel, as we were relying on the logic in the decompressor that blindly
rounds down the decompressor execution address to the next multiple of 128
MiB, and decompresses the kernel there. For this reason, we have a lot of
complicated memory region handling code, to ensure that this memory window
is available, even though it could be occupied by reserved regions or
other allocations that may or may not collide with the uncompressed image.
Today, we simply pass the target address for the decompressed image to the
decompressor directly, and so we can choose a suitable window just by
finding a 16 MiB aligned region, while taking TEXT_OFFSET and the region
for the swapper page tables into account.
So let's get rid of the complicated logic, and instead, use the existing
bottom up allocation routine to allocate a suitable window as low as
possible, and carve out a memory region that has the right properties.
Note that this removes any dependencies on the 'dram_base' argument to
handle_kernel_image(), and so this is removed as well. Given that this
was the only remaining use of dram_base, the code that produces it is
removed entirely as well.
Reviewed-by: Maxim Uvarov <maxim.uvarov@linaro.org>
Tested-by: Maxim Uvarov <maxim.uvarov@linaro.org>
Signed-off-by: Ard Biesheuvel <ardb@kernel.org>
118 lines
3.3 KiB
C
118 lines
3.3 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright (C) 2013, 2014 Linaro Ltd; <roy.franz@linaro.org>
|
|
*
|
|
* This file implements the EFI boot stub for the arm64 kernel.
|
|
* Adapted from ARM version by Mark Salter <msalter@redhat.com>
|
|
*/
|
|
|
|
|
|
#include <linux/efi.h>
|
|
#include <asm/efi.h>
|
|
#include <asm/memory.h>
|
|
#include <asm/sections.h>
|
|
#include <asm/sysreg.h>
|
|
|
|
#include "efistub.h"
|
|
|
|
efi_status_t check_platform_features(void)
|
|
{
|
|
u64 tg;
|
|
|
|
/* UEFI mandates support for 4 KB granularity, no need to check */
|
|
if (IS_ENABLED(CONFIG_ARM64_4K_PAGES))
|
|
return EFI_SUCCESS;
|
|
|
|
tg = (read_cpuid(ID_AA64MMFR0_EL1) >> ID_AA64MMFR0_TGRAN_SHIFT) & 0xf;
|
|
if (tg != ID_AA64MMFR0_TGRAN_SUPPORTED) {
|
|
if (IS_ENABLED(CONFIG_ARM64_64K_PAGES))
|
|
efi_err("This 64 KB granular kernel is not supported by your CPU\n");
|
|
else
|
|
efi_err("This 16 KB granular kernel is not supported by your CPU\n");
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/*
|
|
* Although relocatable kernels can fix up the misalignment with respect to
|
|
* MIN_KIMG_ALIGN, the resulting virtual text addresses are subtly out of
|
|
* sync with those recorded in the vmlinux when kaslr is disabled but the
|
|
* image required relocation anyway. Therefore retain 2M alignment unless
|
|
* KASLR is in use.
|
|
*/
|
|
static u64 min_kimg_align(void)
|
|
{
|
|
return efi_nokaslr ? MIN_KIMG_ALIGN : EFI_KIMG_ALIGN;
|
|
}
|
|
|
|
efi_status_t handle_kernel_image(unsigned long *image_addr,
|
|
unsigned long *image_size,
|
|
unsigned long *reserve_addr,
|
|
unsigned long *reserve_size,
|
|
efi_loaded_image_t *image)
|
|
{
|
|
efi_status_t status;
|
|
unsigned long kernel_size, kernel_memsize = 0;
|
|
u32 phys_seed = 0;
|
|
|
|
if (IS_ENABLED(CONFIG_RANDOMIZE_BASE)) {
|
|
if (!efi_nokaslr) {
|
|
status = efi_get_random_bytes(sizeof(phys_seed),
|
|
(u8 *)&phys_seed);
|
|
if (status == EFI_NOT_FOUND) {
|
|
efi_info("EFI_RNG_PROTOCOL unavailable, no randomness supplied\n");
|
|
} else if (status != EFI_SUCCESS) {
|
|
efi_err("efi_get_random_bytes() failed\n");
|
|
return status;
|
|
}
|
|
} else {
|
|
efi_info("KASLR disabled on kernel command line\n");
|
|
}
|
|
}
|
|
|
|
if (image->image_base != _text)
|
|
efi_err("FIRMWARE BUG: efi_loaded_image_t::image_base has bogus value\n");
|
|
|
|
kernel_size = _edata - _text;
|
|
kernel_memsize = kernel_size + (_end - _edata);
|
|
*reserve_size = kernel_memsize + TEXT_OFFSET % min_kimg_align();
|
|
|
|
if (IS_ENABLED(CONFIG_RANDOMIZE_BASE) && phys_seed != 0) {
|
|
/*
|
|
* If KASLR is enabled, and we have some randomness available,
|
|
* locate the kernel at a randomized offset in physical memory.
|
|
*/
|
|
status = efi_random_alloc(*reserve_size, min_kimg_align(),
|
|
reserve_addr, phys_seed);
|
|
} else {
|
|
status = EFI_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
if (status != EFI_SUCCESS) {
|
|
if (IS_ALIGNED((u64)_text - TEXT_OFFSET, min_kimg_align())) {
|
|
/*
|
|
* Just execute from wherever we were loaded by the
|
|
* UEFI PE/COFF loader if the alignment is suitable.
|
|
*/
|
|
*image_addr = (u64)_text;
|
|
*reserve_size = 0;
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
status = efi_allocate_pages_aligned(*reserve_size, reserve_addr,
|
|
ULONG_MAX, min_kimg_align());
|
|
|
|
if (status != EFI_SUCCESS) {
|
|
efi_err("Failed to relocate kernel\n");
|
|
*reserve_size = 0;
|
|
return status;
|
|
}
|
|
}
|
|
|
|
*image_addr = *reserve_addr + TEXT_OFFSET % min_kimg_align();
|
|
memcpy((void *)*image_addr, _text, kernel_size);
|
|
|
|
return EFI_SUCCESS;
|
|
}
|