]>
Commit | Line | Data |
---|---|---|
0ed02bda AB |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* | |
3 | * Copyright (C) 2016 Linaro Ltd; <ard.biesheuvel@linaro.org> | |
4 | */ | |
5 | ||
6 | #include <linux/efi.h> | |
7 | #include <linux/log2.h> | |
8 | #include <asm/efi.h> | |
9 | ||
10 | #include "efistub.h" | |
11 | ||
12 | /* | |
13 | * Return the number of slots covered by this entry, i.e., the number of | |
14 | * addresses it covers that are suitably aligned and supply enough room | |
15 | * for the allocation. | |
16 | */ | |
17 | static unsigned long get_entry_num_slots(efi_memory_desc_t *md, | |
18 | unsigned long size, | |
19 | unsigned long align_shift) | |
20 | { | |
21 | unsigned long align = 1UL << align_shift; | |
22 | u64 first_slot, last_slot, region_end; | |
23 | ||
24 | if (md->type != EFI_CONVENTIONAL_MEMORY) | |
25 | return 0; | |
26 | ||
27 | if (efi_soft_reserve_enabled() && | |
28 | (md->attribute & EFI_MEMORY_SP)) | |
29 | return 0; | |
30 | ||
31 | region_end = min(md->phys_addr + md->num_pages * EFI_PAGE_SIZE - 1, | |
32 | (u64)ULONG_MAX); | |
33 | ||
34 | first_slot = round_up(md->phys_addr, align); | |
35 | last_slot = round_down(region_end - size + 1, align); | |
36 | ||
37 | if (first_slot > last_slot) | |
38 | return 0; | |
39 | ||
40 | return ((unsigned long)(last_slot - first_slot) >> align_shift) + 1; | |
41 | } | |
42 | ||
43 | /* | |
44 | * The UEFI memory descriptors have a virtual address field that is only used | |
45 | * when installing the virtual mapping using SetVirtualAddressMap(). Since it | |
46 | * is unused here, we can reuse it to keep track of each descriptor's slot | |
47 | * count. | |
48 | */ | |
49 | #define MD_NUM_SLOTS(md) ((md)->virt_addr) | |
50 | ||
51 | efi_status_t efi_random_alloc(unsigned long size, | |
52 | unsigned long align, | |
53 | unsigned long *addr, | |
54 | unsigned long random_seed) | |
55 | { | |
56 | unsigned long map_size, desc_size, total_slots = 0, target_slot; | |
57 | unsigned long buff_size; | |
58 | efi_status_t status; | |
59 | efi_memory_desc_t *memory_map; | |
60 | int map_offset; | |
61 | struct efi_boot_memmap map; | |
62 | ||
63 | map.map = &memory_map; | |
64 | map.map_size = &map_size; | |
65 | map.desc_size = &desc_size; | |
66 | map.desc_ver = NULL; | |
67 | map.key_ptr = NULL; | |
68 | map.buff_size = &buff_size; | |
69 | ||
70 | status = efi_get_memory_map(&map); | |
71 | if (status != EFI_SUCCESS) | |
72 | return status; | |
73 | ||
74 | if (align < EFI_ALLOC_ALIGN) | |
75 | align = EFI_ALLOC_ALIGN; | |
76 | ||
e1df73e2 AB |
77 | size = round_up(size, EFI_ALLOC_ALIGN); |
78 | ||
0ed02bda AB |
79 | /* count the suitable slots in each memory map entry */ |
80 | for (map_offset = 0; map_offset < map_size; map_offset += desc_size) { | |
81 | efi_memory_desc_t *md = (void *)memory_map + map_offset; | |
82 | unsigned long slots; | |
83 | ||
84 | slots = get_entry_num_slots(md, size, ilog2(align)); | |
85 | MD_NUM_SLOTS(md) = slots; | |
86 | total_slots += slots; | |
87 | } | |
88 | ||
89 | /* find a random number between 0 and total_slots */ | |
c37c9162 | 90 | target_slot = (total_slots * (u64)(random_seed & U32_MAX)) >> 32; |
0ed02bda AB |
91 | |
92 | /* | |
93 | * target_slot is now a value in the range [0, total_slots), and so | |
94 | * it corresponds with exactly one of the suitable slots we recorded | |
95 | * when iterating over the memory map the first time around. | |
96 | * | |
97 | * So iterate over the memory map again, subtracting the number of | |
98 | * slots of each entry at each iteration, until we have found the entry | |
99 | * that covers our chosen slot. Use the residual value of target_slot | |
100 | * to calculate the randomly chosen address, and allocate it directly | |
101 | * using EFI_ALLOCATE_ADDRESS. | |
102 | */ | |
103 | for (map_offset = 0; map_offset < map_size; map_offset += desc_size) { | |
104 | efi_memory_desc_t *md = (void *)memory_map + map_offset; | |
105 | efi_physical_addr_t target; | |
106 | unsigned long pages; | |
107 | ||
108 | if (target_slot >= MD_NUM_SLOTS(md)) { | |
109 | target_slot -= MD_NUM_SLOTS(md); | |
110 | continue; | |
111 | } | |
112 | ||
113 | target = round_up(md->phys_addr, align) + target_slot * align; | |
e1df73e2 | 114 | pages = size / EFI_PAGE_SIZE; |
0ed02bda AB |
115 | |
116 | status = efi_bs_call(allocate_pages, EFI_ALLOCATE_ADDRESS, | |
117 | EFI_LOADER_DATA, pages, &target); | |
118 | if (status == EFI_SUCCESS) | |
119 | *addr = target; | |
120 | break; | |
121 | } | |
122 | ||
123 | efi_bs_call(free_pool, memory_map); | |
124 | ||
125 | return status; | |
126 | } |