[J-u-boot.git] / cmd / efi.c

/*
 * (C) Copyright 2015 Google, Inc
 * Written by Simon Glass <[email protected]>
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <common.h>
#include <command.h>
#include <efi.h>
#include <errno.h>
#include <malloc.h>

static const char *const type_name[] = {
	"reserved",
	"loader_code",
	"loader_data",
	"bs_code",
	"bs_data",
	"rt_code",
	"rt_data",
	"conv",
	"unusable",
	"acpi_reclaim",
	"acpi_nvs",
	"io",
	"io_port",
	"pal_code",
};

static struct attr_info {
	int shift;
	const char *name;
} mem_attr[] = {
	{ EFI_MEMORY_UC_SHIFT, "uncached" },
	{ EFI_MEMORY_WC_SHIFT, "write-coalescing" },
	{ EFI_MEMORY_WT_SHIFT, "write-through" },
	{ EFI_MEMORY_WB_SHIFT, "write-back" },
	{ EFI_MEMORY_UCE_SHIFT, "uncached & exported" },
	{ EFI_MEMORY_WP_SHIFT, "write-protect" },
	{ EFI_MEMORY_RP_SHIFT, "read-protect" },
	{ EFI_MEMORY_XP_SHIFT, "execute-protect" },
	{ EFI_MEMORY_RUNTIME_SHIFT, "needs runtime mapping" }
};

/* Maximum different attribute values we can track */
#define ATTR_SEEN_MAX	30

static inline bool is_boot_services(int type)
{
	return type == EFI_LOADER_CODE || type == EFI_LOADER_DATA ||
		type == EFI_BOOT_SERVICES_CODE ||
		type == EFI_BOOT_SERVICES_DATA;
}

static int h_cmp_entry(const void *v1, const void *v2)
{
	const struct efi_mem_desc *desc1 = v1;
	const struct efi_mem_desc *desc2 = v2;
	int64_t diff = desc1->physical_start - desc2->physical_start;

	/*
	 * Manually calculate the difference to avoid sign loss in the 64-bit
	 * to 32-bit conversion
	 */
	return diff < 0 ? -1 : diff > 0 ? 1 : 0;
}

void *efi_build_mem_table(struct efi_entry_memmap *map, int size, bool skip_bs)
{
	struct efi_mem_desc *desc, *end, *base, *dest, *prev;
	int count;
	u64 addr;

	base = malloc(size + sizeof(*desc));
	if (!base) {
		debug("%s: Cannot allocate %#x bytes\n", __func__, size);
		return NULL;
	}
	end = (struct efi_mem_desc *)((ulong)map + size);
	count = ((ulong)end - (ulong)map->desc) / map->desc_size;
	memcpy(base, map->desc, (ulong)end - (ulong)map->desc);
	qsort(base, count, map->desc_size, h_cmp_entry);
	prev = NULL;
	addr = 0;
	dest = base;
	end = base + count;
	for (desc = base; desc < end; desc = efi_get_next_mem_desc(map, desc)) {
		bool merge = true;
		int type = desc->type;

		if (skip_bs && is_boot_services(desc->type))
			type = EFI_CONVENTIONAL_MEMORY;

		memcpy(dest, desc, map->desc_size);
		dest->type = type;
		if (!skip_bs || !prev)
			merge = false;
		else if (desc->physical_start != addr)
			merge = false;
		else if (type != EFI_CONVENTIONAL_MEMORY)
			merge = false;
		else if (prev->type != EFI_CONVENTIONAL_MEMORY)
			merge = false;

		if (merge) {
			prev->num_pages += desc->num_pages;
		} else {
			prev = dest;
			dest = efi_get_next_mem_desc(map, dest);
		}
		addr = desc->physical_start + (desc->num_pages <<
				EFI_PAGE_SHIFT);
	}

	/* Mark the end */
	dest->type = EFI_TABLE_END;

	return base;
}

static void efi_print_mem_table(struct efi_entry_memmap *map,
				struct efi_mem_desc *desc, bool skip_bs)
{
	u64 attr_seen[ATTR_SEEN_MAX];
	int attr_seen_count;
	int upto, i;
	u64 addr;

	printf(" #  %-14s  %10s  %10s  %10s  %s\n", "Type", "Physical",
	       "Virtual", "Size", "Attributes");

	/* Keep track of all the different attributes we have seen */
	attr_seen_count = 0;
	addr = 0;
	for (upto = 0; desc->type != EFI_TABLE_END;
	     upto++, desc = efi_get_next_mem_desc(map, desc)) {
		const char *name;
		u64 size;

		if (skip_bs && is_boot_services(desc->type))
			continue;
		if (desc->physical_start != addr) {
			printf("    %-14s  %010llx  %10s  %010llx\n", "<gap>",
			       addr, "", desc->physical_start - addr);
		}
		size = desc->num_pages << EFI_PAGE_SHIFT;

		name = desc->type < ARRAY_SIZE(type_name) ?
				type_name[desc->type] : "<invalid>";
		printf("%2d  %x:%-12s  %010llx  %010llx  %010llx  ", upto,
		       desc->type, name, desc->physical_start,
		       desc->virtual_start, size);
		if (desc->attribute & EFI_MEMORY_RUNTIME)
			putc('r');
		printf("%llx", desc->attribute & ~EFI_MEMORY_RUNTIME);
		putc('\n');

		for (i = 0; i < attr_seen_count; i++) {
			if (attr_seen[i] == desc->attribute)
				break;
		}
		if (i == attr_seen_count && i < ATTR_SEEN_MAX)
			attr_seen[attr_seen_count++] = desc->attribute;
		addr = desc->physical_start + size;
	}

