David Brazdil | 0f672f6 | 2019-12-10 10:32:29 +0000 | [diff] [blame^] | 1 | // SPDX-License-Identifier: GPL-2.0 |
Andrew Scull | b4b6d4a | 2019-01-02 15:54:55 +0000 | [diff] [blame] | 2 | /* |
| 3 | * Copyright (C) 2013, 2014 Linaro Ltd; <roy.franz@linaro.org> |
| 4 | * |
| 5 | * This file implements the EFI boot stub for the arm64 kernel. |
| 6 | * Adapted from ARM version by Mark Salter <msalter@redhat.com> |
Andrew Scull | b4b6d4a | 2019-01-02 15:54:55 +0000 | [diff] [blame] | 7 | */ |
| 8 | |
| 9 | /* |
| 10 | * To prevent the compiler from emitting GOT-indirected (and thus absolute) |
| 11 | * references to the section markers, override their visibility as 'hidden' |
| 12 | */ |
| 13 | #pragma GCC visibility push(hidden) |
| 14 | #include <asm/sections.h> |
| 15 | #pragma GCC visibility pop |
| 16 | |
| 17 | #include <linux/efi.h> |
| 18 | #include <asm/efi.h> |
| 19 | #include <asm/memory.h> |
| 20 | #include <asm/sysreg.h> |
| 21 | |
| 22 | #include "efistub.h" |
| 23 | |
| 24 | efi_status_t check_platform_features(efi_system_table_t *sys_table_arg) |
| 25 | { |
| 26 | u64 tg; |
| 27 | |
| 28 | /* UEFI mandates support for 4 KB granularity, no need to check */ |
| 29 | if (IS_ENABLED(CONFIG_ARM64_4K_PAGES)) |
| 30 | return EFI_SUCCESS; |
| 31 | |
| 32 | tg = (read_cpuid(ID_AA64MMFR0_EL1) >> ID_AA64MMFR0_TGRAN_SHIFT) & 0xf; |
| 33 | if (tg != ID_AA64MMFR0_TGRAN_SUPPORTED) { |
| 34 | if (IS_ENABLED(CONFIG_ARM64_64K_PAGES)) |
| 35 | pr_efi_err(sys_table_arg, "This 64 KB granular kernel is not supported by your CPU\n"); |
| 36 | else |
| 37 | pr_efi_err(sys_table_arg, "This 16 KB granular kernel is not supported by your CPU\n"); |
| 38 | return EFI_UNSUPPORTED; |
| 39 | } |
| 40 | return EFI_SUCCESS; |
| 41 | } |
| 42 | |
| 43 | efi_status_t handle_kernel_image(efi_system_table_t *sys_table_arg, |
| 44 | unsigned long *image_addr, |
| 45 | unsigned long *image_size, |
| 46 | unsigned long *reserve_addr, |
| 47 | unsigned long *reserve_size, |
| 48 | unsigned long dram_base, |
| 49 | efi_loaded_image_t *image) |
| 50 | { |
| 51 | efi_status_t status; |
| 52 | unsigned long kernel_size, kernel_memsize = 0; |
| 53 | void *old_image_addr = (void *)*image_addr; |
| 54 | unsigned long preferred_offset; |
| 55 | u64 phys_seed = 0; |
| 56 | |
| 57 | if (IS_ENABLED(CONFIG_RANDOMIZE_BASE)) { |
| 58 | if (!nokaslr()) { |
| 59 | status = efi_get_random_bytes(sys_table_arg, |
| 60 | sizeof(phys_seed), |
| 61 | (u8 *)&phys_seed); |
| 62 | if (status == EFI_NOT_FOUND) { |
| 63 | pr_efi(sys_table_arg, "EFI_RNG_PROTOCOL unavailable, no randomness supplied\n"); |
| 64 | } else if (status != EFI_SUCCESS) { |
| 65 | pr_efi_err(sys_table_arg, "efi_get_random_bytes() failed\n"); |
| 66 | return status; |
| 67 | } |
| 68 | } else { |
| 69 | pr_efi(sys_table_arg, "KASLR disabled on kernel command line\n"); |
| 70 | } |
| 71 | } |
| 72 | |
| 73 | /* |
| 74 | * The preferred offset of the kernel Image is TEXT_OFFSET bytes beyond |
| 75 | * a 2 MB aligned base, which itself may be lower than dram_base, as |
| 76 | * long as the resulting offset equals or exceeds it. |
| 77 | */ |
| 78 | preferred_offset = round_down(dram_base, MIN_KIMG_ALIGN) + TEXT_OFFSET; |
| 79 | if (preferred_offset < dram_base) |
| 80 | preferred_offset += MIN_KIMG_ALIGN; |
| 81 | |
| 82 | kernel_size = _edata - _text; |
| 83 | kernel_memsize = kernel_size + (_end - _edata); |
| 84 | |
| 85 | if (IS_ENABLED(CONFIG_RANDOMIZE_BASE) && phys_seed != 0) { |
| 86 | /* |
| 87 | * If CONFIG_DEBUG_ALIGN_RODATA is not set, produce a |
| 88 | * displacement in the interval [0, MIN_KIMG_ALIGN) that |
| 89 | * doesn't violate this kernel's de-facto alignment |
| 90 | * constraints. |
| 91 | */ |
| 92 | u32 mask = (MIN_KIMG_ALIGN - 1) & ~(EFI_KIMG_ALIGN - 1); |
| 93 | u32 offset = !IS_ENABLED(CONFIG_DEBUG_ALIGN_RODATA) ? |
| 94 | (phys_seed >> 32) & mask : TEXT_OFFSET; |
| 95 | |
| 96 | /* |
| 97 | * With CONFIG_RANDOMIZE_TEXT_OFFSET=y, TEXT_OFFSET may not |
| 98 | * be a multiple of EFI_KIMG_ALIGN, and we must ensure that |
| 99 | * we preserve the misalignment of 'offset' relative to |
| 100 | * EFI_KIMG_ALIGN so that statically allocated objects whose |
| 101 | * alignment exceeds PAGE_SIZE appear correctly aligned in |
| 102 | * memory. |
| 103 | */ |
| 104 | offset |= TEXT_OFFSET % EFI_KIMG_ALIGN; |
| 105 | |
| 106 | /* |
| 107 | * If KASLR is enabled, and we have some randomness available, |
| 108 | * locate the kernel at a randomized offset in physical memory. |
| 109 | */ |
| 110 | *reserve_size = kernel_memsize + offset; |
| 111 | status = efi_random_alloc(sys_table_arg, *reserve_size, |
| 112 | MIN_KIMG_ALIGN, reserve_addr, |
| 113 | (u32)phys_seed); |
| 114 | |
| 115 | *image_addr = *reserve_addr + offset; |
| 116 | } else { |
| 117 | /* |
| 118 | * Else, try a straight allocation at the preferred offset. |
| 119 | * This will work around the issue where, if dram_base == 0x0, |
| 120 | * efi_low_alloc() refuses to allocate at 0x0 (to prevent the |
| 121 | * address of the allocation to be mistaken for a FAIL return |
| 122 | * value or a NULL pointer). It will also ensure that, on |
| 123 | * platforms where the [dram_base, dram_base + TEXT_OFFSET) |
| 124 | * interval is partially occupied by the firmware (like on APM |
| 125 | * Mustang), we can still place the kernel at the address |
| 126 | * 'dram_base + TEXT_OFFSET'. |
| 127 | */ |
| 128 | if (*image_addr == preferred_offset) |
| 129 | return EFI_SUCCESS; |
| 130 | |
| 131 | *image_addr = *reserve_addr = preferred_offset; |
| 132 | *reserve_size = round_up(kernel_memsize, EFI_ALLOC_ALIGN); |
| 133 | |
| 134 | status = efi_call_early(allocate_pages, EFI_ALLOCATE_ADDRESS, |
| 135 | EFI_LOADER_DATA, |
| 136 | *reserve_size / EFI_PAGE_SIZE, |
| 137 | (efi_physical_addr_t *)reserve_addr); |
| 138 | } |
| 139 | |
| 140 | if (status != EFI_SUCCESS) { |
| 141 | *reserve_size = kernel_memsize + TEXT_OFFSET; |
| 142 | status = efi_low_alloc(sys_table_arg, *reserve_size, |
| 143 | MIN_KIMG_ALIGN, reserve_addr); |
| 144 | |
| 145 | if (status != EFI_SUCCESS) { |
| 146 | pr_efi_err(sys_table_arg, "Failed to relocate kernel\n"); |
| 147 | *reserve_size = 0; |
| 148 | return status; |
| 149 | } |
| 150 | *image_addr = *reserve_addr + TEXT_OFFSET; |
| 151 | } |
| 152 | memcpy((void *)*image_addr, old_image_addr, kernel_size); |
| 153 | |
| 154 | return EFI_SUCCESS; |
| 155 | } |