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 /** 9 * efi_low_alloc_above() - allocate pages at or above given address 10 * @size: size of the memory area to allocate 11 * @align: minimum alignment of the allocated memory area. It should 12 * a power of two. 13 * @addr: on exit the address of the allocated memory 14 * @min: minimum address to used for the memory allocation 15 * 16 * Allocate at the lowest possible address that is not below @min as 17 * EFI_LOADER_DATA. The allocated pages are aligned according to @align but at 18 * least EFI_ALLOC_ALIGN. The first allocated page will not below the address 19 * given by @min. 20 * 21 * Return: status code 22 */ 23 efi_status_t efi_low_alloc_above(unsigned long size, unsigned long align, 24 unsigned long *addr, unsigned long min) 25 { 26 struct efi_boot_memmap *map __free(efi_pool) = NULL; 27 efi_status_t status; 28 unsigned long nr_pages; 29 int i; 30 31 status = efi_get_memory_map(&map, false); 32 if (status != EFI_SUCCESS) 33 return status; 34 35 /* 36 * Enforce minimum alignment that EFI or Linux requires when 37 * requesting a specific address. We are doing page-based (or 38 * larger) allocations, and both the address and size must meet 39 * alignment constraints. 40 */ 41 if (align < EFI_ALLOC_ALIGN) 42 align = EFI_ALLOC_ALIGN; 43 44 size = round_up(size, EFI_ALLOC_ALIGN); 45 nr_pages = size / EFI_PAGE_SIZE; 46 for (i = 0; i < map->map_size / map->desc_size; i++) { 47 efi_memory_desc_t *desc; 48 unsigned long m = (unsigned long)map->map; 49 u64 start, end; 50 51 desc = efi_memdesc_ptr(m, map->desc_size, i); 52 53 if (desc->type != EFI_CONVENTIONAL_MEMORY) 54 continue; 55 56 if (efi_soft_reserve_enabled() && 57 (desc->attribute & EFI_MEMORY_SP)) 58 continue; 59 60 if (desc->num_pages < nr_pages) 61 continue; 62 63 start = desc->phys_addr; 64 end = start + desc->num_pages * EFI_PAGE_SIZE; 65 66 if (start < min) 67 start = min; 68 69 start = round_up(start, align); 70 if ((start + size) > end) 71 continue; 72 73 status = efi_bs_call(allocate_pages, EFI_ALLOCATE_ADDRESS, 74 EFI_LOADER_DATA, nr_pages, &start); 75 if (status == EFI_SUCCESS) { 76 *addr = start; 77 break; 78 } 79 } 80 81 if (i == map->map_size / map->desc_size) 82 return EFI_NOT_FOUND; 83 84 return EFI_SUCCESS; 85 } 86 87 /** 88 * efi_relocate_kernel() - copy memory area 89 * @image_addr: pointer to address of memory area to copy 90 * @image_size: size of memory area to copy 91 * @alloc_size: minimum size of memory to allocate, must be greater or 92 * equal to image_size 93 * @preferred_addr: preferred target address 94 * @alignment: minimum alignment of the allocated memory area. It 95 * should be a power of two. 96 * @min_addr: minimum target address 97 * 98 * Copy a memory area to a newly allocated memory area aligned according 99 * to @alignment but at least EFI_ALLOC_ALIGN. If the preferred address 100 * is not available, the allocated address will not be below @min_addr. 101 * On exit, @image_addr is updated to the target copy address that was used. 102 * 103 * This function is used to copy the Linux kernel verbatim. It does not apply 104 * any relocation changes. 105 * 106 * Return: status code 107 */ 108 efi_status_t efi_relocate_kernel(unsigned long *image_addr, 109 unsigned long image_size, 110 unsigned long alloc_size, 111 unsigned long preferred_addr, 112 unsigned long alignment, 113 unsigned long min_addr) 114 { 115 unsigned long cur_image_addr; 116 unsigned long new_addr = 0; 117 efi_status_t status; 118 unsigned long nr_pages; 119 efi_physical_addr_t efi_addr = preferred_addr; 120 121 if (!image_addr || !image_size || !alloc_size) 122 return EFI_INVALID_PARAMETER; 123 if (alloc_size < image_size) 124 return EFI_INVALID_PARAMETER; 125 126 cur_image_addr = *image_addr; 127 128 /* 129 * The EFI firmware loader could have placed the kernel image 130 * anywhere in memory, but the kernel has restrictions on the 131 * max physical address it can run at. Some architectures 132 * also have a preferred address, so first try to relocate 133 * to the preferred address. If that fails, allocate as low 134 * as possible while respecting the required alignment. 135 */ 136 nr_pages = round_up(alloc_size, EFI_ALLOC_ALIGN) / EFI_PAGE_SIZE; 137 status = efi_bs_call(allocate_pages, EFI_ALLOCATE_ADDRESS, 138 EFI_LOADER_DATA, nr_pages, &efi_addr); 139 new_addr = efi_addr; 140 /* 141 * If preferred address allocation failed allocate as low as 142 * possible. 143 */ 144 if (status != EFI_SUCCESS) { 145 status = efi_low_alloc_above(alloc_size, alignment, &new_addr, 146 min_addr); 147 } 148 if (status != EFI_SUCCESS) { 149 efi_err("Failed to allocate usable memory for kernel.\n"); 150 return status; 151 } 152 153 /* 154 * We know source/dest won't overlap since both memory ranges 155 * have been allocated by UEFI, so we can safely use memcpy. 156 */ 157 memcpy((void *)new_addr, (void *)cur_image_addr, image_size); 158 159 /* Return the new address of the relocated image. */ 160 *image_addr = new_addr; 161 162 return status; 163 } 164