	printf("\nAttributes key:\n");
	for (i = 0; i < attr_seen_count; i++) {
		u64 attr = attr_seen[i];
		bool first;
		int j;

		printf("%c%llx: ", attr & EFI_MEMORY_RUNTIME ? 'r' : ' ',
		       attr & ~EFI_MEMORY_RUNTIME);
		for (j = 0, first = true; j < ARRAY_SIZE(mem_attr); j++) {
			if (attr & (1ULL << mem_attr[j].shift)) {
				if (first)
					first = false;
				else
					printf(", ");
				printf("%s", mem_attr[j].name);
			}
		}
		putc('\n');
	}
	if (skip_bs)
		printf("*Some areas are merged (use 'all' to see)\n");
}

static int do_efi_mem(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
	struct efi_mem_desc *desc;
	struct efi_entry_memmap *map;
	int size, ret;
	bool skip_bs;

	skip_bs = !argc || *argv[0] != 'a';
	ret = efi_info_get(EFIET_MEMORY_MAP, (void **)&map, &size);
	switch (ret) {
	case -ENOENT:
		printf("No EFI table available\n");
		goto done;
	case -EPROTONOSUPPORT:
		printf("Incorrect EFI table version\n");
		goto done;
	}
	printf("EFI table at %lx, memory map %p, size %x, version %x, descr. size %#x\n",
	       gd->arch.table, map, size, map->version, map->desc_size);
	if (map->version != EFI_MEM_DESC_VERSION) {
		printf("Incorrect memory map version\n");
		ret = -EPROTONOSUPPORT;
		goto done;
	}

	desc = efi_build_mem_table(map, size, skip_bs);
	if (!desc) {
		ret = -ENOMEM;
		goto done;
	}

	efi_print_mem_table(map, desc, skip_bs);
	free(desc);
done:
	if (ret)
		printf("Error: %d\n", ret);

	return ret ? CMD_RET_FAILURE : 0;
}

static cmd_tbl_t efi_commands[] = {
	U_BOOT_CMD_MKENT(mem, 1, 1, do_efi_mem, "", ""),
};

static int do_efi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
	cmd_tbl_t *efi_cmd;
	int ret;

	if (argc < 2)
		return CMD_RET_USAGE;
	efi_cmd = find_cmd_tbl(argv[1], efi_commands, ARRAY_SIZE(efi_commands));
	argc -= 2;
	argv += 2;
	if (!efi_cmd || argc > efi_cmd->maxargs)
		return CMD_RET_USAGE;

	ret = efi_cmd->cmd(efi_cmd, flag, argc, argv);

	return cmd_process_error(efi_cmd, ret);
}

U_BOOT_CMD(
	efi,     3,      1,      do_efi,
	"EFI access",
	"mem [all]        Dump memory information [include boot services]"
);
Commit	Line	Data
f1a0bafb SG	1	/*
	2	* (C) Copyright 2015 Google, Inc
	3	* Written by Simon Glass <[email protected]>
	4	*
	5	* SPDX-License-Identifier: GPL-2.0+
	6	*/
	7
	8	#include <common.h>
	9	#include <command.h>
	10	#include <efi.h>
	11	#include <errno.h>
	12	#include <malloc.h>
	13
	14	static 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
	31	static 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	/* Maximum different attribute values we can track */
	47	#define ATTR_SEEN_MAX 30
	48
	49	static 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
	56	static 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	* Manually calculate the difference to avoid sign loss in the 64-bit
	64	* to 32-bit conversion
65	*/
66	return diff < 0 ? -1 : diff > 0 ? 1 : 0;
67	}
68
69	void 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	/* Mark the end */
117	dest->type = EFI_TABLE_END;
118
119	return base;
120	}
121
122	static 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	/* Keep track of all the different attributes we have seen */
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
191	static 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);
224	done:
225	if (ret)
226	printf("Error: %d\n", ret);
227
228	return ret ? CMD_RET_FAILURE : 0;
229	}
230
231	static cmd_tbl_t efi_commands[] = {
232	U_BOOT_CMD_MKENT(mem, 1, 1, do_efi_mem, "", ""),
233	};
234
235	static 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
253	U_BOOT_CMD(
254	efi, 3, 1, do_efi,
255	"EFI access",
256	"mem [all] Dump memory information [include boot services]"
257	);