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 static inline bool mmap_has_headroom(unsigned long buff_size, 9 unsigned long map_size, 10 unsigned long desc_size) 11 { 12 unsigned long slack = buff_size - map_size; 13 14 return slack / desc_size >= EFI_MMAP_NR_SLACK_SLOTS; 15 } 16 17 /** 18 * efi_get_memory_map() - get memory map 19 * @map: on return pointer to memory map 20 * 21 * Retrieve the UEFI memory map. The allocated memory leaves room for 22 * up to EFI_MMAP_NR_SLACK_SLOTS additional memory map entries. 23 * 24 * Return: status code 25 */ 26 efi_status_t efi_get_memory_map(struct efi_boot_memmap *map) 27 { 28 efi_memory_desc_t *m = NULL; 29 efi_status_t status; 30 unsigned long key; 31 u32 desc_version; 32 33 *map->desc_size = sizeof(*m); 34 *map->map_size = *map->desc_size * 32; 35 *map->buff_size = *map->map_size; 36 again: 37 status = efi_bs_call(allocate_pool, EFI_LOADER_DATA, 38 *map->map_size, (void **)&m); 39 if (status != EFI_SUCCESS) 40 goto fail; 41 42 *map->desc_size = 0; 43 key = 0; 44 status = efi_bs_call(get_memory_map, map->map_size, m, 45 &key, map->desc_size, &desc_version); 46 if (status == EFI_BUFFER_TOO_SMALL || 47 !mmap_has_headroom(*map->buff_size, *map->map_size, 48 *map->desc_size)) { 49 efi_bs_call(free_pool, m); 50 /* 51 * Make sure there is some entries of headroom so that the 52 * buffer can be reused for a new map after allocations are 53 * no longer permitted. Its unlikely that the map will grow to 54 * exceed this headroom once we are ready to trigger 55 * ExitBootServices() 56 */ 57 *map->map_size += *map->desc_size * EFI_MMAP_NR_SLACK_SLOTS; 58 *map->buff_size = *map->map_size; 59 goto again; 60 } 61 62 if (status == EFI_SUCCESS) { 63 if (map->key_ptr) 64 *map->key_ptr = key; 65 if (map->desc_ver) 66 *map->desc_ver = desc_version; 67 } else { 68 efi_bs_call(free_pool, m); 69 } 70 71 fail: 72 *map->map = m; 73 return status; 74 } 75 76 /** 77 * efi_allocate_pages() - Allocate memory pages 78 * @size: minimum number of bytes to allocate 79 * @addr: On return the address of the first allocated page. The first 80 * allocated page has alignment EFI_ALLOC_ALIGN which is an 81 * architecture dependent multiple of the page size. 82 * @max: the address that the last allocated memory page shall not 83 * exceed 84 * 85 * Allocate pages as EFI_LOADER_DATA. The allocated pages are aligned according 86 * to EFI_ALLOC_ALIGN. The last allocated page will not exceed the address 87 * given by @max. 88 * 89 * Return: status code 90 */ 91 efi_status_t efi_allocate_pages(unsigned long size, unsigned long *addr, 92 unsigned long max) 93 { 94 efi_physical_addr_t alloc_addr; 95 efi_status_t status; 96 97 if (EFI_ALLOC_ALIGN > EFI_PAGE_SIZE) 98 return efi_allocate_pages_aligned(size, addr, max, 99 EFI_ALLOC_ALIGN); 100 101 alloc_addr = ALIGN_DOWN(max + 1, EFI_ALLOC_ALIGN) - 1; 102 status = efi_bs_call(allocate_pages, EFI_ALLOCATE_MAX_ADDRESS, 103 EFI_LOADER_DATA, DIV_ROUND_UP(size, EFI_PAGE_SIZE), 104 &alloc_addr); 105 if (status != EFI_SUCCESS) 106 return status; 107 108 *addr = alloc_addr; 109 return EFI_SUCCESS; 110 } 111 112 /** 113 * efi_free() - free memory pages 114 * @size: size of the memory area to free in bytes 115 * @addr: start of the memory area to free (must be EFI_PAGE_SIZE 116 * aligned) 117 * 118 * @size is rounded up to a multiple of EFI_ALLOC_ALIGN which is an 119 * architecture specific multiple of EFI_PAGE_SIZE. So this function should 120 * only be used to return pages allocated with efi_allocate_pages() or 121 * efi_low_alloc_above(). 122 */ 123 void efi_free(unsigned long size, unsigned long addr) 124 { 125 unsigned long nr_pages; 126 127 if (!size) 128 return; 129 130 nr_pages = round_up(size, EFI_ALLOC_ALIGN) / EFI_PAGE_SIZE; 131 efi_bs_call(free_pages, addr, nr_pages); 132 } 133