1 // SPDX-License-Identifier: GPL-2.0 2 3 #include <linux/efi.h> 4 #include <asm/efi.h> 5 6 #include "efistub.h" 7 8 #define EFI_MMAP_NR_SLACK_SLOTS 8 9 10 static inline bool mmap_has_headroom(unsigned long buff_size, 11 unsigned long map_size, 12 unsigned long desc_size) 13 { 14 unsigned long slack = buff_size - map_size; 15 16 return slack / desc_size >= EFI_MMAP_NR_SLACK_SLOTS; 17 } 18 19 /** 20 * efi_get_memory_map() - get memory map 21 * @map: on return pointer to memory map 22 * 23 * Retrieve the UEFI memory map. The allocated memory leaves room for 24 * up to EFI_MMAP_NR_SLACK_SLOTS additional memory map entries. 25 * 26 * Return: status code 27 */ 28 efi_status_t efi_get_memory_map(struct efi_boot_memmap *map) 29 { 30 efi_memory_desc_t *m = NULL; 31 efi_status_t status; 32 unsigned long key; 33 u32 desc_version; 34 35 *map->desc_size = sizeof(*m); 36 *map->map_size = *map->desc_size * 32; 37 *map->buff_size = *map->map_size; 38 again: 39 status = efi_bs_call(allocate_pool, EFI_LOADER_DATA, 40 *map->map_size, (void **)&m); 41 if (status != EFI_SUCCESS) 42 goto fail; 43 44 *map->desc_size = 0; 45 key = 0; 46 status = efi_bs_call(get_memory_map, map->map_size, m, 47 &key, map->desc_size, &desc_version); 48 if (status == EFI_BUFFER_TOO_SMALL || 49 !mmap_has_headroom(*map->buff_size, *map->map_size, 50 *map->desc_size)) { 51 efi_bs_call(free_pool, m); 52 /* 53 * Make sure there is some entries of headroom so that the 54 * buffer can be reused for a new map after allocations are 55 * no longer permitted. Its unlikely that the map will grow to 56 * exceed this headroom once we are ready to trigger 57 * ExitBootServices() 58 */ 59 *map->map_size += *map->desc_size * EFI_MMAP_NR_SLACK_SLOTS; 60 *map->buff_size = *map->map_size; 61 goto again; 62 } 63 64 if (status == EFI_SUCCESS) { 65 if (map->key_ptr) 66 *map->key_ptr = key; 67 if (map->desc_ver) 68 *map->desc_ver = desc_version; 69 } else { 70 efi_bs_call(free_pool, m); 71 } 72 73 fail: 74 *map->map = m; 75 return status; 76 } 77 78 /** 79 * efi_allocate_pages() - Allocate memory pages 80 * @size: minimum number of bytes to allocate 81 * @addr: On return the address of the first allocated page. The first 82 * allocated page has alignment EFI_ALLOC_ALIGN which is an 83 * architecture dependent multiple of the page size. 84 * @max: the address that the last allocated memory page shall not 85 * exceed 86 * 87 * Allocate pages as EFI_LOADER_DATA. The allocated pages are aligned according 88 * to EFI_ALLOC_ALIGN. The last allocated page will not exceed the address 89 * given by @max. 90 * 91 * Return: status code 92 */ 93 efi_status_t efi_allocate_pages(unsigned long size, unsigned long *addr, 94 unsigned long max) 95 { 96 efi_physical_addr_t alloc_addr; 97 efi_status_t status; 98 99 if (EFI_ALLOC_ALIGN > EFI_PAGE_SIZE) 100 return efi_allocate_pages_aligned(size, addr, max, 101 EFI_ALLOC_ALIGN); 102 103 alloc_addr = ALIGN_DOWN(max + 1, EFI_ALLOC_ALIGN) - 1; 104 status = efi_bs_call(allocate_pages, EFI_ALLOCATE_MAX_ADDRESS, 105 EFI_LOADER_DATA, DIV_ROUND_UP(size, EFI_PAGE_SIZE), 106 &alloc_addr); 107 if (status != EFI_SUCCESS) 108 return status; 109 110 *addr = alloc_addr; 111 return EFI_SUCCESS; 112 } 113 114 /** 115 * efi_low_alloc_above() - allocate pages at or above given address 116 * @size: size of the memory area to allocate 117 * @align: minimum alignment of the allocated memory area. It should 118 * a power of two. 119 * @addr: on exit the address of the allocated memory 120 * @min: minimum address to used for the memory allocation 121 * 122 * Allocate at the lowest possible address that is not below @min as 123 * EFI_LOADER_DATA. The allocated pages are aligned according to @align but at 124 * least EFI_ALLOC_ALIGN. The first allocated page will not below the address 125 * given by @min. 126 * 127 * Return: status code 128 */ 129 efi_status_t efi_low_alloc_above(unsigned long size, unsigned long align, 130 unsigned long *addr, unsigned long min) 131 { 132 unsigned long map_size, desc_size, buff_size; 133 efi_memory_desc_t *map; 134 efi_status_t status; 135 unsigned long nr_pages; 136 int i; 137 struct efi_boot_memmap boot_map; 138 139 boot_map.map = ↦ 140 boot_map.map_size = &map_size; 141 boot_map.desc_size = &desc_size; 142 boot_map.desc_ver = NULL; 143 boot_map.key_ptr = NULL; 144 boot_map.buff_size = &buff_size; 145 146 status = efi_get_memory_map(&boot_map); 147 if (status != EFI_SUCCESS) 148 goto fail; 149 150 /* 151 * Enforce minimum alignment that EFI or Linux requires when 152 * requesting a specific address. We are doing page-based (or 153 * larger) allocations, and both the address and size must meet 154 * alignment constraints. 155 */ 156 if (align < EFI_ALLOC_ALIGN) 157 align = EFI_ALLOC_ALIGN; 158 159 size = round_up(size, EFI_ALLOC_ALIGN); 160 nr_pages = size / EFI_PAGE_SIZE; 161 for (i = 0; i < map_size / desc_size; i++) { 162 efi_memory_desc_t *desc; 163 unsigned long m = (unsigned long)map; 164 u64 start, end; 165 166 desc = efi_early_memdesc_ptr(m, desc_size, i); 167 168 if (desc->type != EFI_CONVENTIONAL_MEMORY) 169 continue; 170 171 if (efi_soft_reserve_enabled() && 172 (desc->attribute & EFI_MEMORY_SP)) 173 continue; 174 175 if (desc->num_pages < nr_pages) 176 continue; 177 178 start = desc->phys_addr; 179 end = start + desc->num_pages * EFI_PAGE_SIZE; 180 181 if (start < min) 182 start = min; 183 184 start = round_up(start, align); 185 if ((start + size) > end) 186 continue; 187 188 status = efi_bs_call(allocate_pages, EFI_ALLOCATE_ADDRESS, 189 EFI_LOADER_DATA, nr_pages, &start); 190 if (status == EFI_SUCCESS) { 191 *addr = start; 192 break; 193 } 194 } 195 196 if (i == map_size / desc_size) 197 status = EFI_NOT_FOUND; 198 199 efi_bs_call(free_pool, map); 200 fail: 201 return status; 202 } 203 204 /** 205 * efi_free() - free memory pages 206 * @size: size of the memory area to free in bytes 207 * @addr: start of the memory area to free (must be EFI_PAGE_SIZE 208 * aligned) 209 * 210 * @size is rounded up to a multiple of EFI_ALLOC_ALIGN which is an 211 * architecture specific multiple of EFI_PAGE_SIZE. So this function should 212 * only be used to return pages allocated with efi_allocate_pages() or 213 * efi_low_alloc_above(). 214 */ 215 void efi_free(unsigned long size, unsigned long addr) 216 { 217 unsigned long nr_pages; 218 219 if (!size) 220 return; 221 222 nr_pages = round_up(size, EFI_ALLOC_ALIGN) / EFI_PAGE_SIZE; 223 efi_bs_call(free_pages, addr, nr_pages); 224 } 225 226 /** 227 * efi_relocate_kernel() - copy memory area 228 * @image_addr: pointer to address of memory area to copy 229 * @image_size: size of memory area to copy 230 * @alloc_size: minimum size of memory to allocate, must be greater or 231 * equal to image_size 232 * @preferred_addr: preferred target address 233 * @alignment: minimum alignment of the allocated memory area. It 234 * should be a power of two. 235 * @min_addr: minimum target address 236 * 237 * Copy a memory area to a newly allocated memory area aligned according 238 * to @alignment but at least EFI_ALLOC_ALIGN. If the preferred address 239 * is not available, the allocated address will not be below @min_addr. 240 * On exit, @image_addr is updated to the target copy address that was used. 241 * 242 * This function is used to copy the Linux kernel verbatim. It does not apply 243 * any relocation changes. 244 * 245 * Return: status code 246 */ 247 efi_status_t efi_relocate_kernel(unsigned long *image_addr, 248 unsigned long image_size, 249 unsigned long alloc_size, 250 unsigned long preferred_addr, 251 unsigned long alignment, 252 unsigned long min_addr) 253 { 254 unsigned long cur_image_addr; 255 unsigned long new_addr = 0; 256 efi_status_t status; 257 unsigned long nr_pages; 258 efi_physical_addr_t efi_addr = preferred_addr; 259 260 if (!image_addr || !image_size || !alloc_size) 261 return EFI_INVALID_PARAMETER; 262 if (alloc_size < image_size) 263 return EFI_INVALID_PARAMETER; 264 265 cur_image_addr = *image_addr; 266 267 /* 268 * The EFI firmware loader could have placed the kernel image 269 * anywhere in memory, but the kernel has restrictions on the 270 * max physical address it can run at. Some architectures 271 * also have a prefered address, so first try to relocate 272 * to the preferred address. If that fails, allocate as low 273 * as possible while respecting the required alignment. 274 */ 275 nr_pages = round_up(alloc_size, EFI_ALLOC_ALIGN) / EFI_PAGE_SIZE; 276 status = efi_bs_call(allocate_pages, EFI_ALLOCATE_ADDRESS, 277 EFI_LOADER_DATA, nr_pages, &efi_addr); 278 new_addr = efi_addr; 279 /* 280 * If preferred address allocation failed allocate as low as 281 * possible. 282 */ 283 if (status != EFI_SUCCESS) { 284 status = efi_low_alloc_above(alloc_size, alignment, &new_addr, 285 min_addr); 286 } 287 if (status != EFI_SUCCESS) { 288 pr_efi_err("Failed to allocate usable memory for kernel.\n"); 289 return status; 290 } 291 292 /* 293 * We know source/dest won't overlap since both memory ranges 294 * have been allocated by UEFI, so we can safely use memcpy. 295 */ 296 memcpy((void *)new_addr, (void *)cur_image_addr, image_size); 297 298 /* Return the new address of the relocated image. */ 299 *image_addr = new_addr; 300 301 return status; 302 } 303