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