1 // SPDX-License-Identifier: GPL-2.0-only 2 3 #include <linux/efi.h> 4 #include <asm/efi.h> 5 #include "efistub.h" 6 7 struct efi_unaccepted_memory *unaccepted_table; 8 9 efi_status_t allocate_unaccepted_bitmap(__u32 nr_desc, 10 struct efi_boot_memmap *map) 11 { 12 efi_guid_t unaccepted_table_guid = LINUX_EFI_UNACCEPTED_MEM_TABLE_GUID; 13 u64 unaccepted_start = ULLONG_MAX, unaccepted_end = 0, bitmap_size; 14 efi_status_t status; 15 int i; 16 17 /* Check if the table is already installed */ 18 unaccepted_table = get_efi_config_table(unaccepted_table_guid); 19 if (unaccepted_table) { 20 if (unaccepted_table->version != 1) { 21 efi_err("Unknown version of unaccepted memory table\n"); 22 return EFI_UNSUPPORTED; 23 } 24 return EFI_SUCCESS; 25 } 26 27 /* Check if there's any unaccepted memory and find the max address */ 28 for (i = 0; i < nr_desc; i++) { 29 efi_memory_desc_t *d; 30 unsigned long m = (unsigned long)map->map; 31 32 d = efi_early_memdesc_ptr(m, map->desc_size, i); 33 if (d->type != EFI_UNACCEPTED_MEMORY) 34 continue; 35 36 unaccepted_start = min(unaccepted_start, d->phys_addr); 37 unaccepted_end = max(unaccepted_end, 38 d->phys_addr + d->num_pages * PAGE_SIZE); 39 } 40 41 if (unaccepted_start == ULLONG_MAX) 42 return EFI_SUCCESS; 43 44 unaccepted_start = round_down(unaccepted_start, 45 EFI_UNACCEPTED_UNIT_SIZE); 46 unaccepted_end = round_up(unaccepted_end, EFI_UNACCEPTED_UNIT_SIZE); 47 48 /* 49 * If unaccepted memory is present, allocate a bitmap to track what 50 * memory has to be accepted before access. 51 * 52 * One bit in the bitmap represents 2MiB in the address space: 53 * A 4k bitmap can track 64GiB of physical address space. 54 * 55 * In the worst case scenario -- a huge hole in the middle of the 56 * address space -- It needs 256MiB to handle 4PiB of the address 57 * space. 58 * 59 * The bitmap will be populated in setup_e820() according to the memory 60 * map after efi_exit_boot_services(). 61 */ 62 bitmap_size = DIV_ROUND_UP(unaccepted_end - unaccepted_start, 63 EFI_UNACCEPTED_UNIT_SIZE * BITS_PER_BYTE); 64 65 status = efi_bs_call(allocate_pool, EFI_ACPI_RECLAIM_MEMORY, 66 sizeof(*unaccepted_table) + bitmap_size, 67 (void **)&unaccepted_table); 68 if (status != EFI_SUCCESS) { 69 efi_err("Failed to allocate unaccepted memory config table\n"); 70 return status; 71 } 72 73 unaccepted_table->version = 1; 74 unaccepted_table->unit_size = EFI_UNACCEPTED_UNIT_SIZE; 75 unaccepted_table->phys_base = unaccepted_start; 76 unaccepted_table->size = bitmap_size; 77 memset(unaccepted_table->bitmap, 0, bitmap_size); 78 79 status = efi_bs_call(install_configuration_table, 80 &unaccepted_table_guid, unaccepted_table); 81 if (status != EFI_SUCCESS) { 82 efi_bs_call(free_pool, unaccepted_table); 83 efi_err("Failed to install unaccepted memory config table!\n"); 84 } 85 86 return status; 87 } 88 89 /* 90 * The accepted memory bitmap only works at unit_size granularity. Take 91 * unaligned start/end addresses and either: 92 * 1. Accepts the memory immediately and in its entirety 93 * 2. Accepts unaligned parts, and marks *some* aligned part unaccepted 94 * 95 * The function will never reach the bitmap_set() with zero bits to set. 96 */ 97 void process_unaccepted_memory(u64 start, u64 end) 98 { 99 u64 unit_size = unaccepted_table->unit_size; 100 u64 unit_mask = unaccepted_table->unit_size - 1; 101 u64 bitmap_size = unaccepted_table->size; 102 103 /* 104 * Ensure that at least one bit will be set in the bitmap by 105 * immediately accepting all regions under 2*unit_size. This is 106 * imprecise and may immediately accept some areas that could 107 * have been represented in the bitmap. But, results in simpler 108 * code below 109 * 110 * Consider case like this (assuming unit_size == 2MB): 111 * 112 * | 4k | 2044k | 2048k | 113 * ^ 0x0 ^ 2MB ^ 4MB 114 * 115 * Only the first 4k has been accepted. The 0MB->2MB region can not be 116 * represented in the bitmap. The 2MB->4MB region can be represented in 117 * the bitmap. But, the 0MB->4MB region is <2*unit_size and will be 118 * immediately accepted in its entirety. 119 */ 120 if (end - start < 2 * unit_size) { 121 arch_accept_memory(start, end); 122 return; 123 } 124 125 /* 126 * No matter how the start and end are aligned, at least one unaccepted 127 * unit_size area will remain to be marked in the bitmap. 128 */ 129 130 /* Immediately accept a <unit_size piece at the start: */ 131 if (start & unit_mask) { 132 arch_accept_memory(start, round_up(start, unit_size)); 133 start = round_up(start, unit_size); 134 } 135 136 /* Immediately accept a <unit_size piece at the end: */ 137 if (end & unit_mask) { 138 arch_accept_memory(round_down(end, unit_size), end); 139 end = round_down(end, unit_size); 140 } 141 142 /* 143 * Accept part of the range that before phys_base and cannot be recorded 144 * into the bitmap. 145 */ 146 if (start < unaccepted_table->phys_base) { 147 arch_accept_memory(start, 148 min(unaccepted_table->phys_base, end)); 149 start = unaccepted_table->phys_base; 150 } 151 152 /* Nothing to record */ 153 if (end < unaccepted_table->phys_base) 154 return; 155 156 /* Translate to offsets from the beginning of the bitmap */ 157 start -= unaccepted_table->phys_base; 158 end -= unaccepted_table->phys_base; 159 160 /* Accept memory that doesn't fit into bitmap */ 161 if (end > bitmap_size * unit_size * BITS_PER_BYTE) { 162 unsigned long phys_start, phys_end; 163 164 phys_start = bitmap_size * unit_size * BITS_PER_BYTE + 165 unaccepted_table->phys_base; 166 phys_end = end + unaccepted_table->phys_base; 167 168 arch_accept_memory(phys_start, phys_end); 169 end = bitmap_size * unit_size * BITS_PER_BYTE; 170 } 171 172 /* 173 * 'start' and 'end' are now both unit_size-aligned. 174 * Record the range as being unaccepted: 175 */ 176 bitmap_set(unaccepted_table->bitmap, 177 start / unit_size, (end - start) / unit_size); 178 } 179 180 void accept_memory(phys_addr_t start, phys_addr_t end) 181 { 182 unsigned long range_start, range_end; 183 unsigned long bitmap_size; 184 u64 unit_size; 185 186 if (!unaccepted_table) 187 return; 188 189 unit_size = unaccepted_table->unit_size; 190 191 /* 192 * Only care for the part of the range that is represented 193 * in the bitmap. 194 */ 195 if (start < unaccepted_table->phys_base) 196 start = unaccepted_table->phys_base; 197 if (end < unaccepted_table->phys_base) 198 return; 199 200 /* Translate to offsets from the beginning of the bitmap */ 201 start -= unaccepted_table->phys_base; 202 end -= unaccepted_table->phys_base; 203 204 /* Make sure not to overrun the bitmap */ 205 if (end > unaccepted_table->size * unit_size * BITS_PER_BYTE) 206 end = unaccepted_table->size * unit_size * BITS_PER_BYTE; 207 208 range_start = start / unit_size; 209 bitmap_size = DIV_ROUND_UP(end, unit_size); 210 211 for_each_set_bitrange_from(range_start, range_end, 212 unaccepted_table->bitmap, bitmap_size) { 213 unsigned long phys_start, phys_end; 214 215 phys_start = range_start * unit_size + unaccepted_table->phys_base; 216 phys_end = range_end * unit_size + unaccepted_table->phys_base; 217 218 arch_accept_memory(phys_start, phys_end); 219 bitmap_clear(unaccepted_table->bitmap, 220 range_start, range_end - range_start); 221 } 222 } 223