1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * EFI application memory management
4 *
5 * Copyright (c) 2016 Alexander Graf
6 */
7
8 #define LOG_CATEGORY LOGC_EFI
9
10 #include <common.h>
11 #include <efi_loader.h>
12 #include <init.h>
13 #include <log.h>
14 #include <malloc.h>
15 #include <mapmem.h>
16 #include <watchdog.h>
17 #include <asm/cache.h>
18 #include <asm/global_data.h>
19 #include <linux/list_sort.h>
20 #include <linux/sizes.h>
21
22 DECLARE_GLOBAL_DATA_PTR;
23
24 /* Magic number identifying memory allocated from pool */
25 #define EFI_ALLOC_POOL_MAGIC 0x1fe67ddf6491caa2
26
27 efi_uintn_t efi_memory_map_key;
28
29 struct efi_mem_list {
30 struct list_head link;
31 struct efi_mem_desc desc;
32 };
33
34 #define EFI_CARVE_NO_OVERLAP -1
35 #define EFI_CARVE_LOOP_AGAIN -2
36 #define EFI_CARVE_OVERLAPS_NONRAM -3
37
38 /* This list contains all memory map items */
39 static LIST_HEAD(efi_mem);
40
41 #ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER
42 void *efi_bounce_buffer;
43 #endif
44
45 /**
46 * struct efi_pool_allocation - memory block allocated from pool
47 *
48 * @num_pages: number of pages allocated
49 * @checksum: checksum
50 * @data: allocated pool memory
51 *
52 * U-Boot services each UEFI AllocatePool() request as a separate
53 * (multiple) page allocation. We have to track the number of pages
54 * to be able to free the correct amount later.
55 *
56 * The checksum calculated in function checksum() is used in FreePool() to avoid
57 * freeing memory not allocated by AllocatePool() and duplicate freeing.
58 *
59 * EFI requires 8 byte alignment for pool allocations, so we can
60 * prepend each allocation with these header fields.
61 */
62 struct efi_pool_allocation {
63 u64 num_pages;
64 u64 checksum;
65 char data[] __aligned(ARCH_DMA_MINALIGN);
66 };
67
68 /**
69 * checksum() - calculate checksum for memory allocated from pool
70 *
71 * @alloc: allocation header
72 * Return: checksum, always non-zero
73 */
checksum(struct efi_pool_allocation * alloc)74 static u64 checksum(struct efi_pool_allocation *alloc)
75 {
76 u64 addr = (uintptr_t)alloc;
77 u64 ret = (addr >> 32) ^ (addr << 32) ^ alloc->num_pages ^
78 EFI_ALLOC_POOL_MAGIC;
79 if (!ret)
80 ++ret;
81 return ret;
82 }
83
84 /**
85 * efi_mem_cmp() - comparator function for sorting memory map
86 *
87 * Sorts the memory list from highest address to lowest address
88 *
89 * When allocating memory we should always start from the highest
90 * address chunk, so sort the memory list such that the first list
91 * iterator gets the highest address and goes lower from there.
92 *
93 * @priv: unused
94 * @a: first memory area
95 * @b: second memory area
96 * Return: 1 if @a is before @b, -1 if @b is before @a, 0 if equal
97 */
efi_mem_cmp(void * priv,struct list_head * a,struct list_head * b)98 static int efi_mem_cmp(void *priv, struct list_head *a, struct list_head *b)
99 {
100 struct efi_mem_list *mema = list_entry(a, struct efi_mem_list, link);
101 struct efi_mem_list *memb = list_entry(b, struct efi_mem_list, link);
102
103 if (mema->desc.physical_start == memb->desc.physical_start)
104 return 0;
105 else if (mema->desc.physical_start < memb->desc.physical_start)
106 return 1;
107 else
108 return -1;
109 }
110
111 /**
112 * desc_get_end() - get end address of memory area
113 *
114 * @desc: memory descriptor
115 * Return: end address + 1
116 */
desc_get_end(struct efi_mem_desc * desc)117 static uint64_t desc_get_end(struct efi_mem_desc *desc)
118 {
119 return desc->physical_start + (desc->num_pages << EFI_PAGE_SHIFT);
120 }
121
122 /**
123 * efi_mem_sort() - sort memory map
124 *
125 * Sort the memory map and then try to merge adjacent memory areas.
126 */
efi_mem_sort(void)127 static void efi_mem_sort(void)
128 {
129 struct list_head *lhandle;
130 struct efi_mem_list *prevmem = NULL;
131 bool merge_again = true;
132
133 list_sort(NULL, &efi_mem, efi_mem_cmp);
134
135 /* Now merge entries that can be merged */
136 while (merge_again) {
137 merge_again = false;
138 list_for_each(lhandle, &efi_mem) {
139 struct efi_mem_list *lmem;
140 struct efi_mem_desc *prev = &prevmem->desc;
141 struct efi_mem_desc *cur;
142 uint64_t pages;
143
144 lmem = list_entry(lhandle, struct efi_mem_list, link);
145 if (!prevmem) {
146 prevmem = lmem;
147 continue;
148 }
149
150 cur = &lmem->desc;
151
152 if ((desc_get_end(cur) == prev->physical_start) &&
153 (prev->type == cur->type) &&
154 (prev->attribute == cur->attribute)) {
155 /* There is an existing map before, reuse it */
156 pages = cur->num_pages;
157 prev->num_pages += pages;
158 prev->physical_start -= pages << EFI_PAGE_SHIFT;
159 prev->virtual_start -= pages << EFI_PAGE_SHIFT;
160 list_del(&lmem->link);
161 free(lmem);
162
163 merge_again = true;
164 break;
165 }
166
167 prevmem = lmem;
168 }
169 }
170 }
171
172 /**
173 * efi_mem_carve_out() - unmap memory region
174 *
175 * @map: memory map
176 * @carve_desc: memory region to unmap
177 * @overlap_only_ram: the carved out region may only overlap RAM
178 * Return: the number of overlapping pages which have been
179 * removed from the map,
180 * EFI_CARVE_NO_OVERLAP, if the regions don't overlap,
181 * EFI_CARVE_OVERLAPS_NONRAM, if the carve and map overlap,
182 * and the map contains anything but free ram
183 * (only when overlap_only_ram is true),
184 * EFI_CARVE_LOOP_AGAIN, if the mapping list should be
185 * traversed again, as it has been altered.
186 *
187 * Unmaps all memory occupied by the carve_desc region from the list entry
188 * pointed to by map.
189 *
190 * In case of EFI_CARVE_OVERLAPS_NONRAM it is the callers responsibility
191 * to re-add the already carved out pages to the mapping.
192 */
efi_mem_carve_out(struct efi_mem_list * map,struct efi_mem_desc * carve_desc,bool overlap_only_ram)193 static s64 efi_mem_carve_out(struct efi_mem_list *map,
194 struct efi_mem_desc *carve_desc,
195 bool overlap_only_ram)
196 {
197 struct efi_mem_list *newmap;
198 struct efi_mem_desc *map_desc = &map->desc;
199 uint64_t map_start = map_desc->physical_start;
200 uint64_t map_end = map_start + (map_desc->num_pages << EFI_PAGE_SHIFT);
201 uint64_t carve_start = carve_desc->physical_start;
202 uint64_t carve_end = carve_start +
203 (carve_desc->num_pages << EFI_PAGE_SHIFT);
204
205 /* check whether we're overlapping */
206 if ((carve_end <= map_start) || (carve_start >= map_end))
207 return EFI_CARVE_NO_OVERLAP;
208
209 /* We're overlapping with non-RAM, warn the caller if desired */
210 if (overlap_only_ram && (map_desc->type != EFI_CONVENTIONAL_MEMORY))
211 return EFI_CARVE_OVERLAPS_NONRAM;
212
213 /* Sanitize carve_start and carve_end to lie within our bounds */
214 carve_start = max(carve_start, map_start);
215 carve_end = min(carve_end, map_end);
216
217 /* Carving at the beginning of our map? Just move it! */
218 if (carve_start == map_start) {
219 if (map_end == carve_end) {
220 /* Full overlap, just remove map */
221 list_del(&map->link);
222 free(map);
223 } else {
224 map->desc.physical_start = carve_end;
225 map->desc.virtual_start = carve_end;
226 map->desc.num_pages = (map_end - carve_end)
227 >> EFI_PAGE_SHIFT;
228 }
229
230 return (carve_end - carve_start) >> EFI_PAGE_SHIFT;
231 }
232
233 /*
234 * Overlapping maps, just split the list map at carve_start,
235 * it will get moved or removed in the next iteration.
236 *
237 * [ map_desc |__carve_start__| newmap ]
238 */
239
240 /* Create a new map from [ carve_start ... map_end ] */
241 newmap = calloc(1, sizeof(*newmap));
242 newmap->desc = map->desc;
243 newmap->desc.physical_start = carve_start;
244 newmap->desc.virtual_start = carve_start;
245 newmap->desc.num_pages = (map_end - carve_start) >> EFI_PAGE_SHIFT;
246 /* Insert before current entry (descending address order) */
247 list_add_tail(&newmap->link, &map->link);
248
249 /* Shrink the map to [ map_start ... carve_start ] */
250 map_desc->num_pages = (carve_start - map_start) >> EFI_PAGE_SHIFT;
251
252 return EFI_CARVE_LOOP_AGAIN;
253 }
254
255 /**
256 * efi_add_memory_map_pg() - add pages to the memory map
257 *
258 * @start: start address, must be a multiple of EFI_PAGE_SIZE
259 * @pages: number of pages to add
260 * @memory_type: type of memory added
261 * @overlap_only_ram: region may only overlap RAM
262 * Return: status code
263 */
efi_add_memory_map_pg(u64 start,u64 pages,int memory_type,bool overlap_only_ram)264 static efi_status_t efi_add_memory_map_pg(u64 start, u64 pages,
265 int memory_type,
266 bool overlap_only_ram)
267 {
268 struct list_head *lhandle;
269 struct efi_mem_list *newlist;
270 bool carve_again;
271 uint64_t carved_pages = 0;
272 struct efi_event *evt;
273
274 EFI_PRINT("%s: 0x%llx 0x%llx %d %s\n", __func__,
275 start, pages, memory_type, overlap_only_ram ? "yes" : "no");
276
277 if (memory_type >= EFI_MAX_MEMORY_TYPE)
278 return EFI_INVALID_PARAMETER;
279
280 if (!pages)
281 return EFI_SUCCESS;
282
283 ++efi_memory_map_key;
284 newlist = calloc(1, sizeof(*newlist));
285 newlist->desc.type = memory_type;
286 newlist->desc.physical_start = start;
287 newlist->desc.virtual_start = start;
288 newlist->desc.num_pages = pages;
289
290 switch (memory_type) {
291 case EFI_RUNTIME_SERVICES_CODE:
292 case EFI_RUNTIME_SERVICES_DATA:
293 newlist->desc.attribute = EFI_MEMORY_WB | EFI_MEMORY_RUNTIME;
294 break;
295 case EFI_MMAP_IO:
296 newlist->desc.attribute = EFI_MEMORY_RUNTIME;
297 break;
298 default:
299 newlist->desc.attribute = EFI_MEMORY_WB;
300 break;
301 }
302
303 /* Add our new map */
304 do {
305 carve_again = false;
306 list_for_each(lhandle, &efi_mem) {
307 struct efi_mem_list *lmem;
308 s64 r;
309
310 lmem = list_entry(lhandle, struct efi_mem_list, link);
311 r = efi_mem_carve_out(lmem, &newlist->desc,
312 overlap_only_ram);
313 switch (r) {
314 case EFI_CARVE_OVERLAPS_NONRAM:
315 /*
316 * The user requested to only have RAM overlaps,
317 * but we hit a non-RAM region. Error out.
318 */
319 return EFI_NO_MAPPING;
320 case EFI_CARVE_NO_OVERLAP:
321 /* Just ignore this list entry */
322 break;
323 case EFI_CARVE_LOOP_AGAIN:
324 /*
325 * We split an entry, but need to loop through
326 * the list again to actually carve it.
327 */
328 carve_again = true;
329 break;
330 default:
331 /* We carved a number of pages */
332 carved_pages += r;
333 carve_again = true;
334 break;
335 }
336
337 if (carve_again) {
338 /* The list changed, we need to start over */
339 break;
340 }
341 }
342 } while (carve_again);
343
344 if (overlap_only_ram && (carved_pages != pages)) {
345 /*
346 * The payload wanted to have RAM overlaps, but we overlapped
347 * with an unallocated region. Error out.
348 */
349 return EFI_NO_MAPPING;
350 }
351
352 /* Add our new map */
353 list_add_tail(&newlist->link, &efi_mem);
354
355 /* And make sure memory is listed in descending order */
356 efi_mem_sort();
357
358 /* Notify that the memory map was changed */
359 list_for_each_entry(evt, &efi_events, link) {
360 if (evt->group &&
361 !guidcmp(evt->group,
362 &efi_guid_event_group_memory_map_change)) {
363 efi_signal_event(evt);
364 break;
365 }
366 }
367
368 return EFI_SUCCESS;
369 }
370
371 /**
372 * efi_add_memory_map() - add memory area to the memory map
373 *
374 * @start: start address of the memory area
375 * @size: length in bytes of the memory area
376 * @memory_type: type of memory added
377 *
378 * Return: status code
379 *
380 * This function automatically aligns the start and size of the memory area
381 * to EFI_PAGE_SIZE.
382 */
efi_add_memory_map(u64 start,u64 size,int memory_type)383 efi_status_t efi_add_memory_map(u64 start, u64 size, int memory_type)
384 {
385 u64 pages;
386
387 pages = efi_size_in_pages(size + (start & EFI_PAGE_MASK));
388 start &= ~EFI_PAGE_MASK;
389
390 return efi_add_memory_map_pg(start, pages, memory_type, false);
391 }
392
393 /**
394 * efi_check_allocated() - validate address to be freed
395 *
396 * Check that the address is within allocated memory:
397 *
398 * * The address must be in a range of the memory map.
399 * * The address may not point to EFI_CONVENTIONAL_MEMORY.
400 *
401 * Page alignment is not checked as this is not a requirement of
402 * efi_free_pool().
403 *
404 * @addr: address of page to be freed
405 * @must_be_allocated: return success if the page is allocated
406 * Return: status code
407 */
efi_check_allocated(u64 addr,bool must_be_allocated)408 static efi_status_t efi_check_allocated(u64 addr, bool must_be_allocated)
409 {
410 struct efi_mem_list *item;
411
412 list_for_each_entry(item, &efi_mem, link) {
413 u64 start = item->desc.physical_start;
414 u64 end = start + (item->desc.num_pages << EFI_PAGE_SHIFT);
415
416 if (addr >= start && addr < end) {
417 if (must_be_allocated ^
418 (item->desc.type == EFI_CONVENTIONAL_MEMORY))
419 return EFI_SUCCESS;
420 else
421 return EFI_NOT_FOUND;
422 }
423 }
424
425 return EFI_NOT_FOUND;
426 }
427
428 /**
429 * efi_find_free_memory() - find free memory pages
430 *
431 * @len: size of memory area needed
432 * @max_addr: highest address to allocate
433 * Return: pointer to free memory area or 0
434 */
efi_find_free_memory(uint64_t len,uint64_t max_addr)435 static uint64_t efi_find_free_memory(uint64_t len, uint64_t max_addr)
436 {
437 struct list_head *lhandle;
438
439 /*
440 * Prealign input max address, so we simplify our matching
441 * logic below and can just reuse it as return pointer.
442 */
443 max_addr &= ~EFI_PAGE_MASK;
444
445 list_for_each(lhandle, &efi_mem) {
446 struct efi_mem_list *lmem = list_entry(lhandle,
447 struct efi_mem_list, link);
448 struct efi_mem_desc *desc = &lmem->desc;
449 uint64_t desc_len = desc->num_pages << EFI_PAGE_SHIFT;
450 uint64_t desc_end = desc->physical_start + desc_len;
451 uint64_t curmax = min(max_addr, desc_end);
452 uint64_t ret = curmax - len;
453
454 /* We only take memory from free RAM */
455 if (desc->type != EFI_CONVENTIONAL_MEMORY)
456 continue;
457
458 /* Out of bounds for max_addr */
459 if ((ret + len) > max_addr)
460 continue;
461
462 /* Out of bounds for upper map limit */
463 if ((ret + len) > desc_end)
464 continue;
465
466 /* Out of bounds for lower map limit */
467 if (ret < desc->physical_start)
468 continue;
469
470 /* Return the highest address in this map within bounds */
471 return ret;
472 }
473
474 return 0;
475 }
476
477 /**
478 * efi_allocate_pages - allocate memory pages
479 *
480 * @type: type of allocation to be performed
481 * @memory_type: usage type of the allocated memory
482 * @pages: number of pages to be allocated
483 * @memory: allocated memory
484 * Return: status code
485 */
efi_allocate_pages(enum efi_allocate_type type,enum efi_memory_type memory_type,efi_uintn_t pages,uint64_t * memory)486 efi_status_t efi_allocate_pages(enum efi_allocate_type type,
487 enum efi_memory_type memory_type,
488 efi_uintn_t pages, uint64_t *memory)
489 {
490 u64 len = pages << EFI_PAGE_SHIFT;
491 efi_status_t ret;
492 uint64_t addr;
493
494 /* Check import parameters */
495 if (memory_type >= EFI_PERSISTENT_MEMORY_TYPE &&
496 memory_type <= 0x6FFFFFFF)
497 return EFI_INVALID_PARAMETER;
498 if (!memory)
499 return EFI_INVALID_PARAMETER;
500
501 switch (type) {
502 case EFI_ALLOCATE_ANY_PAGES:
503 /* Any page */
504 addr = efi_find_free_memory(len, -1ULL);
505 if (!addr)
506 return EFI_OUT_OF_RESOURCES;
507 break;
508 case EFI_ALLOCATE_MAX_ADDRESS:
509 /* Max address */
510 addr = efi_find_free_memory(len, *memory);
511 if (!addr)
512 return EFI_OUT_OF_RESOURCES;
513 break;
514 case EFI_ALLOCATE_ADDRESS:
515 if (*memory & EFI_PAGE_MASK)
516 return EFI_NOT_FOUND;
517 /* Exact address, reserve it. The addr is already in *memory. */
518 ret = efi_check_allocated(*memory, false);
519 if (ret != EFI_SUCCESS)
520 return EFI_NOT_FOUND;
521 addr = *memory;
522 break;
523 default:
524 /* UEFI doesn't specify other allocation types */
525 return EFI_INVALID_PARAMETER;
526 }
527
528 /* Reserve that map in our memory maps */
529 ret = efi_add_memory_map_pg(addr, pages, memory_type, true);
530 if (ret != EFI_SUCCESS)
531 /* Map would overlap, bail out */
532 return EFI_OUT_OF_RESOURCES;
533
534 *memory = addr;
535
536 return EFI_SUCCESS;
537 }
538
539 /**
540 * efi_free_pages() - free memory pages
541 *
542 * @memory: start of the memory area to be freed
543 * @pages: number of pages to be freed
544 * Return: status code
545 */
efi_free_pages(uint64_t memory,efi_uintn_t pages)546 efi_status_t efi_free_pages(uint64_t memory, efi_uintn_t pages)
547 {
548 efi_status_t ret;
549
550 ret = efi_check_allocated(memory, true);
551 if (ret != EFI_SUCCESS)
552 return ret;
553
554 /* Sanity check */
555 if (!memory || (memory & EFI_PAGE_MASK) || !pages) {
556 printf("%s: illegal free 0x%llx, 0x%zx\n", __func__,
557 memory, pages);
558 return EFI_INVALID_PARAMETER;
559 }
560
561 ret = efi_add_memory_map_pg(memory, pages, EFI_CONVENTIONAL_MEMORY,
562 false);
563 if (ret != EFI_SUCCESS)
564 return EFI_NOT_FOUND;
565
566 return ret;
567 }
568
569 /**
570 * efi_alloc_aligned_pages() - allocate aligned memory pages
571 *
572 * @len: len in bytes
573 * @memory_type: usage type of the allocated memory
574 * @align: alignment in bytes
575 * Return: aligned memory or NULL
576 */
efi_alloc_aligned_pages(u64 len,int memory_type,size_t align)577 void *efi_alloc_aligned_pages(u64 len, int memory_type, size_t align)
578 {
579 u64 req_pages = efi_size_in_pages(len);
580 u64 true_pages = req_pages + efi_size_in_pages(align) - 1;
581 u64 free_pages;
582 u64 aligned_mem;
583 efi_status_t r;
584 u64 mem;
585
586 /* align must be zero or a power of two */
587 if (align & (align - 1))
588 return NULL;
589
590 /* Check for overflow */
591 if (true_pages < req_pages)
592 return NULL;
593
594 if (align < EFI_PAGE_SIZE) {
595 r = efi_allocate_pages(EFI_ALLOCATE_ANY_PAGES, memory_type,
596 req_pages, &mem);
597 return (r == EFI_SUCCESS) ? (void *)(uintptr_t)mem : NULL;
598 }
599
600 r = efi_allocate_pages(EFI_ALLOCATE_ANY_PAGES, memory_type,
601 true_pages, &mem);
602 if (r != EFI_SUCCESS)
603 return NULL;
604
605 aligned_mem = ALIGN(mem, align);
606 /* Free pages before alignment */
607 free_pages = efi_size_in_pages(aligned_mem - mem);
608 if (free_pages)
609 efi_free_pages(mem, free_pages);
610
611 /* Free trailing pages */
612 free_pages = true_pages - (req_pages + free_pages);
613 if (free_pages) {
614 mem = aligned_mem + req_pages * EFI_PAGE_SIZE;
615 efi_free_pages(mem, free_pages);
616 }
617
618 return (void *)(uintptr_t)aligned_mem;
619 }
620
621 /**
622 * efi_allocate_pool - allocate memory from pool
623 *
624 * @pool_type: type of the pool from which memory is to be allocated
625 * @size: number of bytes to be allocated
626 * @buffer: allocated memory
627 * Return: status code
628 */
efi_allocate_pool(enum efi_memory_type pool_type,efi_uintn_t size,void ** buffer)629 efi_status_t efi_allocate_pool(enum efi_memory_type pool_type, efi_uintn_t size, void **buffer)
630 {
631 efi_status_t r;
632 u64 addr;
633 struct efi_pool_allocation *alloc;
634 u64 num_pages = efi_size_in_pages(size +
635 sizeof(struct efi_pool_allocation));
636
637 if (!buffer)
638 return EFI_INVALID_PARAMETER;
639
640 if (size == 0) {
641 *buffer = NULL;
642 return EFI_SUCCESS;
643 }
644
645 r = efi_allocate_pages(EFI_ALLOCATE_ANY_PAGES, pool_type, num_pages,
646 &addr);
647 if (r == EFI_SUCCESS) {
648 alloc = (struct efi_pool_allocation *)(uintptr_t)addr;
649 alloc->num_pages = num_pages;
650 alloc->checksum = checksum(alloc);
651 *buffer = alloc->data;
652 }
653
654 return r;
655 }
656
657 /**
658 * efi_alloc() - allocate boot services data pool memory
659 *
660 * Allocate memory from pool and zero it out.
661 *
662 * @size: number of bytes to allocate
663 * Return: pointer to allocated memory or NULL
664 */
efi_alloc(size_t size)665 void *efi_alloc(size_t size)
666 {
667 void *buf;
668
669 if (efi_allocate_pool(EFI_BOOT_SERVICES_DATA, size, &buf) !=
670 EFI_SUCCESS) {
671 log_err("out of memory");
672 return NULL;
673 }
674 memset(buf, 0, size);
675
676 return buf;
677 }
678
679 /**
680 * efi_free_pool() - free memory from pool
681 *
682 * @buffer: start of memory to be freed
683 * Return: status code
684 */
efi_free_pool(void * buffer)685 efi_status_t efi_free_pool(void *buffer)
686 {
687 efi_status_t ret;
688 struct efi_pool_allocation *alloc;
689
690 if (!buffer)
691 return EFI_INVALID_PARAMETER;
692
693 ret = efi_check_allocated((uintptr_t)buffer, true);
694 if (ret != EFI_SUCCESS)
695 return ret;
696
697 alloc = container_of(buffer, struct efi_pool_allocation, data);
698
699 /* Check that this memory was allocated by efi_allocate_pool() */
700 if (((uintptr_t)alloc & EFI_PAGE_MASK) ||
701 alloc->checksum != checksum(alloc)) {
702 printf("%s: illegal free 0x%p\n", __func__, buffer);
703 return EFI_INVALID_PARAMETER;
704 }
705 /* Avoid double free */
706 alloc->checksum = 0;
707
708 ret = efi_free_pages((uintptr_t)alloc, alloc->num_pages);
709
710 return ret;
711 }
712
713 /**
714 * efi_get_memory_map() - get map describing memory usage.
715 *
716 * @memory_map_size: on entry the size, in bytes, of the memory map buffer,
717 * on exit the size of the copied memory map
718 * @memory_map: buffer to which the memory map is written
719 * @map_key: key for the memory map
720 * @descriptor_size: size of an individual memory descriptor
721 * @descriptor_version: version number of the memory descriptor structure
722 * Return: status code
723 */
efi_get_memory_map(efi_uintn_t * memory_map_size,struct efi_mem_desc * memory_map,efi_uintn_t * map_key,efi_uintn_t * descriptor_size,uint32_t * descriptor_version)724 efi_status_t efi_get_memory_map(efi_uintn_t *memory_map_size,
725 struct efi_mem_desc *memory_map,
726 efi_uintn_t *map_key,
727 efi_uintn_t *descriptor_size,
728 uint32_t *descriptor_version)
729 {
730 efi_uintn_t map_size = 0;
731 int map_entries = 0;
732 struct list_head *lhandle;
733 efi_uintn_t provided_map_size;
734
735 if (!memory_map_size)
736 return EFI_INVALID_PARAMETER;
737
738 provided_map_size = *memory_map_size;
739
740 list_for_each(lhandle, &efi_mem)
741 map_entries++;
742
743 map_size = map_entries * sizeof(struct efi_mem_desc);
744
745 *memory_map_size = map_size;
746
747 if (descriptor_size)
748 *descriptor_size = sizeof(struct efi_mem_desc);
749
750 if (descriptor_version)
751 *descriptor_version = EFI_MEMORY_DESCRIPTOR_VERSION;
752
753 if (provided_map_size < map_size)
754 return EFI_BUFFER_TOO_SMALL;
755
756 if (!memory_map)
757 return EFI_INVALID_PARAMETER;
758
759 /* Copy list into array */
760 /* Return the list in ascending order */
761 memory_map = &memory_map[map_entries - 1];
762 list_for_each(lhandle, &efi_mem) {
763 struct efi_mem_list *lmem;
764
765 lmem = list_entry(lhandle, struct efi_mem_list, link);
766 *memory_map = lmem->desc;
767 memory_map--;
768 }
769
770 if (map_key)
771 *map_key = efi_memory_map_key;
772
773 return EFI_SUCCESS;
774 }
775
776 /**
777 * efi_get_memory_map_alloc() - allocate map describing memory usage
778 *
779 * The caller is responsible for calling FreePool() if the call succeeds.
780 *
781 * @map_size: size of the memory map
782 * @memory_map: buffer to which the memory map is written
783 * Return: status code
784 */
efi_get_memory_map_alloc(efi_uintn_t * map_size,struct efi_mem_desc ** memory_map)785 efi_status_t efi_get_memory_map_alloc(efi_uintn_t *map_size,
786 struct efi_mem_desc **memory_map)
787 {
788 efi_status_t ret;
789
790 *memory_map = NULL;
791 *map_size = 0;
792 ret = efi_get_memory_map(map_size, *memory_map, NULL, NULL, NULL);
793 if (ret == EFI_BUFFER_TOO_SMALL) {
794 *map_size += sizeof(struct efi_mem_desc); /* for the map */
795 ret = efi_allocate_pool(EFI_BOOT_SERVICES_DATA, *map_size,
796 (void **)memory_map);
797 if (ret != EFI_SUCCESS)
798 return ret;
799 ret = efi_get_memory_map(map_size, *memory_map,
800 NULL, NULL, NULL);
801 if (ret != EFI_SUCCESS) {
802 efi_free_pool(*memory_map);
803 *memory_map = NULL;
804 }
805 }
806
807 return ret;
808 }
809
810 /**
811 * efi_add_conventional_memory_map() - add a RAM memory area to the map
812 *
813 * @ram_start: start address of a RAM memory area
814 * @ram_end: end address of a RAM memory area
815 * @ram_top: max address to be used as conventional memory
816 * Return: status code
817 */
efi_add_conventional_memory_map(u64 ram_start,u64 ram_end,u64 ram_top)818 efi_status_t efi_add_conventional_memory_map(u64 ram_start, u64 ram_end,
819 u64 ram_top)
820 {
821 u64 pages;
822
823 /* Remove partial pages */
824 ram_end &= ~EFI_PAGE_MASK;
825 ram_start = (ram_start + EFI_PAGE_MASK) & ~EFI_PAGE_MASK;
826
827 if (ram_end <= ram_start) {
828 /* Invalid mapping */
829 return EFI_INVALID_PARAMETER;
830 }
831
832 pages = (ram_end - ram_start) >> EFI_PAGE_SHIFT;
833
834 efi_add_memory_map_pg(ram_start, pages,
835 EFI_CONVENTIONAL_MEMORY, false);
836
837 /*
838 * Boards may indicate to the U-Boot memory core that they
839 * can not support memory above ram_top. Let's honor this
840 * in the efi_loader subsystem too by declaring any memory
841 * above ram_top as "already occupied by firmware".
842 */
843 if (ram_top < ram_start) {
844 /* ram_top is before this region, reserve all */
845 efi_add_memory_map_pg(ram_start, pages,
846 EFI_BOOT_SERVICES_DATA, true);
847 } else if (ram_top < ram_end) {
848 /* ram_top is inside this region, reserve parts */
849 pages = (ram_end - ram_top) >> EFI_PAGE_SHIFT;
850
851 efi_add_memory_map_pg(ram_top, pages,
852 EFI_BOOT_SERVICES_DATA, true);
853 }
854
855 return EFI_SUCCESS;
856 }
857
858 /**
859 * efi_add_known_memory() - add memory banks to map
860 *
861 * This function may be overridden for specific architectures.
862 */
efi_add_known_memory(void)863 __weak void efi_add_known_memory(void)
864 {
865 u64 ram_top = board_get_usable_ram_top(0) & ~EFI_PAGE_MASK;
866 int i;
867
868 /*
869 * ram_top is just outside mapped memory. So use an offset of one for
870 * mapping the sandbox address.
871 */
872 ram_top = (uintptr_t)map_sysmem(ram_top - 1, 0) + 1;
873
874 /* Fix for 32bit targets with ram_top at 4G */
875 if (!ram_top)
876 ram_top = 0x100000000ULL;
877
878 /* Add RAM */
879 for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) {
880 u64 ram_end, ram_start;
881
882 ram_start = (uintptr_t)map_sysmem(gd->bd->bi_dram[i].start, 0);
883 ram_end = ram_start + gd->bd->bi_dram[i].size;
884
885 efi_add_conventional_memory_map(ram_start, ram_end, ram_top);
886 }
887 }
888
889 /**
890 * add_u_boot_and_runtime() - add U-Boot code to memory map
891 *
892 * Add memory regions for U-Boot's memory and for the runtime services code.
893 */
add_u_boot_and_runtime(void)894 static void add_u_boot_and_runtime(void)
895 {
896 unsigned long runtime_start, runtime_end, runtime_pages;
897 unsigned long runtime_mask = EFI_PAGE_MASK;
898 unsigned long uboot_start, uboot_pages;
899 unsigned long uboot_stack_size = CONFIG_STACK_SIZE;
900
901 /* Add U-Boot */
902 uboot_start = ((uintptr_t)map_sysmem(gd->start_addr_sp, 0) -
903 uboot_stack_size) & ~EFI_PAGE_MASK;
904 uboot_pages = ((uintptr_t)map_sysmem(gd->ram_top - 1, 0) -
905 uboot_start + EFI_PAGE_MASK) >> EFI_PAGE_SHIFT;
906 efi_add_memory_map_pg(uboot_start, uboot_pages, EFI_BOOT_SERVICES_CODE,
907 false);
908
909 #if defined(__aarch64__)
910 /*
911 * Runtime Services must be 64KiB aligned according to the
912 * "AArch64 Platforms" section in the UEFI spec (2.7+).
913 */
914
915 runtime_mask = SZ_64K - 1;
916 #endif
917
918 /*
919 * Add Runtime Services. We mark surrounding boottime code as runtime as
920 * well to fulfill the runtime alignment constraints but avoid padding.
921 */
922 runtime_start = (ulong)&__efi_runtime_start & ~runtime_mask;
923 runtime_end = (ulong)&__efi_runtime_stop;
924 runtime_end = (runtime_end + runtime_mask) & ~runtime_mask;
925 runtime_pages = (runtime_end - runtime_start) >> EFI_PAGE_SHIFT;
926 efi_add_memory_map_pg(runtime_start, runtime_pages,
927 EFI_RUNTIME_SERVICES_CODE, false);
928 }
929
efi_memory_init(void)930 int efi_memory_init(void)
931 {
932 efi_add_known_memory();
933
934 add_u_boot_and_runtime();
935
936 #ifdef CONFIG_EFI_LOADER_BOUNCE_BUFFER
937 /* Request a 32bit 64MB bounce buffer region */
938 uint64_t efi_bounce_buffer_addr = 0xffffffff;
939
940 if (efi_allocate_pages(EFI_ALLOCATE_MAX_ADDRESS, EFI_BOOT_SERVICES_DATA,
941 (64 * 1024 * 1024) >> EFI_PAGE_SHIFT,
942 &efi_bounce_buffer_addr) != EFI_SUCCESS)
943 return -1;
944
945 efi_bounce_buffer = (void*)(uintptr_t)efi_bounce_buffer_addr;
946 #endif
947
948 return 0;
949 }
950