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