1 // SPDX-License-Identifier: GPL-2.0+
3 * UEFI Shell-like command
5 * Copyright (c) 2018 AKASHI Takahiro, Linaro Limited
11 #include <efi_dt_fixup.h>
12 #include <efi_load_initrd.h>
13 #include <efi_loader.h>
15 #include <efi_variable.h>
23 #include <linux/ctype.h>
24 #include <linux/err.h>
26 #define BS systab.boottime
27 #define RT systab.runtime
29 #ifdef CONFIG_EFI_HAVE_CAPSULE_SUPPORT
31 * do_efi_capsule_update() - process a capsule update
33 * @cmdtp: Command table
35 * @argc: Number of arguments
36 * @argv: Argument array
37 * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
39 * Implement efidebug "capsule update" sub-command.
40 * process a capsule update.
42 * efidebug capsule update [-v] <capsule address>
44 static int do_efi_capsule_update(struct cmd_tbl *cmdtp, int flag,
45 int argc, char * const argv[])
47 struct efi_capsule_header *capsule;
52 if (argc != 2 && argc != 3)
56 if (strcmp(argv[1], "-v"))
64 capsule = (typeof(capsule))hextoul(argv[1], &endp);
65 if (endp == argv[1]) {
66 printf("Invalid address: %s", argv[1]);
67 return CMD_RET_FAILURE;
71 printf("Capsule guid: %pUl\n", &capsule->capsule_guid);
72 printf("Capsule flags: 0x%x\n", capsule->flags);
73 printf("Capsule header size: 0x%x\n", capsule->header_size);
74 printf("Capsule image size: 0x%x\n",
75 capsule->capsule_image_size);
78 ret = EFI_CALL(RT->update_capsule(&capsule, 1, 0));
80 printf("Cannot handle a capsule at %p", capsule);
81 return CMD_RET_FAILURE;
84 return CMD_RET_SUCCESS;
87 static int do_efi_capsule_on_disk_update(struct cmd_tbl *cmdtp, int flag,
88 int argc, char * const argv[])
92 ret = efi_launch_capsules();
94 return ret == EFI_SUCCESS ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
98 * do_efi_capsule_show() - show capsule information
100 * @cmdtp: Command table
101 * @flag: Command flag
102 * @argc: Number of arguments
103 * @argv: Argument array
104 * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
106 * Implement efidebug "capsule show" sub-command.
107 * show capsule information.
109 * efidebug capsule show <capsule address>
111 static int do_efi_capsule_show(struct cmd_tbl *cmdtp, int flag,
112 int argc, char * const argv[])
114 struct efi_capsule_header *capsule;
118 return CMD_RET_USAGE;
120 capsule = (typeof(capsule))hextoul(argv[1], &endp);
121 if (endp == argv[1]) {
122 printf("Invalid address: %s", argv[1]);
123 return CMD_RET_FAILURE;
126 printf("Capsule guid: %pUl\n", &capsule->capsule_guid);
127 printf("Capsule flags: 0x%x\n", capsule->flags);
128 printf("Capsule header size: 0x%x\n", capsule->header_size);
129 printf("Capsule image size: 0x%x\n",
130 capsule->capsule_image_size);
132 return CMD_RET_SUCCESS;
135 #ifdef CONFIG_EFI_ESRT
137 #define EFI_ESRT_FW_TYPE_NUM 4
138 char *efi_fw_type_str[EFI_ESRT_FW_TYPE_NUM] = {"unknown", "system FW", "device FW",
141 #define EFI_ESRT_UPDATE_STATUS_NUM 9
142 char *efi_update_status_str[EFI_ESRT_UPDATE_STATUS_NUM] = {"success", "unsuccessful",
143 "insufficient resources", "incorrect version", "invalid format",
144 "auth error", "power event (AC)", "power event (batt)",
145 "unsatisfied dependencies"};
147 #define EFI_FW_TYPE_STR_GET(idx) (\
148 EFI_ESRT_FW_TYPE_NUM > (idx) ? efi_fw_type_str[(idx)] : "error"\
151 #define EFI_FW_STATUS_STR_GET(idx) (\
152 EFI_ESRT_UPDATE_STATUS_NUM > (idx) ? efi_update_status_str[(idx)] : "error"\
156 * do_efi_capsule_esrt() - manage UEFI capsules
158 * @cmdtp: Command table
159 * @flag: Command flag
160 * @argc: Number of arguments
161 * @argv: Argument array
162 * Return: CMD_RET_SUCCESS on success,
163 * CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure
165 * Implement efidebug "capsule esrt" sub-command.
166 * The prints the current ESRT table.
168 * efidebug capsule esrt
170 static int do_efi_capsule_esrt(struct cmd_tbl *cmdtp, int flag,
171 int argc, char * const argv[])
173 struct efi_system_resource_table *esrt = NULL;
176 return CMD_RET_USAGE;
178 for (int idx = 0; idx < systab.nr_tables; idx++)
179 if (!guidcmp(&efi_esrt_guid, &systab.tables[idx].guid))
180 esrt = (struct efi_system_resource_table *)systab.tables[idx].table;
183 log_info("ESRT: table not present\n");
184 return CMD_RET_SUCCESS;
187 printf("========================================\n");
188 printf("ESRT: fw_resource_count=%d\n", esrt->fw_resource_count);
189 printf("ESRT: fw_resource_count_max=%d\n", esrt->fw_resource_count_max);
190 printf("ESRT: fw_resource_version=%lld\n", esrt->fw_resource_version);
192 for (int idx = 0; idx < esrt->fw_resource_count; idx++) {
193 printf("[entry %d]==============================\n", idx);
194 printf("ESRT: fw_class=%pUL\n", &esrt->entries[idx].fw_class);
195 printf("ESRT: fw_type=%s\n", EFI_FW_TYPE_STR_GET(esrt->entries[idx].fw_type));
196 printf("ESRT: fw_version=%d\n", esrt->entries[idx].fw_version);
197 printf("ESRT: lowest_supported_fw_version=%d\n",
198 esrt->entries[idx].lowest_supported_fw_version);
199 printf("ESRT: capsule_flags=%d\n",
200 esrt->entries[idx].capsule_flags);
201 printf("ESRT: last_attempt_version=%d\n",
202 esrt->entries[idx].last_attempt_version);
203 printf("ESRT: last_attempt_status=%s\n",
204 EFI_FW_STATUS_STR_GET(esrt->entries[idx].last_attempt_status));
206 printf("========================================\n");
208 return CMD_RET_SUCCESS;
210 #endif /* CONFIG_EFI_ESRT */
212 * do_efi_capsule_res() - show a capsule update result
214 * @cmdtp: Command table
215 * @flag: Command flag
216 * @argc: Number of arguments
217 * @argv: Argument array
218 * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
220 * Implement efidebug "capsule result" sub-command.
221 * show a capsule update result.
222 * If result number is not specified, CapsuleLast will be shown.
224 * efidebug capsule result [<capsule result number>]
226 static int do_efi_capsule_res(struct cmd_tbl *cmdtp, int flag,
227 int argc, char * const argv[])
233 struct efi_capsule_result_variable_header *result = NULL;
237 if (argc != 1 && argc != 2)
238 return CMD_RET_USAGE;
240 guid = efi_guid_capsule_report;
242 size = sizeof(var_name16);
243 ret = efi_get_variable_int(u"CapsuleLast", &guid, NULL,
244 &size, var_name16, NULL);
246 if (ret != EFI_SUCCESS) {
247 if (ret == EFI_NOT_FOUND)
248 printf("CapsuleLast doesn't exist\n");
250 printf("Failed to get CapsuleLast\n");
252 return CMD_RET_FAILURE;
254 printf("CapsuleLast is %ls\n", var_name16);
259 capsule_id = hextoul(argv[0], &endp);
260 if (capsule_id < 0 || capsule_id > 0xffff)
261 return CMD_RET_USAGE;
263 efi_create_indexed_name(var_name16, sizeof(var_name16),
264 "Capsule", capsule_id);
268 ret = efi_get_variable_int(var_name16, &guid, NULL, &size, NULL, NULL);
269 if (ret == EFI_BUFFER_TOO_SMALL) {
270 result = malloc(size);
272 return CMD_RET_FAILURE;
273 ret = efi_get_variable_int(var_name16, &guid, NULL, &size,
276 if (ret != EFI_SUCCESS) {
278 printf("Failed to get %ls\n", var_name16);
280 return CMD_RET_FAILURE;
283 printf("Result total size: 0x%x\n", result->variable_total_size);
284 printf("Capsule guid: %pUl\n", &result->capsule_guid);
285 printf("Time processed: %04d-%02d-%02d %02d:%02d:%02d\n",
286 result->capsule_processed.year, result->capsule_processed.month,
287 result->capsule_processed.day, result->capsule_processed.hour,
288 result->capsule_processed.minute,
289 result->capsule_processed.second);
290 printf("Capsule status: 0x%lx\n", result->capsule_status);
294 return CMD_RET_SUCCESS;
297 static struct cmd_tbl cmd_efidebug_capsule_sub[] = {
298 U_BOOT_CMD_MKENT(update, CONFIG_SYS_MAXARGS, 1, do_efi_capsule_update,
300 U_BOOT_CMD_MKENT(show, CONFIG_SYS_MAXARGS, 1, do_efi_capsule_show,
302 #ifdef CONFIG_EFI_ESRT
303 U_BOOT_CMD_MKENT(esrt, CONFIG_SYS_MAXARGS, 1, do_efi_capsule_esrt,
306 U_BOOT_CMD_MKENT(disk-update, 0, 0, do_efi_capsule_on_disk_update,
308 U_BOOT_CMD_MKENT(result, CONFIG_SYS_MAXARGS, 1, do_efi_capsule_res,
313 * do_efi_capsule() - manage UEFI capsules
315 * @cmdtp: Command table
316 * @flag: Command flag
317 * @argc: Number of arguments
318 * @argv: Argument array
319 * Return: CMD_RET_SUCCESS on success,
320 * CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure
322 * Implement efidebug "capsule" sub-command.
324 static int do_efi_capsule(struct cmd_tbl *cmdtp, int flag,
325 int argc, char * const argv[])
330 return CMD_RET_USAGE;
334 cp = find_cmd_tbl(argv[0], cmd_efidebug_capsule_sub,
335 ARRAY_SIZE(cmd_efidebug_capsule_sub));
337 return CMD_RET_USAGE;
339 return cp->cmd(cmdtp, flag, argc, argv);
341 #endif /* CONFIG_EFI_HAVE_CAPSULE_SUPPORT */
344 * efi_get_device_path_text() - get device path text
346 * Return the text representation of the device path of a handle.
348 * @handle: handle of UEFI device
350 * Pointer to the device path text or NULL.
351 * The caller is responsible for calling FreePool().
353 static u16 *efi_get_device_path_text(efi_handle_t handle)
355 struct efi_handler *handler;
358 ret = efi_search_protocol(handle, &efi_guid_device_path, &handler);
359 if (ret == EFI_SUCCESS && handler->protocol_interface) {
360 struct efi_device_path *dp = handler->protocol_interface;
362 return efi_dp_str(dp);
368 #define EFI_HANDLE_WIDTH ((int)sizeof(efi_handle_t) * 2)
370 static const char spc[] = " ";
371 static const char sep[] = "================";
374 * do_efi_show_devices() - show UEFI devices
376 * @cmdtp: Command table
377 * @flag: Command flag
378 * @argc: Number of arguments
379 * @argv: Argument array
380 * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
382 * Implement efidebug "devices" sub-command.
383 * Show all UEFI devices and their information.
385 static int do_efi_show_devices(struct cmd_tbl *cmdtp, int flag,
386 int argc, char *const argv[])
388 efi_handle_t *handles;
393 ret = EFI_CALL(efi_locate_handle_buffer(ALL_HANDLES, NULL, NULL,
395 if (ret != EFI_SUCCESS)
396 return CMD_RET_FAILURE;
399 return CMD_RET_SUCCESS;
401 printf("Device%.*s Device Path\n", EFI_HANDLE_WIDTH - 6, spc);
402 printf("%.*s ====================\n", EFI_HANDLE_WIDTH, sep);
403 for (i = 0; i < num; i++) {
404 dev_path_text = efi_get_device_path_text(handles[i]);
406 printf("%p %ls\n", handles[i], dev_path_text);
407 efi_free_pool(dev_path_text);
411 efi_free_pool(handles);
413 return CMD_RET_SUCCESS;
417 * efi_get_driver_handle_info() - get information of UEFI driver
419 * @handle: Handle of UEFI device
420 * @driver_name: Driver name
421 * @image_path: Pointer to text of device path
422 * Return: 0 on success, -1 on failure
424 * Currently return no useful information as all UEFI drivers are
427 static int efi_get_driver_handle_info(efi_handle_t handle, u16 **driver_name,
430 struct efi_handler *handler;
431 struct efi_loaded_image *image;
436 * TODO: support EFI_COMPONENT_NAME2_PROTOCOL
441 ret = efi_search_protocol(handle, &efi_guid_loaded_image, &handler);
442 if (ret != EFI_SUCCESS) {
447 image = handler->protocol_interface;
448 *image_path = efi_dp_str(image->file_path);
454 * do_efi_show_drivers() - show UEFI drivers
456 * @cmdtp: Command table
457 * @flag: Command flag
458 * @argc: Number of arguments
459 * @argv: Argument array
460 * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
462 * Implement efidebug "drivers" sub-command.
463 * Show all UEFI drivers and their information.
465 static int do_efi_show_drivers(struct cmd_tbl *cmdtp, int flag,
466 int argc, char *const argv[])
468 efi_handle_t *handles;
470 u16 *driver_name, *image_path_text;
473 ret = EFI_CALL(efi_locate_handle_buffer(
474 BY_PROTOCOL, &efi_guid_driver_binding_protocol,
475 NULL, &num, &handles));
476 if (ret != EFI_SUCCESS)
477 return CMD_RET_FAILURE;
480 return CMD_RET_SUCCESS;
482 printf("Driver%.*s Name Image Path\n",
483 EFI_HANDLE_WIDTH - 6, spc);
484 printf("%.*s ==================== ====================\n",
485 EFI_HANDLE_WIDTH, sep);
486 for (i = 0; i < num; i++) {
487 if (!efi_get_driver_handle_info(handles[i], &driver_name,
490 printf("%p %-20ls %ls\n", handles[i],
491 driver_name, image_path_text);
493 printf("%p %-20ls <built-in>\n",
494 handles[i], driver_name);
495 efi_free_pool(driver_name);
496 efi_free_pool(image_path_text);
500 efi_free_pool(handles);
502 return CMD_RET_SUCCESS;
506 * do_efi_show_handles() - show UEFI handles
508 * @cmdtp: Command table
509 * @flag: Command flag
510 * @argc: Number of arguments
511 * @argv: Argument array
512 * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
514 * Implement efidebug "dh" sub-command.
515 * Show all UEFI handles and their information, currently all protocols
518 static int do_efi_show_handles(struct cmd_tbl *cmdtp, int flag,
519 int argc, char *const argv[])
521 efi_handle_t *handles;
523 efi_uintn_t num, count, i, j;
526 ret = EFI_CALL(efi_locate_handle_buffer(ALL_HANDLES, NULL, NULL,
528 if (ret != EFI_SUCCESS)
529 return CMD_RET_FAILURE;
532 return CMD_RET_SUCCESS;
534 printf("Handle%.*s Protocols\n", EFI_HANDLE_WIDTH - 6, spc);
535 printf("%.*s ====================\n", EFI_HANDLE_WIDTH, sep);
536 for (i = 0; i < num; i++) {
537 printf("%p", handles[i]);
538 ret = EFI_CALL(BS->protocols_per_handle(handles[i], &guid,
545 for (j = 0; j < count; j++) {
551 printf("%pUs", guid[j]);
556 efi_free_pool(handles);
558 return CMD_RET_SUCCESS;
562 * do_efi_show_images() - show UEFI images
564 * @cmdtp: Command table
565 * @flag: Command flag
566 * @argc: Number of arguments
567 * @argv: Argument array
568 * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
570 * Implement efidebug "images" sub-command.
571 * Show all UEFI loaded images and their information.
573 static int do_efi_show_images(struct cmd_tbl *cmdtp, int flag,
574 int argc, char *const argv[])
576 efi_print_image_infos(NULL);
578 return CMD_RET_SUCCESS;
581 static const char * const efi_mem_type_string[] = {
582 [EFI_RESERVED_MEMORY_TYPE] = "RESERVED",
583 [EFI_LOADER_CODE] = "LOADER CODE",
584 [EFI_LOADER_DATA] = "LOADER DATA",
585 [EFI_BOOT_SERVICES_CODE] = "BOOT CODE",
586 [EFI_BOOT_SERVICES_DATA] = "BOOT DATA",
587 [EFI_RUNTIME_SERVICES_CODE] = "RUNTIME CODE",
588 [EFI_RUNTIME_SERVICES_DATA] = "RUNTIME DATA",
589 [EFI_CONVENTIONAL_MEMORY] = "CONVENTIONAL",
590 [EFI_UNUSABLE_MEMORY] = "UNUSABLE MEM",
591 [EFI_ACPI_RECLAIM_MEMORY] = "ACPI RECLAIM MEM",
592 [EFI_ACPI_MEMORY_NVS] = "ACPI NVS",
593 [EFI_MMAP_IO] = "IO",
594 [EFI_MMAP_IO_PORT] = "IO PORT",
595 [EFI_PAL_CODE] = "PAL",
596 [EFI_PERSISTENT_MEMORY_TYPE] = "PERSISTENT",
599 static const struct efi_mem_attrs {
602 } efi_mem_attrs[] = {
603 {EFI_MEMORY_UC, "UC"},
604 {EFI_MEMORY_UC, "UC"},
605 {EFI_MEMORY_WC, "WC"},
606 {EFI_MEMORY_WT, "WT"},
607 {EFI_MEMORY_WB, "WB"},
608 {EFI_MEMORY_UCE, "UCE"},
609 {EFI_MEMORY_WP, "WP"},
610 {EFI_MEMORY_RP, "RP"},
611 {EFI_MEMORY_XP, "WP"},
612 {EFI_MEMORY_NV, "NV"},
613 {EFI_MEMORY_MORE_RELIABLE, "REL"},
614 {EFI_MEMORY_RO, "RO"},
615 {EFI_MEMORY_SP, "SP"},
616 {EFI_MEMORY_RUNTIME, "RT"},
620 * print_memory_attributes() - print memory map attributes
622 * @attributes: Attribute value
624 * Print memory map attributes
626 static void print_memory_attributes(u64 attributes)
630 for (sep = 0, i = 0; i < ARRAY_SIZE(efi_mem_attrs); i++)
631 if (attributes & efi_mem_attrs[i].bit) {
638 puts(efi_mem_attrs[i].text);
642 #define EFI_PHYS_ADDR_WIDTH (int)(sizeof(efi_physical_addr_t) * 2)
645 * do_efi_show_memmap() - show UEFI memory map
647 * @cmdtp: Command table
648 * @flag: Command flag
649 * @argc: Number of arguments
650 * @argv: Argument array
651 * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
653 * Implement efidebug "memmap" sub-command.
654 * Show UEFI memory map.
656 static int do_efi_show_memmap(struct cmd_tbl *cmdtp, int flag,
657 int argc, char *const argv[])
659 struct efi_mem_desc *memmap = NULL, *map;
660 efi_uintn_t map_size = 0;
665 ret = efi_get_memory_map(&map_size, memmap, NULL, NULL, NULL);
666 if (ret == EFI_BUFFER_TOO_SMALL) {
667 map_size += sizeof(struct efi_mem_desc); /* for my own */
668 ret = efi_allocate_pool(EFI_LOADER_DATA, map_size,
670 if (ret != EFI_SUCCESS)
671 return CMD_RET_FAILURE;
672 ret = efi_get_memory_map(&map_size, memmap, NULL, NULL, NULL);
674 if (ret != EFI_SUCCESS) {
675 efi_free_pool(memmap);
676 return CMD_RET_FAILURE;
679 printf("Type Start%.*s End%.*s Attributes\n",
680 EFI_PHYS_ADDR_WIDTH - 5, spc, EFI_PHYS_ADDR_WIDTH - 3, spc);
681 printf("================ %.*s %.*s ==========\n",
682 EFI_PHYS_ADDR_WIDTH, sep, EFI_PHYS_ADDR_WIDTH, sep);
684 * Coverity check: dereferencing null pointer "map."
685 * This is a false positive as memmap will always be
686 * populated by allocate_pool() above.
688 for (i = 0, map = memmap; i < map_size / sizeof(*map); map++, i++) {
689 if (map->type < ARRAY_SIZE(efi_mem_type_string))
690 type = efi_mem_type_string[map->type];
694 printf("%-16s %.*llx-%.*llx", type,
696 (u64)map_to_sysmem((void *)(uintptr_t)
697 map->physical_start),
699 (u64)map_to_sysmem((void *)(uintptr_t)
700 (map->physical_start +
701 map->num_pages * EFI_PAGE_SIZE)));
703 print_memory_attributes(map->attribute);
707 efi_free_pool(memmap);
709 return CMD_RET_SUCCESS;
713 * do_efi_show_tables() - show UEFI configuration tables
715 * @cmdtp: Command table
716 * @flag: Command flag
717 * @argc: Number of arguments
718 * @argv: Argument array
719 * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
721 * Implement efidebug "tables" sub-command.
722 * Show UEFI configuration tables.
724 static int do_efi_show_tables(struct cmd_tbl *cmdtp, int flag,
725 int argc, char *const argv[])
729 for (i = 0; i < systab.nr_tables; ++i)
730 printf("%pUl (%pUs)\n",
731 &systab.tables[i].guid, &systab.tables[i].guid);
733 return CMD_RET_SUCCESS;
737 * create_initrd_dp() - create a special device for our Boot### option
740 * @part: disk partition
742 * @shortform: create short form device path
743 * Return: pointer to the device path or ERR_PTR
746 struct efi_device_path *create_initrd_dp(const char *dev, const char *part,
747 const char *file, int shortform)
750 struct efi_device_path *tmp_dp = NULL, *tmp_fp = NULL, *short_fp = NULL;
751 struct efi_device_path *initrd_dp = NULL;
753 const struct efi_initrd_dp id_dp = {
756 DEVICE_PATH_TYPE_MEDIA_DEVICE,
757 DEVICE_PATH_SUB_TYPE_VENDOR_PATH,
758 sizeof(id_dp.vendor),
760 EFI_INITRD_MEDIA_GUID,
763 DEVICE_PATH_TYPE_END,
764 DEVICE_PATH_SUB_TYPE_END,
769 ret = efi_dp_from_name(dev, part, file, &tmp_dp, &tmp_fp);
770 if (ret != EFI_SUCCESS) {
771 printf("Cannot create device path for \"%s %s\"\n", part, file);
775 short_fp = efi_dp_shorten(tmp_fp);
779 initrd_dp = efi_dp_append((const struct efi_device_path *)&id_dp,
783 efi_free_pool(tmp_dp);
784 efi_free_pool(tmp_fp);
789 * do_efi_boot_add() - set UEFI load option
791 * @cmdtp: Command table
792 * @flag: Command flag
793 * @argc: Number of arguments
794 * @argv: Argument array
795 * Return: CMD_RET_SUCCESS on success,
796 * CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure
798 * Implement efidebug "boot add" sub-command. Create or change UEFI load option.
800 * efidebug boot add -b <id> <label> <interface> <devnum>[:<part>] <file>
801 * -i <file> <interface2> <devnum2>[:<part>] <initrd>
804 static int do_efi_boot_add(struct cmd_tbl *cmdtp, int flag,
805 int argc, char *const argv[])
811 size_t label_len, label_len16;
813 struct efi_device_path *file_path = NULL;
814 struct efi_device_path *fp_free = NULL;
815 struct efi_device_path *final_fp = NULL;
816 struct efi_device_path *initrd_dp = NULL;
817 struct efi_load_option lo;
820 efi_uintn_t fp_size = 0;
822 int r = CMD_RET_SUCCESS;
824 guid = efi_global_variable_guid;
827 lo.attributes = LOAD_OPTION_ACTIVE; /* always ACTIVE */
828 lo.optional_data = NULL;
833 for (; argc > 0; argc--, argv++) {
836 if (*argv[0] != '-' || strlen(argv[0]) != 2) {
841 switch (argv[0][1]) {
846 if (argc < 5 || lo.label) {
850 id = (int)hextoul(argv[1], &endp);
851 if (*endp != '\0' || id > 0xffff)
852 return CMD_RET_USAGE;
854 efi_create_indexed_name(var_name16, sizeof(var_name16),
858 label_len = strlen(argv[2]);
859 label_len16 = utf8_utf16_strnlen(argv[2], label_len);
860 label = malloc((label_len16 + 1) * sizeof(u16));
862 return CMD_RET_FAILURE;
863 lo.label = label; /* label will be changed below */
864 utf8_utf16_strncpy(&label, argv[2], label_len);
867 ret = efi_dp_from_name(argv[3], argv[4], argv[5],
869 if (ret != EFI_SUCCESS) {
870 printf("Cannot create device path for \"%s %s\"\n",
876 file_path = efi_dp_shorten(fp_free);
879 fp_size += efi_dp_size(file_path) +
880 sizeof(struct efi_device_path);
888 if (argc < 3 || initrd_dp) {
893 initrd_dp = create_initrd_dp(argv[1], argv[2], argv[3],
896 printf("Cannot add an initrd\n");
902 fp_size += efi_dp_size(initrd_dp) +
903 sizeof(struct efi_device_path);
906 if (argc < 1 || lo.optional_data) {
910 lo.optional_data = (const u8 *)argv[1];
921 printf("Missing binary\n");
926 final_fp = efi_dp_concat(file_path, initrd_dp);
928 printf("Cannot create final device path\n");
933 lo.file_path = final_fp;
934 lo.file_path_length = fp_size;
936 size = efi_serialize_load_option(&lo, (u8 **)&data);
942 ret = efi_set_variable_int(var_name16, &guid,
943 EFI_VARIABLE_NON_VOLATILE |
944 EFI_VARIABLE_BOOTSERVICE_ACCESS |
945 EFI_VARIABLE_RUNTIME_ACCESS,
947 if (ret != EFI_SUCCESS) {
948 printf("Cannot set %ls\n", var_name16);
954 efi_free_pool(final_fp);
955 efi_free_pool(initrd_dp);
956 efi_free_pool(fp_free);
963 * do_efi_boot_rm() - delete UEFI load options
965 * @cmdtp: Command table
966 * @flag: Command flag
967 * @argc: Number of arguments
968 * @argv: Argument array
969 * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
971 * Implement efidebug "boot rm" sub-command.
972 * Delete UEFI load options.
974 * efidebug boot rm <id> ...
976 static int do_efi_boot_rm(struct cmd_tbl *cmdtp, int flag,
977 int argc, char *const argv[])
986 return CMD_RET_USAGE;
988 guid = efi_global_variable_guid;
989 for (i = 1; i < argc; i++, argv++) {
990 id = (int)hextoul(argv[1], &endp);
991 if (*endp != '\0' || id > 0xffff)
992 return CMD_RET_FAILURE;
994 efi_create_indexed_name(var_name16, sizeof(var_name16),
996 ret = efi_set_variable_int(var_name16, &guid, 0, 0, NULL,
999 printf("Cannot remove %ls\n", var_name16);
1000 return CMD_RET_FAILURE;
1004 return CMD_RET_SUCCESS;
1008 * show_efi_boot_opt_data() - dump UEFI load option
1010 * @varname16: variable name
1011 * @data: value of UEFI load option variable
1012 * @size: size of the boot option
1014 * Decode the value of UEFI load option variable and print information.
1016 static void show_efi_boot_opt_data(u16 *varname16, void *data, size_t *size)
1018 struct efi_device_path *initrd_path = NULL;
1019 struct efi_load_option lo;
1022 ret = efi_deserialize_load_option(&lo, data, size);
1023 if (ret != EFI_SUCCESS) {
1024 printf("%ls: invalid load option\n", varname16);
1028 printf("%ls:\nattributes: %c%c%c (0x%08x)\n",
1031 lo.attributes & LOAD_OPTION_ACTIVE ? 'A' : '-',
1032 /* FORCE RECONNECT */
1033 lo.attributes & LOAD_OPTION_FORCE_RECONNECT ? 'R' : '-',
1035 lo.attributes & LOAD_OPTION_HIDDEN ? 'H' : '-',
1037 printf(" label: %ls\n", lo.label);
1039 printf(" file_path: %pD\n", lo.file_path);
1041 initrd_path = efi_dp_from_lo(&lo, &efi_lf2_initrd_guid);
1043 printf(" initrd_path: %pD\n", initrd_path);
1044 efi_free_pool(initrd_path);
1048 print_hex_dump(" ", DUMP_PREFIX_OFFSET, 16, 1,
1049 lo.optional_data, *size, true);
1053 * show_efi_boot_opt() - dump UEFI load option
1055 * @varname16: variable name
1057 * Dump information defined by UEFI load option.
1059 static void show_efi_boot_opt(u16 *varname16)
1066 ret = EFI_CALL(efi_get_variable(varname16, &efi_global_variable_guid,
1067 NULL, &size, NULL));
1068 if (ret == EFI_BUFFER_TOO_SMALL) {
1069 data = malloc(size);
1071 printf("ERROR: Out of memory\n");
1074 ret = EFI_CALL(efi_get_variable(varname16,
1075 &efi_global_variable_guid,
1076 NULL, &size, data));
1077 if (ret == EFI_SUCCESS)
1078 show_efi_boot_opt_data(varname16, data, &size);
1083 static int u16_tohex(u16 c)
1085 if (c >= '0' && c <= '9')
1087 if (c >= 'A' && c <= 'F')
1088 return c - 'A' + 10;
1090 /* not hexadecimal */
1095 * show_efi_boot_dump() - dump all UEFI load options
1097 * @cmdtp: Command table
1098 * @flag: Command flag
1099 * @argc: Number of arguments
1100 * @argv: Argument array
1101 * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
1103 * Implement efidebug "boot dump" sub-command.
1104 * Dump information of all UEFI load options defined.
1106 * efidebug boot dump
1108 static int do_efi_boot_dump(struct cmd_tbl *cmdtp, int flag,
1109 int argc, char *const argv[])
1111 u16 *var_name16, *p;
1112 efi_uintn_t buf_size, size;
1118 return CMD_RET_USAGE;
1121 var_name16 = malloc(buf_size);
1123 return CMD_RET_FAILURE;
1128 ret = EFI_CALL(efi_get_next_variable_name(&size, var_name16,
1130 if (ret == EFI_NOT_FOUND)
1132 if (ret == EFI_BUFFER_TOO_SMALL) {
1134 p = realloc(var_name16, buf_size);
1137 return CMD_RET_FAILURE;
1140 ret = EFI_CALL(efi_get_next_variable_name(&size,
1144 if (ret != EFI_SUCCESS) {
1146 return CMD_RET_FAILURE;
1149 if (memcmp(var_name16, u"Boot", 8))
1152 for (id = 0, i = 0; i < 4; i++) {
1153 digit = u16_tohex(var_name16[4 + i]);
1156 id = (id << 4) + digit;
1158 if (i == 4 && !var_name16[8])
1159 show_efi_boot_opt(var_name16);
1164 return CMD_RET_SUCCESS;
1168 * show_efi_boot_order() - show order of UEFI load options
1170 * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
1172 * Show order of UEFI load options defined by BootOrder variable.
1174 static int show_efi_boot_order(void)
1181 struct efi_load_option lo;
1185 ret = EFI_CALL(efi_get_variable(u"BootOrder", &efi_global_variable_guid,
1186 NULL, &size, NULL));
1187 if (ret != EFI_BUFFER_TOO_SMALL) {
1188 if (ret == EFI_NOT_FOUND) {
1189 printf("BootOrder not defined\n");
1190 return CMD_RET_SUCCESS;
1192 return CMD_RET_FAILURE;
1195 bootorder = malloc(size);
1197 printf("ERROR: Out of memory\n");
1198 return CMD_RET_FAILURE;
1200 ret = EFI_CALL(efi_get_variable(u"BootOrder", &efi_global_variable_guid,
1201 NULL, &size, bootorder));
1202 if (ret != EFI_SUCCESS) {
1203 ret = CMD_RET_FAILURE;
1207 num = size / sizeof(u16);
1208 for (i = 0; i < num; i++) {
1209 efi_create_indexed_name(var_name16, sizeof(var_name16),
1210 "Boot", bootorder[i]);
1213 ret = EFI_CALL(efi_get_variable(var_name16,
1214 &efi_global_variable_guid, NULL,
1216 if (ret != EFI_BUFFER_TOO_SMALL) {
1217 printf("%2d: %ls: (not defined)\n", i + 1, var_name16);
1221 data = malloc(size);
1223 ret = CMD_RET_FAILURE;
1226 ret = EFI_CALL(efi_get_variable(var_name16,
1227 &efi_global_variable_guid, NULL,
1229 if (ret != EFI_SUCCESS) {
1231 ret = CMD_RET_FAILURE;
1235 ret = efi_deserialize_load_option(&lo, data, &size);
1236 if (ret != EFI_SUCCESS) {
1237 printf("%ls: invalid load option\n", var_name16);
1238 ret = CMD_RET_FAILURE;
1242 printf("%2d: %ls: %ls\n", i + 1, var_name16, lo.label);
1253 * do_efi_boot_next() - manage UEFI BootNext variable
1255 * @cmdtp: Command table
1256 * @flag: Command flag
1257 * @argc: Number of arguments
1258 * @argv: Argument array
1259 * Return: CMD_RET_SUCCESS on success,
1260 * CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure
1262 * Implement efidebug "boot next" sub-command.
1263 * Set BootNext variable.
1265 * efidebug boot next <id>
1267 static int do_efi_boot_next(struct cmd_tbl *cmdtp, int flag,
1268 int argc, char *const argv[])
1275 int r = CMD_RET_SUCCESS;
1278 return CMD_RET_USAGE;
1280 bootnext = (u16)hextoul(argv[1], &endp);
1282 printf("invalid value: %s\n", argv[1]);
1283 r = CMD_RET_FAILURE;
1287 guid = efi_global_variable_guid;
1289 ret = efi_set_variable_int(u"BootNext", &guid,
1290 EFI_VARIABLE_NON_VOLATILE |
1291 EFI_VARIABLE_BOOTSERVICE_ACCESS |
1292 EFI_VARIABLE_RUNTIME_ACCESS,
1293 size, &bootnext, false);
1294 if (ret != EFI_SUCCESS) {
1295 printf("Cannot set BootNext\n");
1296 r = CMD_RET_FAILURE;
1303 * do_efi_boot_order() - manage UEFI BootOrder variable
1305 * @cmdtp: Command table
1306 * @flag: Command flag
1307 * @argc: Number of arguments
1308 * @argv: Argument array
1309 * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
1311 * Implement efidebug "boot order" sub-command.
1312 * Show order of UEFI load options, or change it in BootOrder variable.
1314 * efidebug boot order [<id> ...]
1316 static int do_efi_boot_order(struct cmd_tbl *cmdtp, int flag,
1317 int argc, char *const argv[])
1319 u16 *bootorder = NULL;
1325 int r = CMD_RET_SUCCESS;
1328 return show_efi_boot_order();
1333 size = argc * sizeof(u16);
1334 bootorder = malloc(size);
1336 return CMD_RET_FAILURE;
1338 for (i = 0; i < argc; i++) {
1339 id = (int)hextoul(argv[i], &endp);
1340 if (*endp != '\0' || id > 0xffff) {
1341 printf("invalid value: %s\n", argv[i]);
1342 r = CMD_RET_FAILURE;
1346 bootorder[i] = (u16)id;
1349 guid = efi_global_variable_guid;
1350 ret = efi_set_variable_int(u"BootOrder", &guid,
1351 EFI_VARIABLE_NON_VOLATILE |
1352 EFI_VARIABLE_BOOTSERVICE_ACCESS |
1353 EFI_VARIABLE_RUNTIME_ACCESS,
1354 size, bootorder, true);
1355 if (ret != EFI_SUCCESS) {
1356 printf("Cannot set BootOrder\n");
1357 r = CMD_RET_FAILURE;
1365 static struct cmd_tbl cmd_efidebug_boot_sub[] = {
1366 U_BOOT_CMD_MKENT(add, CONFIG_SYS_MAXARGS, 1, do_efi_boot_add, "", ""),
1367 U_BOOT_CMD_MKENT(rm, CONFIG_SYS_MAXARGS, 1, do_efi_boot_rm, "", ""),
1368 U_BOOT_CMD_MKENT(dump, CONFIG_SYS_MAXARGS, 1, do_efi_boot_dump, "", ""),
1369 U_BOOT_CMD_MKENT(next, CONFIG_SYS_MAXARGS, 1, do_efi_boot_next, "", ""),
1370 U_BOOT_CMD_MKENT(order, CONFIG_SYS_MAXARGS, 1, do_efi_boot_order,
1375 * do_efi_boot_opt() - manage UEFI load options
1377 * @cmdtp: Command table
1378 * @flag: Command flag
1379 * @argc: Number of arguments
1380 * @argv: Argument array
1381 * Return: CMD_RET_SUCCESS on success,
1382 * CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure
1384 * Implement efidebug "boot" sub-command.
1386 static int do_efi_boot_opt(struct cmd_tbl *cmdtp, int flag,
1387 int argc, char *const argv[])
1392 return CMD_RET_USAGE;
1396 cp = find_cmd_tbl(argv[0], cmd_efidebug_boot_sub,
1397 ARRAY_SIZE(cmd_efidebug_boot_sub));
1399 return CMD_RET_USAGE;
1401 return cp->cmd(cmdtp, flag, argc, argv);
1405 * do_efi_test_bootmgr() - run simple bootmgr for test
1407 * @cmdtp: Command table
1408 * @flag: Command flag
1409 * @argc: Number of arguments
1410 * @argv: Argument array
1411 * Return: CMD_RET_SUCCESS on success,
1412 * CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure
1414 * Implement efidebug "test bootmgr" sub-command.
1415 * Run simple bootmgr for test.
1417 * efidebug test bootmgr
1419 static __maybe_unused int do_efi_test_bootmgr(struct cmd_tbl *cmdtp, int flag,
1420 int argc, char * const argv[])
1423 efi_uintn_t exit_data_size = 0;
1424 u16 *exit_data = NULL;
1426 void *load_options = NULL;
1428 ret = efi_bootmgr_load(&image, &load_options);
1429 printf("efi_bootmgr_load() returned: %ld\n", ret & ~EFI_ERROR_MASK);
1431 /* We call efi_start_image() even if error for test purpose. */
1432 ret = EFI_CALL(efi_start_image(image, &exit_data_size, &exit_data));
1433 printf("efi_start_image() returned: %ld\n", ret & ~EFI_ERROR_MASK);
1434 if (ret && exit_data)
1435 efi_free_pool(exit_data);
1440 return CMD_RET_SUCCESS;
1443 static struct cmd_tbl cmd_efidebug_test_sub[] = {
1444 #ifdef CONFIG_CMD_BOOTEFI_BOOTMGR
1445 U_BOOT_CMD_MKENT(bootmgr, CONFIG_SYS_MAXARGS, 1, do_efi_test_bootmgr,
1451 * do_efi_test() - manage UEFI load options
1453 * @cmdtp: Command table
1454 * @flag: Command flag
1455 * @argc: Number of arguments
1456 * @argv: Argument array
1457 * Return: CMD_RET_SUCCESS on success,
1458 * CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure
1460 * Implement efidebug "test" sub-command.
1462 static int do_efi_test(struct cmd_tbl *cmdtp, int flag,
1463 int argc, char * const argv[])
1468 return CMD_RET_USAGE;
1472 cp = find_cmd_tbl(argv[0], cmd_efidebug_test_sub,
1473 ARRAY_SIZE(cmd_efidebug_test_sub));
1475 return CMD_RET_USAGE;
1477 return cp->cmd(cmdtp, flag, argc, argv);
1481 * do_efi_query_info() - QueryVariableInfo EFI service
1483 * @cmdtp: Command table
1484 * @flag: Command flag
1485 * @argc: Number of arguments
1486 * @argv: Argument array
1487 * Return: CMD_RET_SUCCESS on success,
1488 * CMD_RET_USAGE or CMD_RET_FAILURE on failure
1490 * Implement efidebug "test" sub-command.
1493 static int do_efi_query_info(struct cmd_tbl *cmdtp, int flag,
1494 int argc, char * const argv[])
1498 u64 max_variable_storage_size;
1499 u64 remain_variable_storage_size;
1500 u64 max_variable_size;
1503 for (i = 1; i < argc; i++) {
1504 if (!strcmp(argv[i], "-bs"))
1505 attr |= EFI_VARIABLE_BOOTSERVICE_ACCESS;
1506 else if (!strcmp(argv[i], "-rt"))
1507 attr |= EFI_VARIABLE_RUNTIME_ACCESS;
1508 else if (!strcmp(argv[i], "-nv"))
1509 attr |= EFI_VARIABLE_NON_VOLATILE;
1510 else if (!strcmp(argv[i], "-at"))
1512 EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS;
1515 ret = EFI_CALL(efi_query_variable_info(attr,
1516 &max_variable_storage_size,
1517 &remain_variable_storage_size,
1518 &max_variable_size));
1519 if (ret != EFI_SUCCESS) {
1520 printf("Error: Cannot query UEFI variables, r = %lu\n",
1521 ret & ~EFI_ERROR_MASK);
1522 return CMD_RET_FAILURE;
1525 printf("Max storage size %llu\n", max_variable_storage_size);
1526 printf("Remaining storage size %llu\n", remain_variable_storage_size);
1527 printf("Max variable size %llu\n", max_variable_size);
1529 return CMD_RET_SUCCESS;
1532 static struct cmd_tbl cmd_efidebug_sub[] = {
1533 U_BOOT_CMD_MKENT(boot, CONFIG_SYS_MAXARGS, 1, do_efi_boot_opt, "", ""),
1534 #ifdef CONFIG_EFI_HAVE_CAPSULE_SUPPORT
1535 U_BOOT_CMD_MKENT(capsule, CONFIG_SYS_MAXARGS, 1, do_efi_capsule,
1538 U_BOOT_CMD_MKENT(devices, CONFIG_SYS_MAXARGS, 1, do_efi_show_devices,
1540 U_BOOT_CMD_MKENT(drivers, CONFIG_SYS_MAXARGS, 1, do_efi_show_drivers,
1542 U_BOOT_CMD_MKENT(dh, CONFIG_SYS_MAXARGS, 1, do_efi_show_handles,
1544 U_BOOT_CMD_MKENT(images, CONFIG_SYS_MAXARGS, 1, do_efi_show_images,
1546 U_BOOT_CMD_MKENT(memmap, CONFIG_SYS_MAXARGS, 1, do_efi_show_memmap,
1548 U_BOOT_CMD_MKENT(tables, CONFIG_SYS_MAXARGS, 1, do_efi_show_tables,
1550 U_BOOT_CMD_MKENT(test, CONFIG_SYS_MAXARGS, 1, do_efi_test,
1552 U_BOOT_CMD_MKENT(query, CONFIG_SYS_MAXARGS, 1, do_efi_query_info,
1557 * do_efidebug() - display and configure UEFI environment
1559 * @cmdtp: Command table
1560 * @flag: Command flag
1561 * @argc: Number of arguments
1562 * @argv: Argument array
1563 * Return: CMD_RET_SUCCESS on success,
1564 * CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure
1566 * Implement efidebug command which allows us to display and
1567 * configure UEFI environment.
1569 static int do_efidebug(struct cmd_tbl *cmdtp, int flag,
1570 int argc, char *const argv[])
1576 return CMD_RET_USAGE;
1580 /* Initialize UEFI drivers */
1581 r = efi_init_obj_list();
1582 if (r != EFI_SUCCESS) {
1583 printf("Error: Cannot initialize UEFI sub-system, r = %lu\n",
1584 r & ~EFI_ERROR_MASK);
1585 return CMD_RET_FAILURE;
1588 cp = find_cmd_tbl(argv[0], cmd_efidebug_sub,
1589 ARRAY_SIZE(cmd_efidebug_sub));
1591 return CMD_RET_USAGE;
1593 return cp->cmd(cmdtp, flag, argc, argv);
1596 #ifdef CONFIG_SYS_LONGHELP
1597 static char efidebug_help_text[] =
1598 " - UEFI Shell-like interface to configure UEFI environment\n"
1600 "efidebug boot add - set UEFI BootXXXX variable\n"
1601 " -b|-B <bootid> <label> <interface> <devnum>[:<part>] <file path>\n"
1602 " -i|-I <interface> <devnum>[:<part>] <initrd file path>\n"
1603 " (-b, -i for short form device path)\n"
1604 " -s '<optional data>'\n"
1605 "efidebug boot rm <bootid#1> [<bootid#2> [<bootid#3> [...]]]\n"
1606 " - delete UEFI BootXXXX variables\n"
1607 "efidebug boot dump\n"
1608 " - dump all UEFI BootXXXX variables\n"
1609 "efidebug boot next <bootid>\n"
1610 " - set UEFI BootNext variable\n"
1611 "efidebug boot order [<bootid#1> [<bootid#2> [<bootid#3> [...]]]]\n"
1612 " - set/show UEFI boot order\n"
1614 #ifdef CONFIG_EFI_HAVE_CAPSULE_SUPPORT
1615 "efidebug capsule update [-v] <capsule address>\n"
1616 " - process a capsule\n"
1617 "efidebug capsule disk-update\n"
1618 " - update a capsule from disk\n"
1619 "efidebug capsule show <capsule address>\n"
1620 " - show capsule information\n"
1621 "efidebug capsule result [<capsule result var>]\n"
1622 " - show a capsule update result\n"
1623 #ifdef CONFIG_EFI_ESRT
1624 "efidebug capsule esrt\n"
1625 " - print the ESRT\n"
1629 "efidebug devices\n"
1630 " - show UEFI devices\n"
1631 "efidebug drivers\n"
1632 " - show UEFI drivers\n"
1634 " - show UEFI handles\n"
1636 " - show loaded images\n"
1638 " - show UEFI memory map\n"
1640 " - show UEFI configuration tables\n"
1641 #ifdef CONFIG_CMD_BOOTEFI_BOOTMGR
1642 "efidebug test bootmgr\n"
1643 " - run simple bootmgr for test\n"
1645 "efidebug query [-nv][-bs][-rt][-at]\n"
1646 " - show size of UEFI variables store\n";
1650 efidebug, CONFIG_SYS_MAXARGS, 0, do_efidebug,
1651 "Configure UEFI environment",