1
2
3
4
5
6
7
8#include <common.h>
9#include <command.h>
10#include <efi.h>
11#include <errno.h>
12#include <malloc.h>
13
14static const char *const type_name[] = {
15 "reserved",
16 "loader_code",
17 "loader_data",
18 "bs_code",
19 "bs_data",
20 "rt_code",
21 "rt_data",
22 "conv",
23 "unusable",
24 "acpi_reclaim",
25 "acpi_nvs",
26 "io",
27 "io_port",
28 "pal_code",
29};
30
31static struct attr_info {
32 int shift;
33 const char *name;
34} mem_attr[] = {
35 { EFI_MEMORY_UC_SHIFT, "uncached" },
36 { EFI_MEMORY_WC_SHIFT, "write-coalescing" },
37 { EFI_MEMORY_WT_SHIFT, "write-through" },
38 { EFI_MEMORY_WB_SHIFT, "write-back" },
39 { EFI_MEMORY_UCE_SHIFT, "uncached & exported" },
40 { EFI_MEMORY_WP_SHIFT, "write-protect" },
41 { EFI_MEMORY_RP_SHIFT, "read-protect" },
42 { EFI_MEMORY_XP_SHIFT, "execute-protect" },
43 { EFI_MEMORY_RUNTIME_SHIFT, "needs runtime mapping" }
44};
45
46
47#define ATTR_SEEN_MAX 30
48
49static inline bool is_boot_services(int type)
50{
51 return type == EFI_LOADER_CODE || type == EFI_LOADER_DATA ||
52 type == EFI_BOOT_SERVICES_CODE ||
53 type == EFI_BOOT_SERVICES_DATA;
54}
55
56static int h_cmp_entry(const void *v1, const void *v2)
57{
58 const struct efi_mem_desc *desc1 = v1;
59 const struct efi_mem_desc *desc2 = v2;
60 int64_t diff = desc1->physical_start - desc2->physical_start;
61
62
63
64
65
66 return diff < 0 ? -1 : diff > 0 ? 1 : 0;
67}
68
69void *efi_build_mem_table(struct efi_entry_memmap *map, int size, bool skip_bs)
70{
71 struct efi_mem_desc *desc, *end, *base, *dest, *prev;
72 int count;
73 u64 addr;
74
75 base = malloc(size + sizeof(*desc));
76 if (!base) {
77 debug("%s: Cannot allocate %#x bytes\n", __func__, size);
78 return NULL;
79 }
80 end = (struct efi_mem_desc *)((ulong)map + size);
81 count = ((ulong)end - (ulong)map->desc) / map->desc_size;
82 memcpy(base, map->desc, (ulong)end - (ulong)map->desc);
83 qsort(base, count, map->desc_size, h_cmp_entry);
84 prev = NULL;
85 addr = 0;
86 dest = base;
87 end = base + count;
88 for (desc = base; desc < end; desc = efi_get_next_mem_desc(map, desc)) {
89 bool merge = true;
90 int type = desc->type;
91
92 if (skip_bs && is_boot_services(desc->type))
93 type = EFI_CONVENTIONAL_MEMORY;
94
95 memcpy(dest, desc, map->desc_size);
96 dest->type = type;
97 if (!skip_bs || !prev)
98 merge = false;
99 else if (desc->physical_start != addr)
100 merge = false;
101 else if (type != EFI_CONVENTIONAL_MEMORY)
102 merge = false;
103 else if (prev->type != EFI_CONVENTIONAL_MEMORY)
104 merge = false;
105
106 if (merge) {
107 prev->num_pages += desc->num_pages;
108 } else {
109 prev = dest;
110 dest = efi_get_next_mem_desc(map, dest);
111 }
112 addr = desc->physical_start + (desc->num_pages <<
113 EFI_PAGE_SHIFT);
114 }
115
116
117 dest->type = EFI_TABLE_END;
118
119 return base;
120}
121
122static void efi_print_mem_table(struct efi_entry_memmap *map,
123 struct efi_mem_desc *desc, bool skip_bs)
124{
125 u64 attr_seen[ATTR_SEEN_MAX];
126 int attr_seen_count;
127 int upto, i;
128 u64 addr;
129
130 printf(" # %-14s %10s %10s %10s %s\n", "Type", "Physical",
131 "Virtual", "Size", "Attributes");
132
133
134 attr_seen_count = 0;
135 addr = 0;
136 for (upto = 0; desc->type != EFI_TABLE_END;
137 upto++, desc = efi_get_next_mem_desc(map, desc)) {
138 const char *name;
139 u64 size;
140
141 if (skip_bs && is_boot_services(desc->type))
142 continue;
143 if (desc->physical_start != addr) {
144 printf(" %-14s %010llx %10s %010llx\n", "<gap>",
145 addr, "", desc->physical_start - addr);
146 }
147 size = desc->num_pages << EFI_PAGE_SHIFT;
148
149 name = desc->type < ARRAY_SIZE(type_name) ?
150 type_name[desc->type] : "<invalid>";
151 printf("%2d %x:%-12s %010llx %010llx %010llx ", upto,
152 desc->type, name, desc->physical_start,
153 desc->virtual_start, size);
154 if (desc->attribute & EFI_MEMORY_RUNTIME)
155 putc('r');
156 printf("%llx", desc->attribute & ~EFI_MEMORY_RUNTIME);
157 putc('\n');
158
159 for (i = 0; i < attr_seen_count; i++) {
160 if (attr_seen[i] == desc->attribute)
161 break;
162 }
163 if (i == attr_seen_count && i < ATTR_SEEN_MAX)
164 attr_seen[attr_seen_count++] = desc->attribute;
165 addr = desc->physical_start + size;
166 }
167
168 printf("\nAttributes key:\n");
169 for (i = 0; i < attr_seen_count; i++) {
170 u64 attr = attr_seen[i];
171 bool first;
172 int j;
173
174 printf("%c%llx: ", attr & EFI_MEMORY_RUNTIME ? 'r' : ' ',
175 attr & ~EFI_MEMORY_RUNTIME);
176 for (j = 0, first = true; j < ARRAY_SIZE(mem_attr); j++) {
177 if (attr & (1ULL << mem_attr[j].shift)) {
178 if (first)
179 first = false;
180 else
181 printf(", ");
182 printf("%s", mem_attr[j].name);
183 }
184 }
185 putc('\n');
186 }
187 if (skip_bs)
188 printf("*Some areas are merged (use 'all' to see)\n");
189}
190
191static int do_efi_mem(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
192{
193 struct efi_mem_desc *desc;
194 struct efi_entry_memmap *map;
195 int size, ret;
196 bool skip_bs;
197
198 skip_bs = !argc || *argv[0] != 'a';
199 ret = efi_info_get(EFIET_MEMORY_MAP, (void **)&map, &size);
200 switch (ret) {
201 case -ENOENT:
202 printf("No EFI table available\n");
203 goto done;
204 case -EPROTONOSUPPORT:
205 printf("Incorrect EFI table version\n");
206 goto done;
207 }
208 printf("EFI table at %lx, memory map %p, size %x, version %x, descr. size %#x\n",
209 gd->arch.table, map, size, map->version, map->desc_size);
210 if (map->version != EFI_MEM_DESC_VERSION) {
211 printf("Incorrect memory map version\n");
212 ret = -EPROTONOSUPPORT;
213 goto done;
214 }
215
216 desc = efi_build_mem_table(map, size, skip_bs);
217 if (!desc) {
218 ret = -ENOMEM;
219 goto done;
220 }
221
222 efi_print_mem_table(map, desc, skip_bs);
223 free(desc);
224done:
225 if (ret)
226 printf("Error: %d\n", ret);
227
228 return ret ? CMD_RET_FAILURE : 0;
229}
230
231static cmd_tbl_t efi_commands[] = {
232 U_BOOT_CMD_MKENT(mem, 1, 1, do_efi_mem, "", ""),
233};
234
235static int do_efi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
236{
237 cmd_tbl_t *efi_cmd;
238 int ret;
239
240 if (argc < 2)
241 return CMD_RET_USAGE;
242 efi_cmd = find_cmd_tbl(argv[1], efi_commands, ARRAY_SIZE(efi_commands));
243 argc -= 2;
244 argv += 2;
245 if (!efi_cmd || argc > efi_cmd->maxargs)
246 return CMD_RET_USAGE;
247
248 ret = efi_cmd->cmd(efi_cmd, flag, argc, argv);
249
250 return cmd_process_error(efi_cmd, ret);
251}
252
253U_BOOT_CMD(
254 efi, 3, 1, do_efi,
255 "EFI access",
256 "mem [all] Dump memory information [include boot services]"
257);
258
