blob: 0abb1f6159ae44843d5d9e50f5df302f89d30600 [file] [log] [blame]
Tom Rini70df9d62018-05-07 17:02:21 -04001// SPDX-License-Identifier: GPL-2.0+
Alexander Graf8623f922016-03-04 01:10:04 +01002/*
3 * EFI application memory management
4 *
5 * Copyright (c) 2016 Alexander Graf
Alexander Graf8623f922016-03-04 01:10:04 +01006 */
7
Heinrich Schuchardt45640252023-03-19 09:20:22 +01008#define LOG_CATEGORY LOGC_EFI
9
Alexander Graf8623f922016-03-04 01:10:04 +010010#include <efi_loader.h>
Simon Glass6980b6b2019-11-14 12:57:45 -070011#include <init.h>
Sughosh Ganufa0ddab2024-10-15 21:07:06 +053012#include <lmb.h>
Heinrich Schuchardt45640252023-03-19 09:20:22 +010013#include <log.h>
Alexander Graf8623f922016-03-04 01:10:04 +010014#include <malloc.h>
Alexander Grafcd405172018-06-18 17:23:15 +020015#include <mapmem.h>
Simon Glass3e852172018-03-08 21:53:27 +010016#include <watchdog.h>
Simon Glass274e0b02020-05-10 11:39:56 -060017#include <asm/cache.h>
Simon Glass3ba929a2020-10-30 21:38:53 -060018#include <asm/global_data.h>
Heinrich Schuchardt211ff082024-04-05 10:12:57 +020019#include <asm/sections.h>
Alexander Grafde2a13b2016-03-30 16:38:29 +020020#include <linux/list_sort.h>
Alexander Graf15937a22018-09-17 13:54:33 +020021#include <linux/sizes.h>
Alexander Graf8623f922016-03-04 01:10:04 +010022
23DECLARE_GLOBAL_DATA_PTR;
24
Heinrich Schuchardtb4e2ba32019-03-26 05:31:41 +010025/* Magic number identifying memory allocated from pool */
26#define EFI_ALLOC_POOL_MAGIC 0x1fe67ddf6491caa2
27
Heinrich Schuchardt0f233c42018-07-02 12:53:55 +020028efi_uintn_t efi_memory_map_key;
29
Alexander Graf8623f922016-03-04 01:10:04 +010030struct efi_mem_list {
31 struct list_head link;
32 struct efi_mem_desc desc;
33};
34
Alexander Graf66d86232016-05-27 12:25:03 +020035#define EFI_CARVE_NO_OVERLAP -1
36#define EFI_CARVE_LOOP_AGAIN -2
37#define EFI_CARVE_OVERLAPS_NONRAM -3
Heinrich Schuchardt17fac0e2023-07-30 12:27:03 +020038#define EFI_CARVE_OUT_OF_RESOURCES -4
Alexander Graf66d86232016-05-27 12:25:03 +020039
Alexander Graf8623f922016-03-04 01:10:04 +010040/* This list contains all memory map items */
Bin Mengc8025a32023-04-05 20:15:18 +080041static LIST_HEAD(efi_mem);
Alexander Graf8623f922016-03-04 01:10:04 +010042
Alexander Graf7c00a3c2016-05-11 18:25:48 +020043#ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER
44void *efi_bounce_buffer;
45#endif
46
Heinrich Schuchardtb4e2ba32019-03-26 05:31:41 +010047/**
Heinrich Schuchardt79f882a2019-07-14 12:28:56 +020048 * struct efi_pool_allocation - memory block allocated from pool
Heinrich Schuchardtb4e2ba32019-03-26 05:31:41 +010049 *
50 * @num_pages: number of pages allocated
51 * @checksum: checksum
Heinrich Schuchardt79f882a2019-07-14 12:28:56 +020052 * @data: allocated pool memory
Heinrich Schuchardtb4e2ba32019-03-26 05:31:41 +010053 *
Heinrich Schuchardt79f882a2019-07-14 12:28:56 +020054 * U-Boot services each UEFI AllocatePool() request as a separate
55 * (multiple) page allocation. We have to track the number of pages
Stefan Brüns67b67d92016-10-09 22:17:26 +020056 * to be able to free the correct amount later.
Heinrich Schuchardt79f882a2019-07-14 12:28:56 +020057 *
58 * The checksum calculated in function checksum() is used in FreePool() to avoid
59 * freeing memory not allocated by AllocatePool() and duplicate freeing.
60 *
Stefan Brüns67b67d92016-10-09 22:17:26 +020061 * EFI requires 8 byte alignment for pool allocations, so we can
Heinrich Schuchardt79f882a2019-07-14 12:28:56 +020062 * prepend each allocation with these header fields.
Stefan Brüns67b67d92016-10-09 22:17:26 +020063 */
64struct efi_pool_allocation {
65 u64 num_pages;
Heinrich Schuchardtb4e2ba32019-03-26 05:31:41 +010066 u64 checksum;
Rob Clarke597fd42017-09-13 18:05:36 -040067 char data[] __aligned(ARCH_DMA_MINALIGN);
Stefan Brüns67b67d92016-10-09 22:17:26 +020068};
69
Heinrich Schuchardtb4e2ba32019-03-26 05:31:41 +010070/**
71 * checksum() - calculate checksum for memory allocated from pool
72 *
73 * @alloc: allocation header
74 * Return: checksum, always non-zero
75 */
76static u64 checksum(struct efi_pool_allocation *alloc)
77{
78 u64 addr = (uintptr_t)alloc;
79 u64 ret = (addr >> 32) ^ (addr << 32) ^ alloc->num_pages ^
80 EFI_ALLOC_POOL_MAGIC;
81 if (!ret)
82 ++ret;
83 return ret;
84}
85
Heinrich Schuchardtb9b838d2023-01-08 01:00:00 +010086/**
87 * efi_mem_cmp() - comparator function for sorting memory map
88 *
Alexander Grafde2a13b2016-03-30 16:38:29 +020089 * Sorts the memory list from highest address to lowest address
90 *
91 * When allocating memory we should always start from the highest
92 * address chunk, so sort the memory list such that the first list
93 * iterator gets the highest address and goes lower from there.
Heinrich Schuchardtb9b838d2023-01-08 01:00:00 +010094 *
95 * @priv: unused
96 * @a: first memory area
97 * @b: second memory area
98 * Return: 1 if @a is before @b, -1 if @b is before @a, 0 if equal
Alexander Grafde2a13b2016-03-30 16:38:29 +020099 */
100static int efi_mem_cmp(void *priv, struct list_head *a, struct list_head *b)
101{
102 struct efi_mem_list *mema = list_entry(a, struct efi_mem_list, link);
103 struct efi_mem_list *memb = list_entry(b, struct efi_mem_list, link);
104
105 if (mema->desc.physical_start == memb->desc.physical_start)
106 return 0;
107 else if (mema->desc.physical_start < memb->desc.physical_start)
108 return 1;
109 else
110 return -1;
111}
112
Heinrich Schuchardtb9b838d2023-01-08 01:00:00 +0100113/**
114 * desc_get_end() - get end address of memory area
115 *
116 * @desc: memory descriptor
117 * Return: end address + 1
118 */
Alexander Grafd7288142018-09-16 17:05:29 +0200119static uint64_t desc_get_end(struct efi_mem_desc *desc)
120{
121 return desc->physical_start + (desc->num_pages << EFI_PAGE_SHIFT);
122}
123
Heinrich Schuchardtb9b838d2023-01-08 01:00:00 +0100124/**
125 * efi_mem_sort() - sort memory map
126 *
127 * Sort the memory map and then try to merge adjacent memory areas.
128 */
Alexander Grafde2a13b2016-03-30 16:38:29 +0200129static void efi_mem_sort(void)
130{
Sughosh Ganu21ad4cc2024-07-30 16:41:31 +0530131 struct efi_mem_list *lmem;
Alexander Grafd7288142018-09-16 17:05:29 +0200132 struct efi_mem_list *prevmem = NULL;
133 bool merge_again = true;
134
Alexander Grafde2a13b2016-03-30 16:38:29 +0200135 list_sort(NULL, &efi_mem, efi_mem_cmp);
Alexander Grafd7288142018-09-16 17:05:29 +0200136
137 /* Now merge entries that can be merged */
138 while (merge_again) {
139 merge_again = false;
Sughosh Ganu21ad4cc2024-07-30 16:41:31 +0530140 list_for_each_entry(lmem, &efi_mem, link) {
Sughosh Ganu7d2c2792024-07-30 16:41:30 +0530141 struct efi_mem_desc *prev;
Alexander Grafd7288142018-09-16 17:05:29 +0200142 struct efi_mem_desc *cur;
143 uint64_t pages;
144
Alexander Grafd7288142018-09-16 17:05:29 +0200145 if (!prevmem) {
146 prevmem = lmem;
147 continue;
148 }
149
150 cur = &lmem->desc;
Sughosh Ganu7d2c2792024-07-30 16:41:30 +0530151 prev = &prevmem->desc;
Alexander Grafd7288142018-09-16 17:05:29 +0200152
153 if ((desc_get_end(cur) == prev->physical_start) &&
154 (prev->type == cur->type) &&
155 (prev->attribute == cur->attribute)) {
156 /* There is an existing map before, reuse it */
157 pages = cur->num_pages;
158 prev->num_pages += pages;
159 prev->physical_start -= pages << EFI_PAGE_SHIFT;
160 prev->virtual_start -= pages << EFI_PAGE_SHIFT;
161 list_del(&lmem->link);
162 free(lmem);
163
164 merge_again = true;
165 break;
166 }
167
168 prevmem = lmem;
169 }
170 }
Alexander Grafde2a13b2016-03-30 16:38:29 +0200171}
172
Heinrich Schuchardtb9b838d2023-01-08 01:00:00 +0100173/**
174 * efi_mem_carve_out() - unmap memory region
Alexander Graf8623f922016-03-04 01:10:04 +0100175 *
Sughosh Ganuc9e6eb62024-10-15 21:07:16 +0530176 * @map: memory map
177 * @carve_desc: memory region to unmap
178 * @overlap_conventional: the carved out region may only overlap free,
179 * or conventional memory
180 * Return: the number of overlapping pages which have been
181 * removed from the map,
182 * EFI_CARVE_NO_OVERLAP, if the regions don't
183 * overlap, EFI_CARVE_OVERLAPS_NONRAM, if the carve
184 * and map overlap, and the map contains anything
185 * but free ram(only when overlap_conventional is
186 * true),
187 * EFI_CARVE_LOOP_AGAIN, if the mapping list should
188 * be traversed again, as it has been altered.
Heinrich Schuchardtf00caa52018-05-27 16:45:09 +0200189 *
190 * Unmaps all memory occupied by the carve_desc region from the list entry
191 * pointed to by map.
Stefan Brüns1b00dc12016-10-01 23:32:23 +0200192 *
193 * In case of EFI_CARVE_OVERLAPS_NONRAM it is the callers responsibility
Heinrich Schuchardtf00caa52018-05-27 16:45:09 +0200194 * to re-add the already carved out pages to the mapping.
Alexander Graf8623f922016-03-04 01:10:04 +0100195 */
Heinrich Schuchardtf00caa52018-05-27 16:45:09 +0200196static s64 efi_mem_carve_out(struct efi_mem_list *map,
Alexander Graf8623f922016-03-04 01:10:04 +0100197 struct efi_mem_desc *carve_desc,
Sughosh Ganuc9e6eb62024-10-15 21:07:16 +0530198 bool overlap_conventional)
Alexander Graf8623f922016-03-04 01:10:04 +0100199{
200 struct efi_mem_list *newmap;
201 struct efi_mem_desc *map_desc = &map->desc;
202 uint64_t map_start = map_desc->physical_start;
203 uint64_t map_end = map_start + (map_desc->num_pages << EFI_PAGE_SHIFT);
204 uint64_t carve_start = carve_desc->physical_start;
205 uint64_t carve_end = carve_start +
206 (carve_desc->num_pages << EFI_PAGE_SHIFT);
207
208 /* check whether we're overlapping */
209 if ((carve_end <= map_start) || (carve_start >= map_end))
Alexander Graf66d86232016-05-27 12:25:03 +0200210 return EFI_CARVE_NO_OVERLAP;
Alexander Graf8623f922016-03-04 01:10:04 +0100211
212 /* We're overlapping with non-RAM, warn the caller if desired */
Sughosh Ganuc9e6eb62024-10-15 21:07:16 +0530213 if (overlap_conventional && (map_desc->type != EFI_CONVENTIONAL_MEMORY))
Alexander Graf66d86232016-05-27 12:25:03 +0200214 return EFI_CARVE_OVERLAPS_NONRAM;
Alexander Graf8623f922016-03-04 01:10:04 +0100215
216 /* Sanitize carve_start and carve_end to lie within our bounds */
217 carve_start = max(carve_start, map_start);
218 carve_end = min(carve_end, map_end);
219
220 /* Carving at the beginning of our map? Just move it! */
221 if (carve_start == map_start) {
222 if (map_end == carve_end) {
223 /* Full overlap, just remove map */
224 list_del(&map->link);
Stefan Brüns4e9ad8d2016-10-01 23:32:29 +0200225 free(map);
226 } else {
227 map->desc.physical_start = carve_end;
Heinrich Schuchardte83aafa2019-04-11 20:08:54 +0200228 map->desc.virtual_start = carve_end;
Stefan Brüns4e9ad8d2016-10-01 23:32:29 +0200229 map->desc.num_pages = (map_end - carve_end)
230 >> EFI_PAGE_SHIFT;
Alexander Graf8623f922016-03-04 01:10:04 +0100231 }
232
Alexander Graf66d86232016-05-27 12:25:03 +0200233 return (carve_end - carve_start) >> EFI_PAGE_SHIFT;
Alexander Graf8623f922016-03-04 01:10:04 +0100234 }
235
236 /*
237 * Overlapping maps, just split the list map at carve_start,
238 * it will get moved or removed in the next iteration.
239 *
240 * [ map_desc |__carve_start__| newmap ]
241 */
242
243 /* Create a new map from [ carve_start ... map_end ] */
244 newmap = calloc(1, sizeof(*newmap));
Heinrich Schuchardt17fac0e2023-07-30 12:27:03 +0200245 if (!newmap)
246 return EFI_CARVE_OUT_OF_RESOURCES;
Alexander Graf8623f922016-03-04 01:10:04 +0100247 newmap->desc = map->desc;
248 newmap->desc.physical_start = carve_start;
Heinrich Schuchardte83aafa2019-04-11 20:08:54 +0200249 newmap->desc.virtual_start = carve_start;
Alexander Graf8623f922016-03-04 01:10:04 +0100250 newmap->desc.num_pages = (map_end - carve_start) >> EFI_PAGE_SHIFT;
Stefan Brüns9d656512016-10-01 23:32:28 +0200251 /* Insert before current entry (descending address order) */
252 list_add_tail(&newmap->link, &map->link);
Alexander Graf8623f922016-03-04 01:10:04 +0100253
254 /* Shrink the map to [ map_start ... carve_start ] */
255 map_desc->num_pages = (carve_start - map_start) >> EFI_PAGE_SHIFT;
256
Alexander Graf66d86232016-05-27 12:25:03 +0200257 return EFI_CARVE_LOOP_AGAIN;
Alexander Graf8623f922016-03-04 01:10:04 +0100258}
259
Bryan O'Donoghue89a22b42019-07-15 12:00:39 +0100260/**
Ilias Apalodimas9e0db622025-03-17 14:03:58 +0530261 * efi_update_memory_map() - update the memory map by adding/removing pages
Bryan O'Donoghue89a22b42019-07-15 12:00:39 +0100262 *
Sughosh Ganuc9e6eb62024-10-15 21:07:16 +0530263 * @start: start address, must be a multiple of
264 * EFI_PAGE_SIZE
265 * @pages: number of pages to add
266 * @memory_type: type of memory added
267 * @overlap_conventional: region may only overlap free(conventional)
268 * memory
Ilias Apalodimas9e0db622025-03-17 14:03:58 +0530269 * @remove: remove memory map
Sughosh Ganuc9e6eb62024-10-15 21:07:16 +0530270 * Return: status code
Bryan O'Donoghue89a22b42019-07-15 12:00:39 +0100271 */
Ilias Apalodimas9e0db622025-03-17 14:03:58 +0530272efi_status_t efi_update_memory_map(u64 start, u64 pages, int memory_type,
273 bool overlap_conventional, bool remove)
Alexander Graf8623f922016-03-04 01:10:04 +0100274{
Sughosh Ganu21ad4cc2024-07-30 16:41:31 +0530275 struct efi_mem_list *lmem;
Alexander Graf8623f922016-03-04 01:10:04 +0100276 struct efi_mem_list *newlist;
Alexander Graf66d86232016-05-27 12:25:03 +0200277 bool carve_again;
278 uint64_t carved_pages = 0;
Heinrich Schuchardt485975b2019-06-04 20:55:12 +0200279 struct efi_event *evt;
Alexander Graf8623f922016-03-04 01:10:04 +0100280
Ilias Apalodimas9e0db622025-03-17 14:03:58 +0530281 EFI_PRINT("%s: 0x%llx 0x%llx %d %s %s\n", __func__,
Sughosh Ganuc9e6eb62024-10-15 21:07:16 +0530282 start, pages, memory_type, overlap_conventional ?
Ilias Apalodimas9e0db622025-03-17 14:03:58 +0530283 "yes" : "no", remove ? "remove" : "add");
Andreas Färber102f8bd2016-07-17 06:57:11 +0200284
Heinrich Schuchardt0f233c42018-07-02 12:53:55 +0200285 if (memory_type >= EFI_MAX_MEMORY_TYPE)
286 return EFI_INVALID_PARAMETER;
287
Alexander Graf8623f922016-03-04 01:10:04 +0100288 if (!pages)
Bryan O'Donoghue89a22b42019-07-15 12:00:39 +0100289 return EFI_SUCCESS;
Alexander Graf8623f922016-03-04 01:10:04 +0100290
Heinrich Schuchardt0f233c42018-07-02 12:53:55 +0200291 ++efi_memory_map_key;
Alexander Graf8623f922016-03-04 01:10:04 +0100292 newlist = calloc(1, sizeof(*newlist));
Heinrich Schuchardt71c24442023-07-30 12:36:17 +0200293 if (!newlist)
294 return EFI_OUT_OF_RESOURCES;
Alexander Graf8623f922016-03-04 01:10:04 +0100295 newlist->desc.type = memory_type;
296 newlist->desc.physical_start = start;
297 newlist->desc.virtual_start = start;
298 newlist->desc.num_pages = pages;
299
300 switch (memory_type) {
301 case EFI_RUNTIME_SERVICES_CODE:
302 case EFI_RUNTIME_SERVICES_DATA:
Eugeniu Roscac86c0812018-07-14 22:53:30 +0200303 newlist->desc.attribute = EFI_MEMORY_WB | EFI_MEMORY_RUNTIME;
Alexander Graf8623f922016-03-04 01:10:04 +0100304 break;
305 case EFI_MMAP_IO:
Eugeniu Roscac86c0812018-07-14 22:53:30 +0200306 newlist->desc.attribute = EFI_MEMORY_RUNTIME;
Alexander Graf8623f922016-03-04 01:10:04 +0100307 break;
308 default:
Eugeniu Roscac86c0812018-07-14 22:53:30 +0200309 newlist->desc.attribute = EFI_MEMORY_WB;
Alexander Graf8623f922016-03-04 01:10:04 +0100310 break;
311 }
312
313 /* Add our new map */
314 do {
Alexander Graf66d86232016-05-27 12:25:03 +0200315 carve_again = false;
Sughosh Ganu21ad4cc2024-07-30 16:41:31 +0530316 list_for_each_entry(lmem, &efi_mem, link) {
Heinrich Schuchardtf00caa52018-05-27 16:45:09 +0200317 s64 r;
Alexander Graf8623f922016-03-04 01:10:04 +0100318
Alexander Graf8623f922016-03-04 01:10:04 +0100319 r = efi_mem_carve_out(lmem, &newlist->desc,
Sughosh Ganuc9e6eb62024-10-15 21:07:16 +0530320 overlap_conventional);
Alexander Graf66d86232016-05-27 12:25:03 +0200321 switch (r) {
Heinrich Schuchardt17fac0e2023-07-30 12:27:03 +0200322 case EFI_CARVE_OUT_OF_RESOURCES:
323 free(newlist);
324 return EFI_OUT_OF_RESOURCES;
Alexander Graf66d86232016-05-27 12:25:03 +0200325 case EFI_CARVE_OVERLAPS_NONRAM:
326 /*
327 * The user requested to only have RAM overlaps,
328 * but we hit a non-RAM region. Error out.
329 */
Heinrich Schuchardt9f0d3ad2023-07-30 12:59:32 +0200330 free(newlist);
Bryan O'Donoghue89a22b42019-07-15 12:00:39 +0100331 return EFI_NO_MAPPING;
Alexander Graf66d86232016-05-27 12:25:03 +0200332 case EFI_CARVE_NO_OVERLAP:
333 /* Just ignore this list entry */
334 break;
335 case EFI_CARVE_LOOP_AGAIN:
336 /*
337 * We split an entry, but need to loop through
338 * the list again to actually carve it.
339 */
340 carve_again = true;
341 break;
342 default:
343 /* We carved a number of pages */
344 carved_pages += r;
345 carve_again = true;
Alexander Graf8623f922016-03-04 01:10:04 +0100346 break;
347 }
Alexander Graf66d86232016-05-27 12:25:03 +0200348
349 if (carve_again) {
350 /* The list changed, we need to start over */
351 break;
352 }
Alexander Graf8623f922016-03-04 01:10:04 +0100353 }
Alexander Graf66d86232016-05-27 12:25:03 +0200354 } while (carve_again);
355
Sughosh Ganuc9e6eb62024-10-15 21:07:16 +0530356 if (overlap_conventional && (carved_pages != pages)) {
Alexander Graf66d86232016-05-27 12:25:03 +0200357 /*
358 * The payload wanted to have RAM overlaps, but we overlapped
359 * with an unallocated region. Error out.
360 */
Heinrich Schuchardt9f0d3ad2023-07-30 12:59:32 +0200361 free(newlist);
Bryan O'Donoghue89a22b42019-07-15 12:00:39 +0100362 return EFI_NO_MAPPING;
Alexander Graf66d86232016-05-27 12:25:03 +0200363 }
Alexander Graf8623f922016-03-04 01:10:04 +0100364
365 /* Add our new map */
Ilias Apalodimas9e0db622025-03-17 14:03:58 +0530366 if (!remove)
367 list_add_tail(&newlist->link, &efi_mem);
368 else
369 free(newlist);
Alexander Graf8623f922016-03-04 01:10:04 +0100370
Alexander Grafde2a13b2016-03-30 16:38:29 +0200371 /* And make sure memory is listed in descending order */
372 efi_mem_sort();
373
Heinrich Schuchardt485975b2019-06-04 20:55:12 +0200374 /* Notify that the memory map was changed */
375 list_for_each_entry(evt, &efi_events, link) {
376 if (evt->group &&
377 !guidcmp(evt->group,
378 &efi_guid_event_group_memory_map_change)) {
Heinrich Schuchardt7b4b8d862019-06-07 06:47:01 +0200379 efi_signal_event(evt);
Heinrich Schuchardt485975b2019-06-04 20:55:12 +0200380 break;
381 }
382 }
383
Bryan O'Donoghue89a22b42019-07-15 12:00:39 +0100384 return EFI_SUCCESS;
Alexander Graf8623f922016-03-04 01:10:04 +0100385}
386
Heinrich Schuchardtac7f8422019-05-10 21:21:30 +0200387/**
Michael Walle282d3862020-05-17 12:29:19 +0200388 * efi_add_memory_map() - add memory area to the memory map
389 *
390 * @start: start address of the memory area
391 * @size: length in bytes of the memory area
392 * @memory_type: type of memory added
393 *
394 * Return: status code
395 *
396 * This function automatically aligns the start and size of the memory area
397 * to EFI_PAGE_SIZE.
398 */
399efi_status_t efi_add_memory_map(u64 start, u64 size, int memory_type)
400{
401 u64 pages;
402
403 pages = efi_size_in_pages(size + (start & EFI_PAGE_MASK));
404 start &= ~EFI_PAGE_MASK;
405
Ilias Apalodimas9e0db622025-03-17 14:03:58 +0530406 return efi_update_memory_map(start, pages, memory_type, false, false);
Michael Walle282d3862020-05-17 12:29:19 +0200407}
408
409/**
Heinrich Schuchardtac7f8422019-05-10 21:21:30 +0200410 * efi_check_allocated() - validate address to be freed
411 *
412 * Check that the address is within allocated memory:
413 *
Heinrich Schuchardtac7f8422019-05-10 21:21:30 +0200414 * * The address must be in a range of the memory map.
415 * * The address may not point to EFI_CONVENTIONAL_MEMORY.
416 *
417 * Page alignment is not checked as this is not a requirement of
418 * efi_free_pool().
419 *
Heinrich Schuchardt906f6852019-05-11 08:21:17 +0200420 * @addr: address of page to be freed
421 * @must_be_allocated: return success if the page is allocated
422 * Return: status code
Heinrich Schuchardtac7f8422019-05-10 21:21:30 +0200423 */
Heinrich Schuchardt906f6852019-05-11 08:21:17 +0200424static efi_status_t efi_check_allocated(u64 addr, bool must_be_allocated)
Heinrich Schuchardtac7f8422019-05-10 21:21:30 +0200425{
426 struct efi_mem_list *item;
427
Heinrich Schuchardtac7f8422019-05-10 21:21:30 +0200428 list_for_each_entry(item, &efi_mem, link) {
429 u64 start = item->desc.physical_start;
430 u64 end = start + (item->desc.num_pages << EFI_PAGE_SHIFT);
431
432 if (addr >= start && addr < end) {
Heinrich Schuchardt906f6852019-05-11 08:21:17 +0200433 if (must_be_allocated ^
434 (item->desc.type == EFI_CONVENTIONAL_MEMORY))
Heinrich Schuchardtac7f8422019-05-10 21:21:30 +0200435 return EFI_SUCCESS;
436 else
437 return EFI_NOT_FOUND;
438 }
439 }
440
441 return EFI_NOT_FOUND;
442}
443
Heinrich Schuchardtb9b838d2023-01-08 01:00:00 +0100444/**
Heinrich Schuchardtb9b838d2023-01-08 01:00:00 +0100445 * efi_allocate_pages - allocate memory pages
Heinrich Schuchardt1b32cae2017-12-04 20:52:41 +0100446 *
Heinrich Schuchardtb9b838d2023-01-08 01:00:00 +0100447 * @type: type of allocation to be performed
448 * @memory_type: usage type of the allocated memory
449 * @pages: number of pages to be allocated
450 * @memory: allocated memory
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100451 * Return: status code
Heinrich Schuchardt1b32cae2017-12-04 20:52:41 +0100452 */
Heinrich Schuchardt98228942021-08-17 15:05:31 +0200453efi_status_t efi_allocate_pages(enum efi_allocate_type type,
454 enum efi_memory_type memory_type,
Heinrich Schuchardt798a4412017-11-06 21:17:48 +0100455 efi_uintn_t pages, uint64_t *memory)
Alexander Graf8623f922016-03-04 01:10:04 +0100456{
Ilias Apalodimasfa5be122024-11-24 11:00:03 +0200457 u64 efi_addr, len;
Sughosh Ganufa0ddab2024-10-15 21:07:06 +0530458 uint flags;
Heinrich Schuchardtfbdb93c2019-05-11 08:43:30 +0200459 efi_status_t ret;
Sughosh Ganufa0ddab2024-10-15 21:07:06 +0530460 phys_addr_t addr;
Alexander Graf8623f922016-03-04 01:10:04 +0100461
Heinrich Schuchardtf7272332019-04-23 00:30:53 +0200462 /* Check import parameters */
463 if (memory_type >= EFI_PERSISTENT_MEMORY_TYPE &&
464 memory_type <= 0x6FFFFFFF)
465 return EFI_INVALID_PARAMETER;
Heinrich Schuchardta137c962018-07-02 12:53:53 +0200466 if (!memory)
467 return EFI_INVALID_PARAMETER;
Heinrich Schuchardtf0c16f92023-07-30 11:31:08 +0200468 len = (u64)pages << EFI_PAGE_SHIFT;
469 /* Catch possible overflow on 64bit systems */
470 if (sizeof(efi_uintn_t) == sizeof(u64) &&
471 (len >> EFI_PAGE_SHIFT) != (u64)pages)
472 return EFI_OUT_OF_RESOURCES;
Heinrich Schuchardta137c962018-07-02 12:53:53 +0200473
Sughosh Ganufa0ddab2024-10-15 21:07:06 +0530474 flags = LMB_NOOVERWRITE | LMB_NONOTIFY;
Alexander Graf8623f922016-03-04 01:10:04 +0100475 switch (type) {
Heinrich Schuchardt3b7b3b62018-01-30 21:08:00 +0100476 case EFI_ALLOCATE_ANY_PAGES:
Alexander Graf8623f922016-03-04 01:10:04 +0100477 /* Any page */
Ilias Apalodimasd1e9a262024-12-18 09:02:36 +0200478 addr = (u64)lmb_alloc_base(len, EFI_PAGE_SIZE,
Ilias Apalodimas7d182fb2024-10-23 18:26:36 +0300479 LMB_ALLOC_ANYWHERE, flags);
Heinrich Schuchardtfbdb93c2019-05-11 08:43:30 +0200480 if (!addr)
481 return EFI_OUT_OF_RESOURCES;
Alexander Graf8623f922016-03-04 01:10:04 +0100482 break;
Heinrich Schuchardt3b7b3b62018-01-30 21:08:00 +0100483 case EFI_ALLOCATE_MAX_ADDRESS:
Alexander Graf8623f922016-03-04 01:10:04 +0100484 /* Max address */
Sughosh Ganufa0ddab2024-10-15 21:07:06 +0530485 addr = map_to_sysmem((void *)(uintptr_t)*memory);
Ilias Apalodimasd1e9a262024-12-18 09:02:36 +0200486 addr = (u64)lmb_alloc_base(len, EFI_PAGE_SIZE, addr,
Sughosh Ganufa0ddab2024-10-15 21:07:06 +0530487 flags);
Heinrich Schuchardtfbdb93c2019-05-11 08:43:30 +0200488 if (!addr)
489 return EFI_OUT_OF_RESOURCES;
Alexander Graf8623f922016-03-04 01:10:04 +0100490 break;
Heinrich Schuchardt3b7b3b62018-01-30 21:08:00 +0100491 case EFI_ALLOCATE_ADDRESS:
Heinrich Schuchardt1c180b82022-11-06 01:52:13 +0100492 if (*memory & EFI_PAGE_MASK)
493 return EFI_NOT_FOUND;
Sughosh Ganufa0ddab2024-10-15 21:07:06 +0530494
495 addr = map_to_sysmem((void *)(uintptr_t)*memory);
Ilias Apalodimas299c87d2025-03-14 12:57:02 +0200496 if (lmb_alloc_addr(addr, len, flags))
Heinrich Schuchardtfbdb93c2019-05-11 08:43:30 +0200497 return EFI_NOT_FOUND;
Alexander Graf8623f922016-03-04 01:10:04 +0100498 break;
499 default:
500 /* UEFI doesn't specify other allocation types */
Heinrich Schuchardtfbdb93c2019-05-11 08:43:30 +0200501 return EFI_INVALID_PARAMETER;
Alexander Graf8623f922016-03-04 01:10:04 +0100502 }
503
Ilias Apalodimasfa5be122024-11-24 11:00:03 +0200504 efi_addr = (u64)(uintptr_t)map_sysmem(addr, 0);
Heinrich Schuchardtfbdb93c2019-05-11 08:43:30 +0200505 /* Reserve that map in our memory maps */
Ilias Apalodimas9e0db622025-03-17 14:03:58 +0530506 ret = efi_update_memory_map(efi_addr, pages, memory_type, true, false);
Ilias Apalodimasfa5be122024-11-24 11:00:03 +0200507 if (ret != EFI_SUCCESS) {
Heinrich Schuchardtfbdb93c2019-05-11 08:43:30 +0200508 /* Map would overlap, bail out */
Ilias Apalodimasfa5be122024-11-24 11:00:03 +0200509 lmb_free_flags(addr, (u64)pages << EFI_PAGE_SHIFT, flags);
510 unmap_sysmem((void *)(uintptr_t)efi_addr);
Heinrich Schuchardtfbdb93c2019-05-11 08:43:30 +0200511 return EFI_OUT_OF_RESOURCES;
Ilias Apalodimasfa5be122024-11-24 11:00:03 +0200512 }
Alexander Graf8623f922016-03-04 01:10:04 +0100513
Ilias Apalodimasfa5be122024-11-24 11:00:03 +0200514 *memory = efi_addr;
Alexander Graf8623f922016-03-04 01:10:04 +0100515
Heinrich Schuchardtfbdb93c2019-05-11 08:43:30 +0200516 return EFI_SUCCESS;
Alexander Graf8623f922016-03-04 01:10:04 +0100517}
518
Heinrich Schuchardtb9b838d2023-01-08 01:00:00 +0100519/**
Heinrich Schuchardtb4e2ba32019-03-26 05:31:41 +0100520 * efi_free_pages() - free memory pages
Heinrich Schuchardt1b32cae2017-12-04 20:52:41 +0100521 *
Heinrich Schuchardtb4e2ba32019-03-26 05:31:41 +0100522 * @memory: start of the memory area to be freed
523 * @pages: number of pages to be freed
524 * Return: status code
Heinrich Schuchardt1b32cae2017-12-04 20:52:41 +0100525 */
Heinrich Schuchardt798a4412017-11-06 21:17:48 +0100526efi_status_t efi_free_pages(uint64_t memory, efi_uintn_t pages)
Alexander Graf8623f922016-03-04 01:10:04 +0100527{
Sughosh Ganufa0ddab2024-10-15 21:07:06 +0530528 u64 len;
Sughosh Ganufa0ddab2024-10-15 21:07:06 +0530529 long status;
Heinrich Schuchardtac7f8422019-05-10 21:21:30 +0200530 efi_status_t ret;
531
Heinrich Schuchardt906f6852019-05-11 08:21:17 +0200532 ret = efi_check_allocated(memory, true);
Heinrich Schuchardtac7f8422019-05-10 21:21:30 +0200533 if (ret != EFI_SUCCESS)
534 return ret;
Stefan Brünsa4f43022016-10-01 23:32:27 +0200535
Heinrich Schuchardtb4e2ba32019-03-26 05:31:41 +0100536 /* Sanity check */
Heinrich Schuchardt7bf4bc92019-04-25 18:41:40 +0200537 if (!memory || (memory & EFI_PAGE_MASK) || !pages) {
Heinrich Schuchardtb4e2ba32019-03-26 05:31:41 +0100538 printf("%s: illegal free 0x%llx, 0x%zx\n", __func__,
539 memory, pages);
540 return EFI_INVALID_PARAMETER;
541 }
542
Sughosh Ganufa0ddab2024-10-15 21:07:06 +0530543 len = (u64)pages << EFI_PAGE_SHIFT;
Ilias Apalodimase9e55c72024-10-24 14:01:55 +0300544 /*
545 * The 'memory' variable for sandbox holds a pointer which has already
546 * been mapped with map_sysmem() from efi_allocate_pages(). Convert
547 * it back to an address LMB understands
548 */
Sughosh Ganufa0ddab2024-10-15 21:07:06 +0530549 status = lmb_free_flags(map_to_sysmem((void *)(uintptr_t)memory), len,
Ilias Apalodimase9e55c72024-10-24 14:01:55 +0300550 LMB_NOOVERWRITE);
Sughosh Ganufa0ddab2024-10-15 21:07:06 +0530551 if (status)
552 return EFI_NOT_FOUND;
553
Ilias Apalodimasfa5be122024-11-24 11:00:03 +0200554 unmap_sysmem((void *)(uintptr_t)memory);
555
Bryan O'Donoghue89a22b42019-07-15 12:00:39 +0100556 return ret;
Alexander Graf8623f922016-03-04 01:10:04 +0100557}
558
Heinrich Schuchardtb4e2ba32019-03-26 05:31:41 +0100559/**
Heinrich Schuchardtb9b838d2023-01-08 01:00:00 +0100560 * efi_alloc_aligned_pages() - allocate aligned memory pages
Ilias Apalodimas6e01c232021-10-11 15:10:23 +0300561 *
562 * @len: len in bytes
563 * @memory_type: usage type of the allocated memory
564 * @align: alignment in bytes
565 * Return: aligned memory or NULL
566 */
567void *efi_alloc_aligned_pages(u64 len, int memory_type, size_t align)
568{
569 u64 req_pages = efi_size_in_pages(len);
570 u64 true_pages = req_pages + efi_size_in_pages(align) - 1;
571 u64 free_pages;
572 u64 aligned_mem;
573 efi_status_t r;
574 u64 mem;
575
576 /* align must be zero or a power of two */
577 if (align & (align - 1))
578 return NULL;
579
580 /* Check for overflow */
581 if (true_pages < req_pages)
582 return NULL;
583
584 if (align < EFI_PAGE_SIZE) {
585 r = efi_allocate_pages(EFI_ALLOCATE_ANY_PAGES, memory_type,
586 req_pages, &mem);
587 return (r == EFI_SUCCESS) ? (void *)(uintptr_t)mem : NULL;
588 }
589
590 r = efi_allocate_pages(EFI_ALLOCATE_ANY_PAGES, memory_type,
591 true_pages, &mem);
592 if (r != EFI_SUCCESS)
593 return NULL;
594
595 aligned_mem = ALIGN(mem, align);
596 /* Free pages before alignment */
597 free_pages = efi_size_in_pages(aligned_mem - mem);
598 if (free_pages)
599 efi_free_pages(mem, free_pages);
600
601 /* Free trailing pages */
602 free_pages = true_pages - (req_pages + free_pages);
603 if (free_pages) {
604 mem = aligned_mem + req_pages * EFI_PAGE_SIZE;
605 efi_free_pages(mem, free_pages);
606 }
607
608 return (void *)(uintptr_t)aligned_mem;
609}
610
611/**
Heinrich Schuchardtb4e2ba32019-03-26 05:31:41 +0100612 * efi_allocate_pool - allocate memory from pool
Heinrich Schuchardt1b32cae2017-12-04 20:52:41 +0100613 *
Heinrich Schuchardtb4e2ba32019-03-26 05:31:41 +0100614 * @pool_type: type of the pool from which memory is to be allocated
615 * @size: number of bytes to be allocated
616 * @buffer: allocated memory
617 * Return: status code
Heinrich Schuchardt1b32cae2017-12-04 20:52:41 +0100618 */
Heinrich Schuchardt98228942021-08-17 15:05:31 +0200619efi_status_t efi_allocate_pool(enum efi_memory_type pool_type, efi_uintn_t size, void **buffer)
Stefan Brüns5a09aef2016-10-09 22:17:18 +0200620{
621 efi_status_t r;
Heinrich Schuchardt657e9792019-03-18 20:01:59 +0100622 u64 addr;
Alexander Grafcd405172018-06-18 17:23:15 +0200623 struct efi_pool_allocation *alloc;
Heinrich Schuchardtdcdca292018-11-18 17:58:49 +0100624 u64 num_pages = efi_size_in_pages(size +
625 sizeof(struct efi_pool_allocation));
Stefan Brüns67b67d92016-10-09 22:17:26 +0200626
Heinrich Schuchardta137c962018-07-02 12:53:53 +0200627 if (!buffer)
628 return EFI_INVALID_PARAMETER;
629
Stefan Brüns67b67d92016-10-09 22:17:26 +0200630 if (size == 0) {
631 *buffer = NULL;
632 return EFI_SUCCESS;
633 }
Stefan Brüns5a09aef2016-10-09 22:17:18 +0200634
Heinrich Schuchardt0f7186b2018-05-26 10:32:27 +0200635 r = efi_allocate_pages(EFI_ALLOCATE_ANY_PAGES, pool_type, num_pages,
Heinrich Schuchardt657e9792019-03-18 20:01:59 +0100636 &addr);
Stefan Brüns67b67d92016-10-09 22:17:26 +0200637 if (r == EFI_SUCCESS) {
Heinrich Schuchardt657e9792019-03-18 20:01:59 +0100638 alloc = (struct efi_pool_allocation *)(uintptr_t)addr;
Stefan Brüns67b67d92016-10-09 22:17:26 +0200639 alloc->num_pages = num_pages;
Heinrich Schuchardtb4e2ba32019-03-26 05:31:41 +0100640 alloc->checksum = checksum(alloc);
Stefan Brüns67b67d92016-10-09 22:17:26 +0200641 *buffer = alloc->data;
642 }
643
644 return r;
645}
646
Heinrich Schuchardtb4e2ba32019-03-26 05:31:41 +0100647/**
Heinrich Schuchardt45640252023-03-19 09:20:22 +0100648 * efi_alloc() - allocate boot services data pool memory
649 *
650 * Allocate memory from pool and zero it out.
651 *
652 * @size: number of bytes to allocate
653 * Return: pointer to allocated memory or NULL
654 */
655void *efi_alloc(size_t size)
656{
657 void *buf;
658
659 if (efi_allocate_pool(EFI_BOOT_SERVICES_DATA, size, &buf) !=
660 EFI_SUCCESS) {
Heinrich Schuchardtf39486a2024-10-17 20:05:07 +0200661 log_err("out of memory\n");
Heinrich Schuchardt45640252023-03-19 09:20:22 +0100662 return NULL;
663 }
664 memset(buf, 0, size);
665
666 return buf;
667}
668
669/**
Heinrich Schuchardtb4e2ba32019-03-26 05:31:41 +0100670 * efi_free_pool() - free memory from pool
Heinrich Schuchardt1b32cae2017-12-04 20:52:41 +0100671 *
Heinrich Schuchardtb4e2ba32019-03-26 05:31:41 +0100672 * @buffer: start of memory to be freed
673 * Return: status code
Heinrich Schuchardt1b32cae2017-12-04 20:52:41 +0100674 */
Stefan Brüns67b67d92016-10-09 22:17:26 +0200675efi_status_t efi_free_pool(void *buffer)
676{
Heinrich Schuchardtac7f8422019-05-10 21:21:30 +0200677 efi_status_t ret;
Stefan Brüns67b67d92016-10-09 22:17:26 +0200678 struct efi_pool_allocation *alloc;
679
Heinrich Schuchardt56b587f72019-06-12 07:17:04 +0200680 if (!buffer)
681 return EFI_INVALID_PARAMETER;
682
Heinrich Schuchardt906f6852019-05-11 08:21:17 +0200683 ret = efi_check_allocated((uintptr_t)buffer, true);
Heinrich Schuchardtac7f8422019-05-10 21:21:30 +0200684 if (ret != EFI_SUCCESS)
685 return ret;
xypron.glpk@gmx.de34ddae72017-07-14 19:12:39 +0200686
Stefan Brüns67b67d92016-10-09 22:17:26 +0200687 alloc = container_of(buffer, struct efi_pool_allocation, data);
Heinrich Schuchardtb4e2ba32019-03-26 05:31:41 +0100688
689 /* Check that this memory was allocated by efi_allocate_pool() */
690 if (((uintptr_t)alloc & EFI_PAGE_MASK) ||
691 alloc->checksum != checksum(alloc)) {
692 printf("%s: illegal free 0x%p\n", __func__, buffer);
693 return EFI_INVALID_PARAMETER;
694 }
695 /* Avoid double free */
696 alloc->checksum = 0;
Stefan Brüns67b67d92016-10-09 22:17:26 +0200697
Heinrich Schuchardtac7f8422019-05-10 21:21:30 +0200698 ret = efi_free_pages((uintptr_t)alloc, alloc->num_pages);
Stefan Brüns5a09aef2016-10-09 22:17:18 +0200699
Heinrich Schuchardtac7f8422019-05-10 21:21:30 +0200700 return ret;
Stefan Brüns5a09aef2016-10-09 22:17:18 +0200701}
702
Heinrich Schuchardtb9b838d2023-01-08 01:00:00 +0100703/**
704 * efi_get_memory_map() - get map describing memory usage.
Heinrich Schuchardt1b32cae2017-12-04 20:52:41 +0100705 *
Heinrich Schuchardtb9b838d2023-01-08 01:00:00 +0100706 * @memory_map_size: on entry the size, in bytes, of the memory map buffer,
Heinrich Schuchardt1b32cae2017-12-04 20:52:41 +0100707 * on exit the size of the copied memory map
Heinrich Schuchardtb9b838d2023-01-08 01:00:00 +0100708 * @memory_map: buffer to which the memory map is written
709 * @map_key: key for the memory map
710 * @descriptor_size: size of an individual memory descriptor
711 * @descriptor_version: version number of the memory descriptor structure
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100712 * Return: status code
Heinrich Schuchardt1b32cae2017-12-04 20:52:41 +0100713 */
Heinrich Schuchardt798a4412017-11-06 21:17:48 +0100714efi_status_t efi_get_memory_map(efi_uintn_t *memory_map_size,
715 struct efi_mem_desc *memory_map,
716 efi_uintn_t *map_key,
717 efi_uintn_t *descriptor_size,
718 uint32_t *descriptor_version)
Alexander Graf8623f922016-03-04 01:10:04 +0100719{
Sughosh Ganu38dcdb82024-07-30 16:41:29 +0530720 size_t map_entries;
Heinrich Schuchardt798a4412017-11-06 21:17:48 +0100721 efi_uintn_t map_size = 0;
Sughosh Ganu21ad4cc2024-07-30 16:41:31 +0530722 struct efi_mem_list *lmem;
Heinrich Schuchardt9b166462018-08-06 22:28:18 +0200723 efi_uintn_t provided_map_size;
Alexander Graf8623f922016-03-04 01:10:04 +0100724
Heinrich Schuchardte1a1a092018-07-02 12:53:54 +0200725 if (!memory_map_size)
726 return EFI_INVALID_PARAMETER;
727
Heinrich Schuchardt9b166462018-08-06 22:28:18 +0200728 provided_map_size = *memory_map_size;
729
Sughosh Ganu38dcdb82024-07-30 16:41:29 +0530730 map_entries = list_count_nodes(&efi_mem);
Alexander Graf9b591022016-04-11 23:51:02 +0200731
732 map_size = map_entries * sizeof(struct efi_mem_desc);
Alexander Graf8623f922016-03-04 01:10:04 +0100733
Rob Clarka84c9742017-07-26 14:34:05 -0400734 *memory_map_size = map_size;
735
Alexander Graf8623f922016-03-04 01:10:04 +0100736 if (descriptor_size)
737 *descriptor_size = sizeof(struct efi_mem_desc);
738
Mian Yousaf Kaukab338cf562016-09-05 23:59:22 +0200739 if (descriptor_version)
740 *descriptor_version = EFI_MEMORY_DESCRIPTOR_VERSION;
741
AKASHI Takahiro3ee138d2020-03-11 15:18:18 +0900742 if (provided_map_size < map_size)
743 return EFI_BUFFER_TOO_SMALL;
744
745 if (!memory_map)
746 return EFI_INVALID_PARAMETER;
747
Alexander Graf8623f922016-03-04 01:10:04 +0100748 /* Copy list into array */
Heinrich Schuchardte1a1a092018-07-02 12:53:54 +0200749 /* Return the list in ascending order */
750 memory_map = &memory_map[map_entries - 1];
Sughosh Ganu21ad4cc2024-07-30 16:41:31 +0530751 list_for_each_entry(lmem, &efi_mem, link) {
Heinrich Schuchardte1a1a092018-07-02 12:53:54 +0200752 *memory_map = lmem->desc;
753 memory_map--;
Alexander Graf8623f922016-03-04 01:10:04 +0100754 }
755
Heinrich Schuchardte1a1a092018-07-02 12:53:54 +0200756 if (map_key)
Heinrich Schuchardt0f233c42018-07-02 12:53:55 +0200757 *map_key = efi_memory_map_key;
xypron.glpk@gmx.dee436e632017-07-21 19:05:44 +0200758
Alexander Graf8623f922016-03-04 01:10:04 +0100759 return EFI_SUCCESS;
760}
761
Park, Aidene009e7a2019-09-03 17:43:43 +0000762/**
Heinrich Schuchardt13ce2d92023-01-05 18:26:01 +0100763 * efi_get_memory_map_alloc() - allocate map describing memory usage
764 *
765 * The caller is responsible for calling FreePool() if the call succeeds.
766 *
Heinrich Schuchardtb9b838d2023-01-08 01:00:00 +0100767 * @map_size: size of the memory map
768 * @memory_map: buffer to which the memory map is written
Heinrich Schuchardt13ce2d92023-01-05 18:26:01 +0100769 * Return: status code
770 */
771efi_status_t efi_get_memory_map_alloc(efi_uintn_t *map_size,
772 struct efi_mem_desc **memory_map)
773{
774 efi_status_t ret;
775
776 *memory_map = NULL;
777 *map_size = 0;
778 ret = efi_get_memory_map(map_size, *memory_map, NULL, NULL, NULL);
779 if (ret == EFI_BUFFER_TOO_SMALL) {
780 *map_size += sizeof(struct efi_mem_desc); /* for the map */
781 ret = efi_allocate_pool(EFI_BOOT_SERVICES_DATA, *map_size,
782 (void **)memory_map);
783 if (ret != EFI_SUCCESS)
784 return ret;
785 ret = efi_get_memory_map(map_size, *memory_map,
786 NULL, NULL, NULL);
787 if (ret != EFI_SUCCESS) {
788 efi_free_pool(*memory_map);
789 *memory_map = NULL;
790 }
791 }
792
793 return ret;
794}
795
796/**
Sughosh Ganufbb00c22024-10-15 21:07:14 +0530797 * efi_add_known_memory() - add memory types to the EFI memory map
Park, Aidene009e7a2019-09-03 17:43:43 +0000798 *
Sughosh Ganufbb00c22024-10-15 21:07:14 +0530799 * This function is to be used to add different memory types other
800 * than EFI_CONVENTIONAL_MEMORY to the EFI memory map. The conventional
801 * memory is handled by the LMB module and gets added to the memory
802 * map through the LMB module.
Heinrich Schuchardtb9b838d2023-01-08 01:00:00 +0100803 *
Sughosh Ganufbb00c22024-10-15 21:07:14 +0530804 * This function may be overridden for architectures specific purposes.
Heinrich Schuchardtb9b838d2023-01-08 01:00:00 +0100805 */
York Suna8e9f0a2017-03-06 09:02:27 -0800806__weak void efi_add_known_memory(void)
Alexander Graf8623f922016-03-04 01:10:04 +0100807{
York Suna8e9f0a2017-03-06 09:02:27 -0800808}
809
Heinrich Schuchardtb9b838d2023-01-08 01:00:00 +0100810/**
811 * add_u_boot_and_runtime() - add U-Boot code to memory map
812 *
813 * Add memory regions for U-Boot's memory and for the runtime services code.
814 */
Simon Glass78639432018-06-18 17:23:12 +0200815static void add_u_boot_and_runtime(void)
York Suna8e9f0a2017-03-06 09:02:27 -0800816{
817 unsigned long runtime_start, runtime_end, runtime_pages;
Alexander Graf15937a22018-09-17 13:54:33 +0200818 unsigned long runtime_mask = EFI_PAGE_MASK;
Ilias Apalodimas172039e2024-11-29 19:08:13 +0200819 unsigned long uboot_start, uboot_pages;
820 unsigned long uboot_stack_size = CONFIG_STACK_SIZE;
Alexander Graf8623f922016-03-04 01:10:04 +0100821
Ilias Apalodimas172039e2024-11-29 19:08:13 +0200822 /* Add U-Boot */
823 uboot_start = ((uintptr_t)map_sysmem(gd->start_addr_sp, 0) -
824 uboot_stack_size) & ~EFI_PAGE_MASK;
825 uboot_pages = ((uintptr_t)map_sysmem(gd->ram_top - 1, 0) -
826 uboot_start + EFI_PAGE_MASK) >> EFI_PAGE_SHIFT;
Ilias Apalodimas9e0db622025-03-17 14:03:58 +0530827 efi_update_memory_map(uboot_start, uboot_pages, EFI_BOOT_SERVICES_CODE,
828 false, false);
Alexander Graf15937a22018-09-17 13:54:33 +0200829#if defined(__aarch64__)
830 /*
831 * Runtime Services must be 64KiB aligned according to the
832 * "AArch64 Platforms" section in the UEFI spec (2.7+).
833 */
834
835 runtime_mask = SZ_64K - 1;
836#endif
837
838 /*
839 * Add Runtime Services. We mark surrounding boottime code as runtime as
840 * well to fulfill the runtime alignment constraints but avoid padding.
841 */
Ilias Apalodimas2af95532024-04-04 09:35:35 +0300842 runtime_start = (uintptr_t)__efi_runtime_start & ~runtime_mask;
843 runtime_end = (uintptr_t)__efi_runtime_stop;
Alexander Graf15937a22018-09-17 13:54:33 +0200844 runtime_end = (runtime_end + runtime_mask) & ~runtime_mask;
Alexander Graf8623f922016-03-04 01:10:04 +0100845 runtime_pages = (runtime_end - runtime_start) >> EFI_PAGE_SHIFT;
Ilias Apalodimas9e0db622025-03-17 14:03:58 +0530846 efi_update_memory_map(runtime_start, runtime_pages,
847 EFI_RUNTIME_SERVICES_CODE, false, false);
Simon Glass78639432018-06-18 17:23:12 +0200848}
849
850int efi_memory_init(void)
851{
852 efi_add_known_memory();
853
Heinrich Schuchardta69976e2019-11-08 20:42:53 +0100854 add_u_boot_and_runtime();
Alexander Graf8623f922016-03-04 01:10:04 +0100855
Alexander Graf7c00a3c2016-05-11 18:25:48 +0200856#ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER
857 /* Request a 32bit 64MB bounce buffer region */
858 uint64_t efi_bounce_buffer_addr = 0xffffffff;
859
Heinrich Schuchardt296b55c2022-11-29 16:00:41 +0100860 if (efi_allocate_pages(EFI_ALLOCATE_MAX_ADDRESS, EFI_BOOT_SERVICES_DATA,
Alexander Graf7c00a3c2016-05-11 18:25:48 +0200861 (64 * 1024 * 1024) >> EFI_PAGE_SHIFT,
862 &efi_bounce_buffer_addr) != EFI_SUCCESS)
863 return -1;
864
865 efi_bounce_buffer = (void*)(uintptr_t)efi_bounce_buffer_addr;
866#endif
867
Alexander Graf8623f922016-03-04 01:10:04 +0100868 return 0;
869}
Heinrich Schuchardtfabdb732025-02-16 12:12:40 +0100870
871int efi_map_update_notify(phys_addr_t addr, phys_size_t size,
872 enum lmb_map_op op)
873{
874 u64 efi_addr;
875 u64 pages;
876 efi_status_t status;
877
878 efi_addr = (uintptr_t)map_sysmem(addr, 0);
879 pages = efi_size_in_pages(size + (efi_addr & EFI_PAGE_MASK));
880 efi_addr &= ~EFI_PAGE_MASK;
881
Ilias Apalodimas9e0db622025-03-17 14:03:58 +0530882 status = efi_update_memory_map(efi_addr, pages,
Heinrich Schuchardtfabdb732025-02-16 12:12:40 +0100883 op == LMB_MAP_OP_RESERVE ?
884 EFI_BOOT_SERVICES_DATA :
885 EFI_CONVENTIONAL_MEMORY,
Ilias Apalodimas9e0db622025-03-17 14:03:58 +0530886 false, false);
Heinrich Schuchardtfabdb732025-02-16 12:12:40 +0100887 if (status != EFI_SUCCESS) {
888 log_err("LMB Map notify failure %lu\n",
889 status & ~EFI_ERROR_MASK);
890 return -1;
891 }
892 unmap_sysmem((void *)(uintptr_t)efi_addr);
893
894 return 0;
895}
896