]>
Commit | Line | Data |
---|---|---|
59df7e7e AT |
1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* | |
3 | * UEFI Shell-like command | |
4 | * | |
5 | * Copyright (c) 2018 AKASHI Takahiro, Linaro Limited | |
6 | */ | |
7 | ||
8 | #include <charset.h> | |
9 | #include <common.h> | |
10 | #include <command.h> | |
11 | #include <efi_loader.h> | |
59df7e7e | 12 | #include <exports.h> |
39a1ff8c | 13 | #include <hexdump.h> |
f7ae49fc | 14 | #include <log.h> |
59df7e7e | 15 | #include <malloc.h> |
a415d61e | 16 | #include <mapmem.h> |
59df7e7e AT |
17 | #include <search.h> |
18 | #include <linux/ctype.h> | |
19 | ||
355cdb5a | 20 | #define BS systab.boottime |
59df7e7e | 21 | |
355cdb5a AT |
22 | /** |
23 | * efi_get_device_handle_info() - get information of UEFI device | |
24 | * | |
25 | * @handle: Handle of UEFI device | |
26 | * @dev_path_text: Pointer to text of device path | |
27 | * Return: 0 on success, -1 on failure | |
28 | * | |
29 | * Currently return a formatted text of device path. | |
30 | */ | |
31 | static int efi_get_device_handle_info(efi_handle_t handle, u16 **dev_path_text) | |
32 | { | |
33 | struct efi_device_path *dp; | |
34 | efi_status_t ret; | |
35 | ||
36 | ret = EFI_CALL(BS->open_protocol(handle, &efi_guid_device_path, | |
37 | (void **)&dp, NULL /* FIXME */, NULL, | |
38 | EFI_OPEN_PROTOCOL_GET_PROTOCOL)); | |
39 | if (ret == EFI_SUCCESS) { | |
40 | *dev_path_text = efi_dp_str(dp); | |
41 | return 0; | |
42 | } else { | |
43 | return -1; | |
44 | } | |
45 | } | |
46 | ||
47 | #define EFI_HANDLE_WIDTH ((int)sizeof(efi_handle_t) * 2) | |
48 | ||
49 | static const char spc[] = " "; | |
50 | static const char sep[] = "================"; | |
51 | ||
52 | /** | |
53 | * do_efi_show_devices() - show UEFI devices | |
54 | * | |
55 | * @cmdtp: Command table | |
56 | * @flag: Command flag | |
57 | * @argc: Number of arguments | |
58 | * @argv: Argument array | |
59 | * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure | |
60 | * | |
61 | * Implement efidebug "devices" sub-command. | |
62 | * Show all UEFI devices and their information. | |
63 | */ | |
09140113 SG |
64 | static int do_efi_show_devices(struct cmd_tbl *cmdtp, int flag, |
65 | int argc, char *const argv[]) | |
355cdb5a AT |
66 | { |
67 | efi_handle_t *handles; | |
68 | efi_uintn_t num, i; | |
69 | u16 *dev_path_text; | |
70 | efi_status_t ret; | |
71 | ||
a30c7231 | 72 | ret = EFI_CALL(efi_locate_handle_buffer(ALL_HANDLES, NULL, NULL, |
355cdb5a AT |
73 | &num, &handles)); |
74 | if (ret != EFI_SUCCESS) | |
75 | return CMD_RET_FAILURE; | |
76 | ||
77 | if (!num) | |
78 | return CMD_RET_SUCCESS; | |
79 | ||
80 | printf("Device%.*s Device Path\n", EFI_HANDLE_WIDTH - 6, spc); | |
81 | printf("%.*s ====================\n", EFI_HANDLE_WIDTH, sep); | |
82 | for (i = 0; i < num; i++) { | |
83 | if (!efi_get_device_handle_info(handles[i], &dev_path_text)) { | |
84 | printf("%p %ls\n", handles[i], dev_path_text); | |
85 | efi_free_pool(dev_path_text); | |
86 | } | |
87 | } | |
88 | ||
a30c7231 | 89 | efi_free_pool(handles); |
355cdb5a AT |
90 | |
91 | return CMD_RET_SUCCESS; | |
92 | } | |
93 | ||
66eaf566 AT |
94 | /** |
95 | * efi_get_driver_handle_info() - get information of UEFI driver | |
96 | * | |
97 | * @handle: Handle of UEFI device | |
98 | * @driver_name: Driver name | |
99 | * @image_path: Pointer to text of device path | |
100 | * Return: 0 on success, -1 on failure | |
101 | * | |
102 | * Currently return no useful information as all UEFI drivers are | |
103 | * built-in.. | |
104 | */ | |
105 | static int efi_get_driver_handle_info(efi_handle_t handle, u16 **driver_name, | |
106 | u16 **image_path) | |
107 | { | |
108 | struct efi_handler *handler; | |
109 | struct efi_loaded_image *image; | |
110 | efi_status_t ret; | |
111 | ||
112 | /* | |
113 | * driver name | |
114 | * TODO: support EFI_COMPONENT_NAME2_PROTOCOL | |
115 | */ | |
116 | *driver_name = NULL; | |
117 | ||
118 | /* image name */ | |
119 | ret = efi_search_protocol(handle, &efi_guid_loaded_image, &handler); | |
120 | if (ret != EFI_SUCCESS) { | |
121 | *image_path = NULL; | |
122 | return 0; | |
123 | } | |
124 | ||
125 | image = handler->protocol_interface; | |
126 | *image_path = efi_dp_str(image->file_path); | |
127 | ||
128 | return 0; | |
129 | } | |
130 | ||
131 | /** | |
132 | * do_efi_show_drivers() - show UEFI drivers | |
133 | * | |
134 | * @cmdtp: Command table | |
135 | * @flag: Command flag | |
136 | * @argc: Number of arguments | |
137 | * @argv: Argument array | |
138 | * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure | |
139 | * | |
140 | * Implement efidebug "drivers" sub-command. | |
141 | * Show all UEFI drivers and their information. | |
142 | */ | |
09140113 SG |
143 | static int do_efi_show_drivers(struct cmd_tbl *cmdtp, int flag, |
144 | int argc, char *const argv[]) | |
66eaf566 AT |
145 | { |
146 | efi_handle_t *handles; | |
147 | efi_uintn_t num, i; | |
148 | u16 *driver_name, *image_path_text; | |
149 | efi_status_t ret; | |
150 | ||
a30c7231 | 151 | ret = EFI_CALL(efi_locate_handle_buffer( |
66eaf566 AT |
152 | BY_PROTOCOL, &efi_guid_driver_binding_protocol, |
153 | NULL, &num, &handles)); | |
154 | if (ret != EFI_SUCCESS) | |
155 | return CMD_RET_FAILURE; | |
156 | ||
157 | if (!num) | |
158 | return CMD_RET_SUCCESS; | |
159 | ||
160 | printf("Driver%.*s Name Image Path\n", | |
161 | EFI_HANDLE_WIDTH - 6, spc); | |
162 | printf("%.*s ==================== ====================\n", | |
163 | EFI_HANDLE_WIDTH, sep); | |
164 | for (i = 0; i < num; i++) { | |
165 | if (!efi_get_driver_handle_info(handles[i], &driver_name, | |
166 | &image_path_text)) { | |
167 | if (image_path_text) | |
168 | printf("%p %-20ls %ls\n", handles[i], | |
169 | driver_name, image_path_text); | |
170 | else | |
171 | printf("%p %-20ls <built-in>\n", | |
172 | handles[i], driver_name); | |
a30c7231 HS |
173 | efi_free_pool(driver_name); |
174 | efi_free_pool(image_path_text); | |
66eaf566 AT |
175 | } |
176 | } | |
177 | ||
a30c7231 | 178 | efi_free_pool(handles); |
66eaf566 AT |
179 | |
180 | return CMD_RET_SUCCESS; | |
181 | } | |
182 | ||
a8014620 AT |
183 | static const struct { |
184 | const char *text; | |
185 | const efi_guid_t guid; | |
186 | } guid_list[] = { | |
187 | { | |
188 | "Device Path", | |
dec88e41 | 189 | EFI_DEVICE_PATH_PROTOCOL_GUID, |
a8014620 AT |
190 | }, |
191 | { | |
192 | "Device Path To Text", | |
193 | EFI_DEVICE_PATH_TO_TEXT_PROTOCOL_GUID, | |
194 | }, | |
195 | { | |
196 | "Device Path Utilities", | |
197 | EFI_DEVICE_PATH_UTILITIES_PROTOCOL_GUID, | |
198 | }, | |
199 | { | |
200 | "Unicode Collation 2", | |
201 | EFI_UNICODE_COLLATION_PROTOCOL2_GUID, | |
202 | }, | |
203 | { | |
204 | "Driver Binding", | |
205 | EFI_DRIVER_BINDING_PROTOCOL_GUID, | |
206 | }, | |
207 | { | |
208 | "Simple Text Input", | |
209 | EFI_SIMPLE_TEXT_INPUT_PROTOCOL_GUID, | |
210 | }, | |
211 | { | |
212 | "Simple Text Input Ex", | |
213 | EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL_GUID, | |
214 | }, | |
215 | { | |
216 | "Simple Text Output", | |
217 | EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL_GUID, | |
218 | }, | |
219 | { | |
220 | "Block IO", | |
dec88e41 | 221 | EFI_BLOCK_IO_PROTOCOL_GUID, |
a8014620 AT |
222 | }, |
223 | { | |
224 | "Simple File System", | |
225 | EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID, | |
226 | }, | |
227 | { | |
228 | "Loaded Image", | |
dec88e41 | 229 | EFI_LOADED_IMAGE_PROTOCOL_GUID, |
a8014620 AT |
230 | }, |
231 | { | |
dec88e41 HS |
232 | "Graphics Output", |
233 | EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID, | |
a8014620 | 234 | }, |
391bc8a9 HS |
235 | { |
236 | "HII String", | |
237 | EFI_HII_STRING_PROTOCOL_GUID, | |
238 | }, | |
239 | { | |
240 | "HII Database", | |
241 | EFI_HII_DATABASE_PROTOCOL_GUID, | |
242 | }, | |
243 | { | |
244 | "HII Config Routing", | |
245 | EFI_HII_CONFIG_ROUTING_PROTOCOL_GUID, | |
246 | }, | |
ec80b473 IA |
247 | { |
248 | "Load File2", | |
249 | EFI_LOAD_FILE2_PROTOCOL_GUID, | |
250 | }, | |
391bc8a9 HS |
251 | { |
252 | "Simple Network", | |
253 | EFI_SIMPLE_NETWORK_PROTOCOL_GUID, | |
254 | }, | |
255 | { | |
256 | "PXE Base Code", | |
257 | EFI_PXE_BASE_CODE_PROTOCOL_GUID, | |
258 | }, | |
986e0648 HS |
259 | /* Configuration table GUIDs */ |
260 | { | |
261 | "ACPI table", | |
262 | EFI_ACPI_TABLE_GUID, | |
263 | }, | |
264 | { | |
265 | "device tree", | |
266 | EFI_FDT_GUID, | |
267 | }, | |
268 | { | |
269 | "SMBIOS table", | |
270 | SMBIOS_TABLE_GUID, | |
271 | }, | |
76be6872 HS |
272 | { |
273 | "Runtime properties", | |
274 | EFI_RT_PROPERTIES_TABLE_GUID, | |
275 | }, | |
a8014620 AT |
276 | }; |
277 | ||
278 | /** | |
173cd9e7 | 279 | * get_guid_text - get string of GUID |
a8014620 | 280 | * |
173cd9e7 HS |
281 | * Return description of GUID. |
282 | * | |
283 | * @guid: GUID | |
284 | * Return: description of GUID or NULL | |
a8014620 | 285 | */ |
173cd9e7 | 286 | static const char *get_guid_text(const void *guid) |
a8014620 AT |
287 | { |
288 | int i; | |
289 | ||
173cd9e7 HS |
290 | for (i = 0; i < ARRAY_SIZE(guid_list); i++) { |
291 | /* | |
292 | * As guidcmp uses memcmp() we can safely accept unaligned | |
293 | * GUIDs. | |
294 | */ | |
a8014620 | 295 | if (!guidcmp(&guid_list[i].guid, guid)) |
173cd9e7 HS |
296 | return guid_list[i].text; |
297 | } | |
a8014620 | 298 | |
173cd9e7 | 299 | return NULL; |
a8014620 AT |
300 | } |
301 | ||
302 | /** | |
303 | * do_efi_show_handles() - show UEFI handles | |
304 | * | |
305 | * @cmdtp: Command table | |
306 | * @flag: Command flag | |
307 | * @argc: Number of arguments | |
308 | * @argv: Argument array | |
309 | * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure | |
310 | * | |
311 | * Implement efidebug "dh" sub-command. | |
312 | * Show all UEFI handles and their information, currently all protocols | |
313 | * added to handle. | |
314 | */ | |
09140113 SG |
315 | static int do_efi_show_handles(struct cmd_tbl *cmdtp, int flag, |
316 | int argc, char *const argv[]) | |
a8014620 AT |
317 | { |
318 | efi_handle_t *handles; | |
319 | efi_guid_t **guid; | |
320 | efi_uintn_t num, count, i, j; | |
321 | const char *guid_text; | |
322 | efi_status_t ret; | |
323 | ||
a30c7231 | 324 | ret = EFI_CALL(efi_locate_handle_buffer(ALL_HANDLES, NULL, NULL, |
a8014620 AT |
325 | &num, &handles)); |
326 | if (ret != EFI_SUCCESS) | |
327 | return CMD_RET_FAILURE; | |
328 | ||
329 | if (!num) | |
330 | return CMD_RET_SUCCESS; | |
331 | ||
332 | printf("Handle%.*s Protocols\n", EFI_HANDLE_WIDTH - 6, spc); | |
333 | printf("%.*s ====================\n", EFI_HANDLE_WIDTH, sep); | |
334 | for (i = 0; i < num; i++) { | |
335 | printf("%p", handles[i]); | |
336 | ret = EFI_CALL(BS->protocols_per_handle(handles[i], &guid, | |
337 | &count)); | |
338 | if (ret || !count) { | |
339 | putc('\n'); | |
340 | continue; | |
341 | } | |
342 | ||
343 | for (j = 0; j < count; j++) { | |
344 | if (j) | |
345 | printf(", "); | |
346 | else | |
347 | putc(' '); | |
348 | ||
349 | guid_text = get_guid_text(guid[j]); | |
350 | if (guid_text) | |
351 | puts(guid_text); | |
352 | else | |
353 | printf("%pUl", guid[j]); | |
354 | } | |
355 | putc('\n'); | |
356 | } | |
357 | ||
a30c7231 | 358 | efi_free_pool(handles); |
a8014620 AT |
359 | |
360 | return CMD_RET_SUCCESS; | |
361 | } | |
362 | ||
fa536734 AT |
363 | /** |
364 | * do_efi_show_images() - show UEFI images | |
365 | * | |
366 | * @cmdtp: Command table | |
367 | * @flag: Command flag | |
368 | * @argc: Number of arguments | |
369 | * @argv: Argument array | |
370 | * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure | |
371 | * | |
372 | * Implement efidebug "images" sub-command. | |
373 | * Show all UEFI loaded images and their information. | |
374 | */ | |
09140113 SG |
375 | static int do_efi_show_images(struct cmd_tbl *cmdtp, int flag, |
376 | int argc, char *const argv[]) | |
fa536734 AT |
377 | { |
378 | efi_print_image_infos(NULL); | |
379 | ||
380 | return CMD_RET_SUCCESS; | |
381 | } | |
382 | ||
00358bb8 AT |
383 | static const char * const efi_mem_type_string[] = { |
384 | [EFI_RESERVED_MEMORY_TYPE] = "RESERVED", | |
385 | [EFI_LOADER_CODE] = "LOADER CODE", | |
386 | [EFI_LOADER_DATA] = "LOADER DATA", | |
387 | [EFI_BOOT_SERVICES_CODE] = "BOOT CODE", | |
388 | [EFI_BOOT_SERVICES_DATA] = "BOOT DATA", | |
389 | [EFI_RUNTIME_SERVICES_CODE] = "RUNTIME CODE", | |
390 | [EFI_RUNTIME_SERVICES_DATA] = "RUNTIME DATA", | |
391 | [EFI_CONVENTIONAL_MEMORY] = "CONVENTIONAL", | |
392 | [EFI_UNUSABLE_MEMORY] = "UNUSABLE MEM", | |
393 | [EFI_ACPI_RECLAIM_MEMORY] = "ACPI RECLAIM MEM", | |
394 | [EFI_ACPI_MEMORY_NVS] = "ACPI NVS", | |
395 | [EFI_MMAP_IO] = "IO", | |
396 | [EFI_MMAP_IO_PORT] = "IO PORT", | |
397 | [EFI_PAL_CODE] = "PAL", | |
dd9056c0 | 398 | [EFI_PERSISTENT_MEMORY_TYPE] = "PERSISTENT", |
00358bb8 AT |
399 | }; |
400 | ||
401 | static const struct efi_mem_attrs { | |
402 | const u64 bit; | |
403 | const char *text; | |
404 | } efi_mem_attrs[] = { | |
405 | {EFI_MEMORY_UC, "UC"}, | |
406 | {EFI_MEMORY_UC, "UC"}, | |
407 | {EFI_MEMORY_WC, "WC"}, | |
408 | {EFI_MEMORY_WT, "WT"}, | |
409 | {EFI_MEMORY_WB, "WB"}, | |
410 | {EFI_MEMORY_UCE, "UCE"}, | |
411 | {EFI_MEMORY_WP, "WP"}, | |
412 | {EFI_MEMORY_RP, "RP"}, | |
413 | {EFI_MEMORY_XP, "WP"}, | |
414 | {EFI_MEMORY_NV, "NV"}, | |
415 | {EFI_MEMORY_MORE_RELIABLE, "REL"}, | |
416 | {EFI_MEMORY_RO, "RO"}, | |
255a4733 | 417 | {EFI_MEMORY_SP, "SP"}, |
00358bb8 AT |
418 | {EFI_MEMORY_RUNTIME, "RT"}, |
419 | }; | |
420 | ||
421 | /** | |
422 | * print_memory_attributes() - print memory map attributes | |
0b016569 | 423 | * |
00358bb8 AT |
424 | * @attributes: Attribute value |
425 | * | |
426 | * Print memory map attributes | |
427 | */ | |
428 | static void print_memory_attributes(u64 attributes) | |
429 | { | |
430 | int sep, i; | |
431 | ||
432 | for (sep = 0, i = 0; i < ARRAY_SIZE(efi_mem_attrs); i++) | |
433 | if (attributes & efi_mem_attrs[i].bit) { | |
434 | if (sep) { | |
435 | putc('|'); | |
436 | } else { | |
437 | putc(' '); | |
438 | sep = 1; | |
439 | } | |
440 | puts(efi_mem_attrs[i].text); | |
441 | } | |
442 | } | |
443 | ||
444 | #define EFI_PHYS_ADDR_WIDTH (int)(sizeof(efi_physical_addr_t) * 2) | |
445 | ||
446 | /** | |
447 | * do_efi_show_memmap() - show UEFI memory map | |
448 | * | |
449 | * @cmdtp: Command table | |
450 | * @flag: Command flag | |
451 | * @argc: Number of arguments | |
452 | * @argv: Argument array | |
453 | * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure | |
454 | * | |
455 | * Implement efidebug "memmap" sub-command. | |
456 | * Show UEFI memory map. | |
457 | */ | |
09140113 SG |
458 | static int do_efi_show_memmap(struct cmd_tbl *cmdtp, int flag, |
459 | int argc, char *const argv[]) | |
00358bb8 AT |
460 | { |
461 | struct efi_mem_desc *memmap = NULL, *map; | |
462 | efi_uintn_t map_size = 0; | |
463 | const char *type; | |
464 | int i; | |
465 | efi_status_t ret; | |
466 | ||
a30c7231 | 467 | ret = efi_get_memory_map(&map_size, memmap, NULL, NULL, NULL); |
00358bb8 AT |
468 | if (ret == EFI_BUFFER_TOO_SMALL) { |
469 | map_size += sizeof(struct efi_mem_desc); /* for my own */ | |
a30c7231 HS |
470 | ret = efi_allocate_pool(EFI_LOADER_DATA, map_size, |
471 | (void *)&memmap); | |
00358bb8 AT |
472 | if (ret != EFI_SUCCESS) |
473 | return CMD_RET_FAILURE; | |
a30c7231 | 474 | ret = efi_get_memory_map(&map_size, memmap, NULL, NULL, NULL); |
00358bb8 AT |
475 | } |
476 | if (ret != EFI_SUCCESS) { | |
a30c7231 | 477 | efi_free_pool(memmap); |
00358bb8 AT |
478 | return CMD_RET_FAILURE; |
479 | } | |
480 | ||
481 | printf("Type Start%.*s End%.*s Attributes\n", | |
482 | EFI_PHYS_ADDR_WIDTH - 5, spc, EFI_PHYS_ADDR_WIDTH - 3, spc); | |
483 | printf("================ %.*s %.*s ==========\n", | |
484 | EFI_PHYS_ADDR_WIDTH, sep, EFI_PHYS_ADDR_WIDTH, sep); | |
e2a5b860 AT |
485 | /* |
486 | * Coverity check: dereferencing null pointer "map." | |
487 | * This is a false positive as memmap will always be | |
488 | * populated by allocate_pool() above. | |
489 | */ | |
00358bb8 | 490 | for (i = 0, map = memmap; i < map_size / sizeof(*map); map++, i++) { |
dd9056c0 | 491 | if (map->type < ARRAY_SIZE(efi_mem_type_string)) |
00358bb8 AT |
492 | type = efi_mem_type_string[map->type]; |
493 | else | |
494 | type = "(unknown)"; | |
495 | ||
496 | printf("%-16s %.*llx-%.*llx", type, | |
497 | EFI_PHYS_ADDR_WIDTH, | |
6c0ef35c HS |
498 | (u64)map_to_sysmem((void *)(uintptr_t) |
499 | map->physical_start), | |
00358bb8 | 500 | EFI_PHYS_ADDR_WIDTH, |
6c0ef35c HS |
501 | (u64)map_to_sysmem((void *)(uintptr_t) |
502 | (map->physical_start + | |
503 | map->num_pages * EFI_PAGE_SIZE))); | |
00358bb8 AT |
504 | |
505 | print_memory_attributes(map->attribute); | |
506 | putc('\n'); | |
507 | } | |
508 | ||
a30c7231 | 509 | efi_free_pool(memmap); |
00358bb8 AT |
510 | |
511 | return CMD_RET_SUCCESS; | |
512 | } | |
513 | ||
986e0648 HS |
514 | /** |
515 | * do_efi_show_tables() - show UEFI configuration tables | |
516 | * | |
517 | * @cmdtp: Command table | |
518 | * @flag: Command flag | |
519 | * @argc: Number of arguments | |
520 | * @argv: Argument array | |
521 | * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure | |
522 | * | |
523 | * Implement efidebug "tables" sub-command. | |
524 | * Show UEFI configuration tables. | |
525 | */ | |
09140113 SG |
526 | static int do_efi_show_tables(struct cmd_tbl *cmdtp, int flag, |
527 | int argc, char *const argv[]) | |
986e0648 HS |
528 | { |
529 | efi_uintn_t i; | |
530 | const char *guid_str; | |
531 | ||
532 | for (i = 0; i < systab.nr_tables; ++i) { | |
533 | guid_str = get_guid_text(&systab.tables[i].guid); | |
534 | if (!guid_str) | |
535 | guid_str = ""; | |
536 | printf("%pUl %s\n", &systab.tables[i].guid, guid_str); | |
537 | } | |
538 | ||
539 | return CMD_RET_SUCCESS; | |
540 | } | |
541 | ||
59df7e7e AT |
542 | /** |
543 | * do_efi_boot_add() - set UEFI load option | |
544 | * | |
545 | * @cmdtp: Command table | |
546 | * @flag: Command flag | |
547 | * @argc: Number of arguments | |
548 | * @argv: Argument array | |
549 | * Return: CMD_RET_SUCCESS on success, | |
550 | * CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure | |
551 | * | |
0b016569 HS |
552 | * Implement efidebug "boot add" sub-command. Create or change UEFI load option. |
553 | * | |
554 | * efidebug boot add <id> <label> <interface> <devnum>[:<part>] <file> <options> | |
59df7e7e | 555 | */ |
09140113 SG |
556 | static int do_efi_boot_add(struct cmd_tbl *cmdtp, int flag, |
557 | int argc, char *const argv[]) | |
59df7e7e AT |
558 | { |
559 | int id; | |
560 | char *endp; | |
561 | char var_name[9]; | |
562 | u16 var_name16[9], *p; | |
563 | efi_guid_t guid; | |
564 | size_t label_len, label_len16; | |
565 | u16 *label; | |
566 | struct efi_device_path *device_path = NULL, *file_path = NULL; | |
567 | struct efi_load_option lo; | |
568 | void *data = NULL; | |
569 | efi_uintn_t size; | |
428a470a | 570 | efi_status_t ret; |
a332f251 | 571 | int r = CMD_RET_SUCCESS; |
59df7e7e AT |
572 | |
573 | if (argc < 6 || argc > 7) | |
574 | return CMD_RET_USAGE; | |
575 | ||
576 | id = (int)simple_strtoul(argv[1], &endp, 16); | |
577 | if (*endp != '\0' || id > 0xffff) | |
1fa442ed | 578 | return CMD_RET_USAGE; |
59df7e7e AT |
579 | |
580 | sprintf(var_name, "Boot%04X", id); | |
581 | p = var_name16; | |
582 | utf8_utf16_strncpy(&p, var_name, 9); | |
583 | ||
584 | guid = efi_global_variable_guid; | |
585 | ||
586 | /* attributes */ | |
587 | lo.attributes = LOAD_OPTION_ACTIVE; /* always ACTIVE */ | |
588 | ||
589 | /* label */ | |
590 | label_len = strlen(argv[2]); | |
591 | label_len16 = utf8_utf16_strnlen(argv[2], label_len); | |
592 | label = malloc((label_len16 + 1) * sizeof(u16)); | |
593 | if (!label) | |
594 | return CMD_RET_FAILURE; | |
595 | lo.label = label; /* label will be changed below */ | |
596 | utf8_utf16_strncpy(&label, argv[2], label_len); | |
597 | ||
598 | /* file path */ | |
599 | ret = efi_dp_from_name(argv[3], argv[4], argv[5], &device_path, | |
600 | &file_path); | |
601 | if (ret != EFI_SUCCESS) { | |
602 | printf("Cannot create device path for \"%s %s\"\n", | |
603 | argv[3], argv[4]); | |
428a470a | 604 | r = CMD_RET_FAILURE; |
59df7e7e AT |
605 | goto out; |
606 | } | |
607 | lo.file_path = file_path; | |
608 | lo.file_path_length = efi_dp_size(file_path) | |
609 | + sizeof(struct efi_device_path); /* for END */ | |
610 | ||
611 | /* optional data */ | |
d67591dc | 612 | if (argc == 6) |
39a1ff8c HS |
613 | lo.optional_data = NULL; |
614 | else | |
615 | lo.optional_data = (const u8 *)argv[6]; | |
59df7e7e AT |
616 | |
617 | size = efi_serialize_load_option(&lo, (u8 **)&data); | |
618 | if (!size) { | |
428a470a | 619 | r = CMD_RET_FAILURE; |
59df7e7e AT |
620 | goto out; |
621 | } | |
622 | ||
a30c7231 | 623 | ret = EFI_CALL(efi_set_variable(var_name16, &guid, |
f658c2e1 | 624 | EFI_VARIABLE_NON_VOLATILE | |
59df7e7e AT |
625 | EFI_VARIABLE_BOOTSERVICE_ACCESS | |
626 | EFI_VARIABLE_RUNTIME_ACCESS, | |
627 | size, data)); | |
a332f251 HS |
628 | if (ret != EFI_SUCCESS) { |
629 | printf("Cannot set %ls\n", var_name16); | |
630 | r = CMD_RET_FAILURE; | |
631 | } | |
59df7e7e AT |
632 | out: |
633 | free(data); | |
634 | efi_free_pool(device_path); | |
635 | efi_free_pool(file_path); | |
636 | free(lo.label); | |
637 | ||
428a470a | 638 | return r; |
59df7e7e AT |
639 | } |
640 | ||
641 | /** | |
642 | * do_efi_boot_rm() - delete UEFI load options | |
643 | * | |
644 | * @cmdtp: Command table | |
645 | * @flag: Command flag | |
646 | * @argc: Number of arguments | |
647 | * @argv: Argument array | |
648 | * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure | |
649 | * | |
650 | * Implement efidebug "boot rm" sub-command. | |
651 | * Delete UEFI load options. | |
0b016569 HS |
652 | * |
653 | * efidebug boot rm <id> ... | |
59df7e7e | 654 | */ |
09140113 SG |
655 | static int do_efi_boot_rm(struct cmd_tbl *cmdtp, int flag, |
656 | int argc, char *const argv[]) | |
59df7e7e AT |
657 | { |
658 | efi_guid_t guid; | |
659 | int id, i; | |
660 | char *endp; | |
661 | char var_name[9]; | |
e8bced62 | 662 | u16 var_name16[9], *p; |
59df7e7e AT |
663 | efi_status_t ret; |
664 | ||
665 | if (argc == 1) | |
666 | return CMD_RET_USAGE; | |
667 | ||
668 | guid = efi_global_variable_guid; | |
669 | for (i = 1; i < argc; i++, argv++) { | |
670 | id = (int)simple_strtoul(argv[1], &endp, 16); | |
671 | if (*endp != '\0' || id > 0xffff) | |
672 | return CMD_RET_FAILURE; | |
673 | ||
674 | sprintf(var_name, "Boot%04X", id); | |
e8bced62 AT |
675 | p = var_name16; |
676 | utf8_utf16_strncpy(&p, var_name, 9); | |
59df7e7e | 677 | |
a30c7231 | 678 | ret = EFI_CALL(efi_set_variable(var_name16, &guid, 0, 0, NULL)); |
59df7e7e | 679 | if (ret) { |
30efb5dd | 680 | printf("Cannot remove %ls\n", var_name16); |
59df7e7e AT |
681 | return CMD_RET_FAILURE; |
682 | } | |
683 | } | |
684 | ||
685 | return CMD_RET_SUCCESS; | |
686 | } | |
687 | ||
688 | /** | |
689 | * show_efi_boot_opt_data() - dump UEFI load option | |
690 | * | |
b5f4e9e3 | 691 | * @varname16: variable name |
39a1ff8c HS |
692 | * @data: value of UEFI load option variable |
693 | * @size: size of the boot option | |
59df7e7e AT |
694 | * |
695 | * Decode the value of UEFI load option variable and print information. | |
696 | */ | |
0e69bcfb | 697 | static void show_efi_boot_opt_data(u16 *varname16, void *data, size_t *size) |
59df7e7e AT |
698 | { |
699 | struct efi_load_option lo; | |
700 | char *label, *p; | |
701 | size_t label_len16, label_len; | |
702 | u16 *dp_str; | |
0e69bcfb | 703 | efi_status_t ret; |
59df7e7e | 704 | |
0e69bcfb HS |
705 | ret = efi_deserialize_load_option(&lo, data, size); |
706 | if (ret != EFI_SUCCESS) { | |
707 | printf("%ls: invalid load option\n", varname16); | |
708 | return; | |
709 | } | |
59df7e7e AT |
710 | |
711 | label_len16 = u16_strlen(lo.label); | |
712 | label_len = utf16_utf8_strnlen(lo.label, label_len16); | |
713 | label = malloc(label_len + 1); | |
714 | if (!label) | |
715 | return; | |
716 | p = label; | |
717 | utf16_utf8_strncpy(&p, lo.label, label_len16); | |
718 | ||
b5f4e9e3 HS |
719 | printf("%ls:\nattributes: %c%c%c (0x%08x)\n", |
720 | varname16, | |
59df7e7e AT |
721 | /* ACTIVE */ |
722 | lo.attributes & LOAD_OPTION_ACTIVE ? 'A' : '-', | |
723 | /* FORCE RECONNECT */ | |
724 | lo.attributes & LOAD_OPTION_FORCE_RECONNECT ? 'R' : '-', | |
725 | /* HIDDEN */ | |
726 | lo.attributes & LOAD_OPTION_HIDDEN ? 'H' : '-', | |
727 | lo.attributes); | |
39a1ff8c | 728 | printf(" label: %s\n", label); |
59df7e7e AT |
729 | |
730 | dp_str = efi_dp_str(lo.file_path); | |
39a1ff8c | 731 | printf(" file_path: %ls\n", dp_str); |
59df7e7e AT |
732 | efi_free_pool(dp_str); |
733 | ||
39a1ff8c HS |
734 | printf(" data:\n"); |
735 | print_hex_dump(" ", DUMP_PREFIX_OFFSET, 16, 1, | |
0e69bcfb | 736 | lo.optional_data, *size, true); |
59df7e7e AT |
737 | free(label); |
738 | } | |
739 | ||
740 | /** | |
741 | * show_efi_boot_opt() - dump UEFI load option | |
742 | * | |
b5f4e9e3 | 743 | * @varname16: variable name |
59df7e7e AT |
744 | * |
745 | * Dump information defined by UEFI load option. | |
746 | */ | |
b5f4e9e3 | 747 | static void show_efi_boot_opt(u16 *varname16) |
59df7e7e | 748 | { |
b5f4e9e3 | 749 | void *data; |
59df7e7e | 750 | efi_uintn_t size; |
0bffb8c4 | 751 | efi_status_t ret; |
59df7e7e | 752 | |
59df7e7e | 753 | size = 0; |
b5f4e9e3 HS |
754 | ret = EFI_CALL(efi_get_variable(varname16, &efi_global_variable_guid, |
755 | NULL, &size, NULL)); | |
0bffb8c4 | 756 | if (ret == EFI_BUFFER_TOO_SMALL) { |
59df7e7e | 757 | data = malloc(size); |
b5f4e9e3 HS |
758 | if (!data) { |
759 | printf("ERROR: Out of memory\n"); | |
760 | return; | |
761 | } | |
762 | ret = EFI_CALL(efi_get_variable(varname16, | |
763 | &efi_global_variable_guid, | |
764 | NULL, &size, data)); | |
765 | if (ret == EFI_SUCCESS) | |
0e69bcfb | 766 | show_efi_boot_opt_data(varname16, data, &size); |
b5f4e9e3 | 767 | free(data); |
59df7e7e | 768 | } |
59df7e7e AT |
769 | } |
770 | ||
ffe21574 AT |
771 | static int u16_tohex(u16 c) |
772 | { | |
773 | if (c >= '0' && c <= '9') | |
774 | return c - '0'; | |
775 | if (c >= 'A' && c <= 'F') | |
776 | return c - 'A' + 10; | |
777 | ||
778 | /* not hexadecimal */ | |
779 | return -1; | |
780 | } | |
781 | ||
59df7e7e AT |
782 | /** |
783 | * show_efi_boot_dump() - dump all UEFI load options | |
784 | * | |
785 | * @cmdtp: Command table | |
786 | * @flag: Command flag | |
787 | * @argc: Number of arguments | |
788 | * @argv: Argument array | |
789 | * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure | |
790 | * | |
791 | * Implement efidebug "boot dump" sub-command. | |
792 | * Dump information of all UEFI load options defined. | |
a6ccba0c HS |
793 | * |
794 | * efidebug boot dump | |
59df7e7e | 795 | */ |
09140113 SG |
796 | static int do_efi_boot_dump(struct cmd_tbl *cmdtp, int flag, |
797 | int argc, char *const argv[]) | |
59df7e7e | 798 | { |
ffe21574 AT |
799 | u16 *var_name16, *p; |
800 | efi_uintn_t buf_size, size; | |
801 | efi_guid_t guid; | |
802 | int id, i, digit; | |
803 | efi_status_t ret; | |
59df7e7e AT |
804 | |
805 | if (argc > 1) | |
806 | return CMD_RET_USAGE; | |
807 | ||
ffe21574 AT |
808 | buf_size = 128; |
809 | var_name16 = malloc(buf_size); | |
810 | if (!var_name16) | |
59df7e7e AT |
811 | return CMD_RET_FAILURE; |
812 | ||
ffe21574 AT |
813 | var_name16[0] = 0; |
814 | for (;;) { | |
815 | size = buf_size; | |
816 | ret = EFI_CALL(efi_get_next_variable_name(&size, var_name16, | |
817 | &guid)); | |
818 | if (ret == EFI_NOT_FOUND) | |
59df7e7e | 819 | break; |
ffe21574 AT |
820 | if (ret == EFI_BUFFER_TOO_SMALL) { |
821 | buf_size = size; | |
822 | p = realloc(var_name16, buf_size); | |
823 | if (!p) { | |
824 | free(var_name16); | |
825 | return CMD_RET_FAILURE; | |
826 | } | |
827 | var_name16 = p; | |
828 | ret = EFI_CALL(efi_get_next_variable_name(&size, | |
829 | var_name16, | |
830 | &guid)); | |
831 | } | |
832 | if (ret != EFI_SUCCESS) { | |
833 | free(var_name16); | |
834 | return CMD_RET_FAILURE; | |
835 | } | |
836 | ||
837 | if (memcmp(var_name16, L"Boot", 8)) | |
838 | continue; | |
839 | ||
840 | for (id = 0, i = 0; i < 4; i++) { | |
841 | digit = u16_tohex(var_name16[4 + i]); | |
842 | if (digit < 0) | |
843 | break; | |
844 | id = (id << 4) + digit; | |
845 | } | |
846 | if (i == 4 && !var_name16[8]) | |
b5f4e9e3 | 847 | show_efi_boot_opt(var_name16); |
59df7e7e | 848 | } |
ffe21574 AT |
849 | |
850 | free(var_name16); | |
59df7e7e AT |
851 | |
852 | return CMD_RET_SUCCESS; | |
853 | } | |
854 | ||
855 | /** | |
856 | * show_efi_boot_order() - show order of UEFI load options | |
857 | * | |
858 | * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure | |
859 | * | |
860 | * Show order of UEFI load options defined by BootOrder variable. | |
861 | */ | |
862 | static int show_efi_boot_order(void) | |
863 | { | |
f9f5f92b | 864 | u16 *bootorder; |
59df7e7e AT |
865 | efi_uintn_t size; |
866 | int num, i; | |
867 | char var_name[9]; | |
868 | u16 var_name16[9], *p16; | |
869 | void *data; | |
870 | struct efi_load_option lo; | |
871 | char *label, *p; | |
872 | size_t label_len16, label_len; | |
873 | efi_status_t ret; | |
874 | ||
59df7e7e | 875 | size = 0; |
a30c7231 | 876 | ret = EFI_CALL(efi_get_variable(L"BootOrder", &efi_global_variable_guid, |
f9f5f92b HS |
877 | NULL, &size, NULL)); |
878 | if (ret != EFI_BUFFER_TOO_SMALL) { | |
879 | if (ret == EFI_NOT_FOUND) { | |
880 | printf("BootOrder not defined\n"); | |
881 | return CMD_RET_SUCCESS; | |
882 | } else { | |
883 | return CMD_RET_FAILURE; | |
884 | } | |
59df7e7e | 885 | } |
f9f5f92b HS |
886 | bootorder = malloc(size); |
887 | if (!bootorder) { | |
888 | printf("ERROR: Out of memory\n"); | |
889 | return CMD_RET_FAILURE; | |
890 | } | |
891 | ret = EFI_CALL(efi_get_variable(L"BootOrder", &efi_global_variable_guid, | |
892 | NULL, &size, bootorder)); | |
893 | if (ret != EFI_SUCCESS) { | |
59df7e7e AT |
894 | ret = CMD_RET_FAILURE; |
895 | goto out; | |
896 | } | |
897 | ||
898 | num = size / sizeof(u16); | |
899 | for (i = 0; i < num; i++) { | |
900 | sprintf(var_name, "Boot%04X", bootorder[i]); | |
901 | p16 = var_name16; | |
902 | utf8_utf16_strncpy(&p16, var_name, 9); | |
903 | ||
904 | size = 0; | |
f9f5f92b HS |
905 | ret = EFI_CALL(efi_get_variable(var_name16, |
906 | &efi_global_variable_guid, NULL, | |
907 | &size, NULL)); | |
59df7e7e | 908 | if (ret != EFI_BUFFER_TOO_SMALL) { |
f9f5f92b | 909 | printf("%2d: %s: (not defined)\n", i + 1, var_name); |
59df7e7e AT |
910 | continue; |
911 | } | |
912 | ||
913 | data = malloc(size); | |
914 | if (!data) { | |
915 | ret = CMD_RET_FAILURE; | |
916 | goto out; | |
917 | } | |
f9f5f92b HS |
918 | ret = EFI_CALL(efi_get_variable(var_name16, |
919 | &efi_global_variable_guid, NULL, | |
920 | &size, data)); | |
59df7e7e AT |
921 | if (ret != EFI_SUCCESS) { |
922 | free(data); | |
923 | ret = CMD_RET_FAILURE; | |
924 | goto out; | |
925 | } | |
926 | ||
0e69bcfb HS |
927 | ret = efi_deserialize_load_option(&lo, data, &size); |
928 | if (ret != EFI_SUCCESS) { | |
929 | printf("%ls: invalid load option\n", var_name16); | |
930 | ret = CMD_RET_FAILURE; | |
931 | goto out; | |
932 | } | |
59df7e7e AT |
933 | |
934 | label_len16 = u16_strlen(lo.label); | |
935 | label_len = utf16_utf8_strnlen(lo.label, label_len16); | |
936 | label = malloc(label_len + 1); | |
937 | if (!label) { | |
938 | free(data); | |
939 | ret = CMD_RET_FAILURE; | |
940 | goto out; | |
941 | } | |
942 | p = label; | |
943 | utf16_utf8_strncpy(&p, lo.label, label_len16); | |
f9f5f92b | 944 | printf("%2d: %s: %s\n", i + 1, var_name, label); |
59df7e7e AT |
945 | free(label); |
946 | ||
947 | free(data); | |
948 | } | |
949 | out: | |
950 | free(bootorder); | |
951 | ||
952 | return ret; | |
953 | } | |
954 | ||
955 | /** | |
956 | * do_efi_boot_next() - manage UEFI BootNext variable | |
957 | * | |
958 | * @cmdtp: Command table | |
959 | * @flag: Command flag | |
960 | * @argc: Number of arguments | |
961 | * @argv: Argument array | |
962 | * Return: CMD_RET_SUCCESS on success, | |
963 | * CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure | |
964 | * | |
965 | * Implement efidebug "boot next" sub-command. | |
966 | * Set BootNext variable. | |
0b016569 HS |
967 | * |
968 | * efidebug boot next <id> | |
59df7e7e | 969 | */ |
09140113 SG |
970 | static int do_efi_boot_next(struct cmd_tbl *cmdtp, int flag, |
971 | int argc, char *const argv[]) | |
59df7e7e AT |
972 | { |
973 | u16 bootnext; | |
974 | efi_uintn_t size; | |
975 | char *endp; | |
976 | efi_guid_t guid; | |
977 | efi_status_t ret; | |
a332f251 | 978 | int r = CMD_RET_SUCCESS; |
59df7e7e AT |
979 | |
980 | if (argc != 2) | |
981 | return CMD_RET_USAGE; | |
982 | ||
983 | bootnext = (u16)simple_strtoul(argv[1], &endp, 16); | |
bdb15776 | 984 | if (*endp) { |
59df7e7e | 985 | printf("invalid value: %s\n", argv[1]); |
428a470a | 986 | r = CMD_RET_FAILURE; |
59df7e7e AT |
987 | goto out; |
988 | } | |
989 | ||
990 | guid = efi_global_variable_guid; | |
991 | size = sizeof(u16); | |
a30c7231 | 992 | ret = EFI_CALL(efi_set_variable(L"BootNext", &guid, |
f658c2e1 | 993 | EFI_VARIABLE_NON_VOLATILE | |
59df7e7e AT |
994 | EFI_VARIABLE_BOOTSERVICE_ACCESS | |
995 | EFI_VARIABLE_RUNTIME_ACCESS, | |
996 | size, &bootnext)); | |
a332f251 HS |
997 | if (ret != EFI_SUCCESS) { |
998 | printf("Cannot set BootNext\n"); | |
999 | r = CMD_RET_FAILURE; | |
1000 | } | |
59df7e7e | 1001 | out: |
428a470a | 1002 | return r; |
59df7e7e AT |
1003 | } |
1004 | ||
1005 | /** | |
1006 | * do_efi_boot_order() - manage UEFI BootOrder variable | |
1007 | * | |
1008 | * @cmdtp: Command table | |
1009 | * @flag: Command flag | |
1010 | * @argc: Number of arguments | |
1011 | * @argv: Argument array | |
1012 | * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure | |
1013 | * | |
1014 | * Implement efidebug "boot order" sub-command. | |
1015 | * Show order of UEFI load options, or change it in BootOrder variable. | |
0b016569 HS |
1016 | * |
1017 | * efidebug boot order [<id> ...] | |
59df7e7e | 1018 | */ |
09140113 SG |
1019 | static int do_efi_boot_order(struct cmd_tbl *cmdtp, int flag, |
1020 | int argc, char *const argv[]) | |
59df7e7e AT |
1021 | { |
1022 | u16 *bootorder = NULL; | |
1023 | efi_uintn_t size; | |
1024 | int id, i; | |
1025 | char *endp; | |
1026 | efi_guid_t guid; | |
1027 | efi_status_t ret; | |
a332f251 | 1028 | int r = CMD_RET_SUCCESS; |
59df7e7e AT |
1029 | |
1030 | if (argc == 1) | |
1031 | return show_efi_boot_order(); | |
1032 | ||
1033 | argc--; | |
1034 | argv++; | |
1035 | ||
1036 | size = argc * sizeof(u16); | |
1037 | bootorder = malloc(size); | |
1038 | if (!bootorder) | |
1039 | return CMD_RET_FAILURE; | |
1040 | ||
1041 | for (i = 0; i < argc; i++) { | |
1042 | id = (int)simple_strtoul(argv[i], &endp, 16); | |
1043 | if (*endp != '\0' || id > 0xffff) { | |
1044 | printf("invalid value: %s\n", argv[i]); | |
428a470a | 1045 | r = CMD_RET_FAILURE; |
59df7e7e AT |
1046 | goto out; |
1047 | } | |
1048 | ||
1049 | bootorder[i] = (u16)id; | |
1050 | } | |
1051 | ||
1052 | guid = efi_global_variable_guid; | |
a30c7231 | 1053 | ret = EFI_CALL(efi_set_variable(L"BootOrder", &guid, |
f658c2e1 | 1054 | EFI_VARIABLE_NON_VOLATILE | |
59df7e7e AT |
1055 | EFI_VARIABLE_BOOTSERVICE_ACCESS | |
1056 | EFI_VARIABLE_RUNTIME_ACCESS, | |
1057 | size, bootorder)); | |
a332f251 HS |
1058 | if (ret != EFI_SUCCESS) { |
1059 | printf("Cannot set BootOrder\n"); | |
1060 | r = CMD_RET_FAILURE; | |
1061 | } | |
59df7e7e AT |
1062 | out: |
1063 | free(bootorder); | |
1064 | ||
428a470a | 1065 | return r; |
59df7e7e AT |
1066 | } |
1067 | ||
09140113 | 1068 | static struct cmd_tbl cmd_efidebug_boot_sub[] = { |
59df7e7e AT |
1069 | U_BOOT_CMD_MKENT(add, CONFIG_SYS_MAXARGS, 1, do_efi_boot_add, "", ""), |
1070 | U_BOOT_CMD_MKENT(rm, CONFIG_SYS_MAXARGS, 1, do_efi_boot_rm, "", ""), | |
1071 | U_BOOT_CMD_MKENT(dump, CONFIG_SYS_MAXARGS, 1, do_efi_boot_dump, "", ""), | |
1072 | U_BOOT_CMD_MKENT(next, CONFIG_SYS_MAXARGS, 1, do_efi_boot_next, "", ""), | |
1073 | U_BOOT_CMD_MKENT(order, CONFIG_SYS_MAXARGS, 1, do_efi_boot_order, | |
1074 | "", ""), | |
1075 | }; | |
1076 | ||
1077 | /** | |
1078 | * do_efi_boot_opt() - manage UEFI load options | |
1079 | * | |
1080 | * @cmdtp: Command table | |
1081 | * @flag: Command flag | |
1082 | * @argc: Number of arguments | |
1083 | * @argv: Argument array | |
1084 | * Return: CMD_RET_SUCCESS on success, | |
1085 | * CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure | |
1086 | * | |
1087 | * Implement efidebug "boot" sub-command. | |
59df7e7e | 1088 | */ |
09140113 SG |
1089 | static int do_efi_boot_opt(struct cmd_tbl *cmdtp, int flag, |
1090 | int argc, char *const argv[]) | |
59df7e7e | 1091 | { |
09140113 | 1092 | struct cmd_tbl *cp; |
59df7e7e AT |
1093 | |
1094 | if (argc < 2) | |
1095 | return CMD_RET_USAGE; | |
1096 | ||
1097 | argc--; argv++; | |
1098 | ||
1099 | cp = find_cmd_tbl(argv[0], cmd_efidebug_boot_sub, | |
1100 | ARRAY_SIZE(cmd_efidebug_boot_sub)); | |
1101 | if (!cp) | |
1102 | return CMD_RET_USAGE; | |
1103 | ||
1104 | return cp->cmd(cmdtp, flag, argc, argv); | |
1105 | } | |
1106 | ||
525fc067 AT |
1107 | /** |
1108 | * do_efi_test_bootmgr() - run simple bootmgr for test | |
1109 | * | |
1110 | * @cmdtp: Command table | |
1111 | * @flag: Command flag | |
1112 | * @argc: Number of arguments | |
1113 | * @argv: Argument array | |
1114 | * Return: CMD_RET_SUCCESS on success, | |
1115 | * CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure | |
1116 | * | |
1117 | * Implement efidebug "test bootmgr" sub-command. | |
1118 | * Run simple bootmgr for test. | |
1119 | * | |
1120 | * efidebug test bootmgr | |
1121 | */ | |
09140113 | 1122 | static int do_efi_test_bootmgr(struct cmd_tbl *cmdtp, int flag, |
525fc067 AT |
1123 | int argc, char * const argv[]) |
1124 | { | |
1125 | efi_handle_t image; | |
1126 | efi_uintn_t exit_data_size = 0; | |
1127 | u16 *exit_data = NULL; | |
1128 | efi_status_t ret; | |
1129 | ||
1130 | ret = efi_bootmgr_load(&image); | |
1131 | printf("efi_bootmgr_load() returned: %ld\n", ret & ~EFI_ERROR_MASK); | |
1132 | ||
1133 | /* We call efi_start_image() even if error for test purpose. */ | |
1134 | ret = EFI_CALL(efi_start_image(image, &exit_data_size, &exit_data)); | |
1135 | printf("efi_start_image() returned: %ld\n", ret & ~EFI_ERROR_MASK); | |
1136 | if (ret && exit_data) | |
1137 | efi_free_pool(exit_data); | |
1138 | ||
1139 | efi_restore_gd(); | |
1140 | ||
1141 | return CMD_RET_SUCCESS; | |
1142 | } | |
1143 | ||
09140113 | 1144 | static struct cmd_tbl cmd_efidebug_test_sub[] = { |
525fc067 AT |
1145 | U_BOOT_CMD_MKENT(bootmgr, CONFIG_SYS_MAXARGS, 1, do_efi_test_bootmgr, |
1146 | "", ""), | |
1147 | }; | |
1148 | ||
1149 | /** | |
1150 | * do_efi_test() - manage UEFI load options | |
1151 | * | |
1152 | * @cmdtp: Command table | |
1153 | * @flag: Command flag | |
1154 | * @argc: Number of arguments | |
1155 | * @argv: Argument array | |
1156 | * Return: CMD_RET_SUCCESS on success, | |
1157 | * CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure | |
1158 | * | |
1159 | * Implement efidebug "test" sub-command. | |
1160 | */ | |
09140113 | 1161 | static int do_efi_test(struct cmd_tbl *cmdtp, int flag, |
525fc067 AT |
1162 | int argc, char * const argv[]) |
1163 | { | |
09140113 | 1164 | struct cmd_tbl *cp; |
525fc067 AT |
1165 | |
1166 | if (argc < 2) | |
1167 | return CMD_RET_USAGE; | |
1168 | ||
1169 | argc--; argv++; | |
1170 | ||
1171 | cp = find_cmd_tbl(argv[0], cmd_efidebug_test_sub, | |
1172 | ARRAY_SIZE(cmd_efidebug_test_sub)); | |
1173 | if (!cp) | |
1174 | return CMD_RET_USAGE; | |
1175 | ||
1176 | return cp->cmd(cmdtp, flag, argc, argv); | |
1177 | } | |
1178 | ||
b0e4f2c7 IA |
1179 | /** |
1180 | * do_efi_query_info() - QueryVariableInfo EFI service | |
1181 | * | |
1182 | * @cmdtp: Command table | |
1183 | * @flag: Command flag | |
1184 | * @argc: Number of arguments | |
1185 | * @argv: Argument array | |
1186 | * Return: CMD_RET_SUCCESS on success, | |
1187 | * CMD_RET_USAGE or CMD_RET_FAILURE on failure | |
1188 | * | |
1189 | * Implement efidebug "test" sub-command. | |
1190 | */ | |
1191 | ||
09140113 | 1192 | static int do_efi_query_info(struct cmd_tbl *cmdtp, int flag, |
b0e4f2c7 IA |
1193 | int argc, char * const argv[]) |
1194 | { | |
1195 | efi_status_t ret; | |
1196 | u32 attr = 0; | |
1197 | u64 max_variable_storage_size; | |
1198 | u64 remain_variable_storage_size; | |
1199 | u64 max_variable_size; | |
1200 | int i; | |
1201 | ||
1202 | for (i = 1; i < argc; i++) { | |
1203 | if (!strcmp(argv[i], "-bs")) | |
1204 | attr |= EFI_VARIABLE_BOOTSERVICE_ACCESS; | |
1205 | else if (!strcmp(argv[i], "-rt")) | |
1206 | attr |= EFI_VARIABLE_RUNTIME_ACCESS; | |
1207 | else if (!strcmp(argv[i], "-nv")) | |
1208 | attr |= EFI_VARIABLE_NON_VOLATILE; | |
1209 | else if (!strcmp(argv[i], "-at")) | |
1210 | attr |= | |
1211 | EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS; | |
1212 | } | |
1213 | ||
1214 | ret = EFI_CALL(efi_query_variable_info(attr, | |
1215 | &max_variable_storage_size, | |
1216 | &remain_variable_storage_size, | |
1217 | &max_variable_size)); | |
1218 | if (ret != EFI_SUCCESS) { | |
1219 | printf("Error: Cannot query UEFI variables, r = %lu\n", | |
1220 | ret & ~EFI_ERROR_MASK); | |
1221 | return CMD_RET_FAILURE; | |
1222 | } | |
1223 | ||
1224 | printf("Max storage size %llu\n", max_variable_storage_size); | |
1225 | printf("Remaining storage size %llu\n", remain_variable_storage_size); | |
1226 | printf("Max variable size %llu\n", max_variable_size); | |
1227 | ||
1228 | return CMD_RET_SUCCESS; | |
1229 | } | |
1230 | ||
09140113 | 1231 | static struct cmd_tbl cmd_efidebug_sub[] = { |
59df7e7e | 1232 | U_BOOT_CMD_MKENT(boot, CONFIG_SYS_MAXARGS, 1, do_efi_boot_opt, "", ""), |
355cdb5a AT |
1233 | U_BOOT_CMD_MKENT(devices, CONFIG_SYS_MAXARGS, 1, do_efi_show_devices, |
1234 | "", ""), | |
66eaf566 AT |
1235 | U_BOOT_CMD_MKENT(drivers, CONFIG_SYS_MAXARGS, 1, do_efi_show_drivers, |
1236 | "", ""), | |
a8014620 AT |
1237 | U_BOOT_CMD_MKENT(dh, CONFIG_SYS_MAXARGS, 1, do_efi_show_handles, |
1238 | "", ""), | |
fa536734 AT |
1239 | U_BOOT_CMD_MKENT(images, CONFIG_SYS_MAXARGS, 1, do_efi_show_images, |
1240 | "", ""), | |
00358bb8 AT |
1241 | U_BOOT_CMD_MKENT(memmap, CONFIG_SYS_MAXARGS, 1, do_efi_show_memmap, |
1242 | "", ""), | |
986e0648 HS |
1243 | U_BOOT_CMD_MKENT(tables, CONFIG_SYS_MAXARGS, 1, do_efi_show_tables, |
1244 | "", ""), | |
525fc067 AT |
1245 | U_BOOT_CMD_MKENT(test, CONFIG_SYS_MAXARGS, 1, do_efi_test, |
1246 | "", ""), | |
b0e4f2c7 IA |
1247 | U_BOOT_CMD_MKENT(query, CONFIG_SYS_MAXARGS, 1, do_efi_query_info, |
1248 | "", ""), | |
59df7e7e AT |
1249 | }; |
1250 | ||
1251 | /** | |
1252 | * do_efidebug() - display and configure UEFI environment | |
1253 | * | |
1254 | * @cmdtp: Command table | |
1255 | * @flag: Command flag | |
1256 | * @argc: Number of arguments | |
1257 | * @argv: Argument array | |
1258 | * Return: CMD_RET_SUCCESS on success, | |
1259 | * CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure | |
1260 | * | |
1261 | * Implement efidebug command which allows us to display and | |
1262 | * configure UEFI environment. | |
59df7e7e | 1263 | */ |
09140113 SG |
1264 | static int do_efidebug(struct cmd_tbl *cmdtp, int flag, |
1265 | int argc, char *const argv[]) | |
59df7e7e | 1266 | { |
09140113 | 1267 | struct cmd_tbl *cp; |
59df7e7e AT |
1268 | efi_status_t r; |
1269 | ||
1270 | if (argc < 2) | |
1271 | return CMD_RET_USAGE; | |
1272 | ||
1273 | argc--; argv++; | |
1274 | ||
1275 | /* Initialize UEFI drivers */ | |
1276 | r = efi_init_obj_list(); | |
1277 | if (r != EFI_SUCCESS) { | |
1278 | printf("Error: Cannot initialize UEFI sub-system, r = %lu\n", | |
1279 | r & ~EFI_ERROR_MASK); | |
1280 | return CMD_RET_FAILURE; | |
1281 | } | |
1282 | ||
1283 | cp = find_cmd_tbl(argv[0], cmd_efidebug_sub, | |
1284 | ARRAY_SIZE(cmd_efidebug_sub)); | |
1285 | if (!cp) | |
1286 | return CMD_RET_USAGE; | |
1287 | ||
1288 | return cp->cmd(cmdtp, flag, argc, argv); | |
1289 | } | |
1290 | ||
1291 | #ifdef CONFIG_SYS_LONGHELP | |
1292 | static char efidebug_help_text[] = | |
1293 | " - UEFI Shell-like interface to configure UEFI environment\n" | |
1294 | "\n" | |
1295 | "efidebug boot add <bootid> <label> <interface> <devnum>[:<part>] <file path> [<load options>]\n" | |
1296 | " - set UEFI BootXXXX variable\n" | |
1297 | " <load options> will be passed to UEFI application\n" | |
1298 | "efidebug boot rm <bootid#1> [<bootid#2> [<bootid#3> [...]]]\n" | |
1299 | " - delete UEFI BootXXXX variables\n" | |
1300 | "efidebug boot dump\n" | |
1301 | " - dump all UEFI BootXXXX variables\n" | |
1302 | "efidebug boot next <bootid>\n" | |
1303 | " - set UEFI BootNext variable\n" | |
1304 | "efidebug boot order [<bootid#1> [<bootid#2> [<bootid#3> [...]]]]\n" | |
1305 | " - set/show UEFI boot order\n" | |
355cdb5a AT |
1306 | "\n" |
1307 | "efidebug devices\n" | |
07e2fe79 | 1308 | " - show UEFI devices\n" |
66eaf566 | 1309 | "efidebug drivers\n" |
07e2fe79 | 1310 | " - show UEFI drivers\n" |
a8014620 | 1311 | "efidebug dh\n" |
07e2fe79 | 1312 | " - show UEFI handles\n" |
fa536734 | 1313 | "efidebug images\n" |
00358bb8 AT |
1314 | " - show loaded images\n" |
1315 | "efidebug memmap\n" | |
07e2fe79 | 1316 | " - show UEFI memory map\n" |
986e0648 | 1317 | "efidebug tables\n" |
525fc067 AT |
1318 | " - show UEFI configuration tables\n" |
1319 | "efidebug test bootmgr\n" | |
b0e4f2c7 IA |
1320 | " - run simple bootmgr for test\n" |
1321 | "efidebug query [-nv][-bs][-rt][-at]\n" | |
1322 | " - show size of UEFI variables store\n"; | |
59df7e7e AT |
1323 | #endif |
1324 | ||
1325 | U_BOOT_CMD( | |
1326 | efidebug, 10, 0, do_efidebug, | |
1327 | "Configure UEFI environment", | |
1328 | efidebug_help_text | |
1329 | ); |