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; 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 goto fail; 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_early_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 status = EFI_NOT_FOUND; 83 84 efi_bs_call(free_pool, map); 85 fail: 86 return status; 87 } 88 89 /** 90 * efi_relocate_kernel() - copy memory area 91 * @image_addr: pointer to address of memory area to copy 92 * @image_size: size of memory area to copy 93 * @alloc_size: minimum size of memory to allocate, must be greater or 94 * equal to image_size 95 * @preferred_addr: preferred target address 96 * @alignment: minimum alignment of the allocated memory area. It 97 * should be a power of two. 98 * @min_addr: minimum target address 99 * 100 * Copy a memory area to a newly allocated memory area aligned according 101 * to @alignment but at least EFI_ALLOC_ALIGN. If the preferred address 102 * is not available, the allocated address will not be below @min_addr. 103 * On exit, @image_addr is updated to the target copy address that was used. 104 * 105 * This function is used to copy the Linux kernel verbatim. It does not apply 106 * any relocation changes. 107 * 108 * Return: status code 109 */ 110 efi_status_t efi_relocate_kernel(unsigned long *image_addr, 111 unsigned long image_size, 112 unsigned long alloc_size, 113 unsigned long preferred_addr, 114 unsigned long alignment, 115 unsigned long min_addr) 116 { 117 unsigned long cur_image_addr; 118 unsigned long new_addr = 0; 119 efi_status_t status; 120 unsigned long nr_pages; 121 efi_physical_addr_t efi_addr = preferred_addr; 122 123 if (!image_addr || !image_size || !alloc_size) 124 return EFI_INVALID_PARAMETER; 125 if (alloc_size < image_size) 126 return EFI_INVALID_PARAMETER; 127 128 cur_image_addr = *image_addr; 129 130 /* 131 * The EFI firmware loader could have placed the kernel image 132 * anywhere in memory, but the kernel has restrictions on the 133 * max physical address it can run at. Some architectures 134 * also have a preferred address, so first try to relocate 135 * to the preferred address. If that fails, allocate as low 136 * as possible while respecting the required alignment. 137 */ 138 nr_pages = round_up(alloc_size, EFI_ALLOC_ALIGN) / EFI_PAGE_SIZE; 139 status = efi_bs_call(allocate_pages, EFI_ALLOCATE_ADDRESS, 140 EFI_LOADER_DATA, nr_pages, &efi_addr); 141 new_addr = efi_addr; 142 /* 143 * If preferred address allocation failed allocate as low as 144 * possible. 145 */ 146 if (status != EFI_SUCCESS) { 147 status = efi_low_alloc_above(alloc_size, alignment, &new_addr, 148 min_addr); 149 } 150 if (status != EFI_SUCCESS) { 151 efi_err("Failed to allocate usable memory for kernel.\n"); 152 return status; 153 } 154 155 /* 156 * We know source/dest won't overlap since both memory ranges 157 * have been allocated by UEFI, so we can safely use memcpy. 158 */ 159 memcpy((void *)new_addr, (void *)cur_image_addr, image_size); 160 161 /* Return the new address of the relocated image. */ 162 *image_addr = new_addr; 163 164 return status; 165 } 166