relocate.c

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