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