1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Helper functions used by the EFI stub on multiple 4 * architectures to deal with physical address space randomization. 5 */ 6 #include <linux/efi.h> 7 8 #include "efistub.h" 9 10 /** 11 * efi_kaslr_get_phys_seed() - Get random seed for physical kernel KASLR 12 * @image_handle: Handle to the image 13 * 14 * If KASLR is not disabled, obtain a random seed using EFI_RNG_PROTOCOL 15 * that will be used to move the kernel physical mapping. 16 * 17 * Return: the random seed 18 */ 19 u32 efi_kaslr_get_phys_seed(efi_handle_t image_handle) 20 { 21 efi_status_t status; 22 u32 phys_seed; 23 efi_guid_t li_fixed_proto = LINUX_EFI_LOADED_IMAGE_FIXED_GUID; 24 void *p; 25 26 if (!IS_ENABLED(CONFIG_RANDOMIZE_BASE)) 27 return 0; 28 29 if (efi_nokaslr) { 30 efi_info("KASLR disabled on kernel command line\n"); 31 } else if (efi_bs_call(handle_protocol, image_handle, 32 &li_fixed_proto, &p) == EFI_SUCCESS) { 33 efi_info("Image placement fixed by loader\n"); 34 } else { 35 status = efi_get_random_bytes(sizeof(phys_seed), 36 (u8 *)&phys_seed); 37 if (status == EFI_SUCCESS) { 38 return phys_seed; 39 } else if (status == EFI_NOT_FOUND) { 40 efi_info("EFI_RNG_PROTOCOL unavailable\n"); 41 efi_nokaslr = true; 42 } else if (status != EFI_SUCCESS) { 43 efi_err("efi_get_random_bytes() failed (0x%lx)\n", 44 status); 45 efi_nokaslr = true; 46 } 47 } 48 49 return 0; 50 } 51 52 /* 53 * Distro versions of GRUB may ignore the BSS allocation entirely (i.e., fail 54 * to provide space, and fail to zero it). Check for this condition by double 55 * checking that the first and the last byte of the image are covered by the 56 * same EFI memory map entry. 57 */ 58 static bool check_image_region(u64 base, u64 size) 59 { 60 struct efi_boot_memmap *map; 61 efi_status_t status; 62 bool ret = false; 63 int map_offset; 64 65 status = efi_get_memory_map(&map, false); 66 if (status != EFI_SUCCESS) 67 return false; 68 69 for (map_offset = 0; map_offset < map->map_size; map_offset += map->desc_size) { 70 efi_memory_desc_t *md = (void *)map->map + map_offset; 71 u64 end = md->phys_addr + md->num_pages * EFI_PAGE_SIZE; 72 73 /* 74 * Find the region that covers base, and return whether 75 * it covers base+size bytes. 76 */ 77 if (base >= md->phys_addr && base < end) { 78 ret = (base + size) <= end; 79 break; 80 } 81 } 82 83 efi_bs_call(free_pool, map); 84 85 return ret; 86 } 87 88 /** 89 * efi_kaslr_relocate_kernel() - Relocate the kernel (random if KASLR enabled) 90 * @image_addr: Pointer to the current kernel location 91 * @reserve_addr: Pointer to the relocated kernel location 92 * @reserve_size: Size of the relocated kernel 93 * @kernel_size: Size of the text + data 94 * @kernel_codesize: Size of the text 95 * @kernel_memsize: Size of the text + data + bss 96 * @phys_seed: Random seed used for the relocation 97 * 98 * If KASLR is not enabled, this function relocates the kernel to a fixed 99 * address (or leave it as its current location). If KASLR is enabled, the 100 * kernel physical location is randomized using the seed in parameter. 101 * 102 * Return: status code, EFI_SUCCESS if relocation is successful 103 */ 104 efi_status_t efi_kaslr_relocate_kernel(unsigned long *image_addr, 105 unsigned long *reserve_addr, 106 unsigned long *reserve_size, 107 unsigned long kernel_size, 108 unsigned long kernel_codesize, 109 unsigned long kernel_memsize, 110 u32 phys_seed) 111 { 112 efi_status_t status; 113 u64 min_kimg_align = efi_get_kimg_min_align(); 114 115 if (IS_ENABLED(CONFIG_RANDOMIZE_BASE) && phys_seed != 0) { 116 /* 117 * If KASLR is enabled, and we have some randomness available, 118 * locate the kernel at a randomized offset in physical memory. 119 */ 120 status = efi_random_alloc(*reserve_size, min_kimg_align, 121 reserve_addr, phys_seed, 122 EFI_LOADER_CODE, 0, EFI_ALLOC_LIMIT); 123 if (status != EFI_SUCCESS) 124 efi_warn("efi_random_alloc() failed: 0x%lx\n", status); 125 } else { 126 status = EFI_OUT_OF_RESOURCES; 127 } 128 129 if (status != EFI_SUCCESS) { 130 if (!check_image_region(*image_addr, kernel_memsize)) { 131 efi_err("FIRMWARE BUG: Image BSS overlaps adjacent EFI memory region\n"); 132 } else if (IS_ALIGNED(*image_addr, min_kimg_align) && 133 (unsigned long)_end < EFI_ALLOC_LIMIT) { 134 /* 135 * Just execute from wherever we were loaded by the 136 * UEFI PE/COFF loader if the placement is suitable. 137 */ 138 *reserve_size = 0; 139 return EFI_SUCCESS; 140 } 141 142 status = efi_allocate_pages_aligned(*reserve_size, reserve_addr, 143 ULONG_MAX, min_kimg_align, 144 EFI_LOADER_CODE); 145 146 if (status != EFI_SUCCESS) { 147 efi_err("Failed to relocate kernel\n"); 148 *reserve_size = 0; 149 return status; 150 } 151 } 152 153 memcpy((void *)*reserve_addr, (void *)*image_addr, kernel_size); 154 *image_addr = *reserve_addr; 155 efi_icache_sync(*image_addr, *image_addr + kernel_codesize); 156 efi_remap_image(*image_addr, *reserve_size, kernel_codesize); 157 158 return status; 159 } 160