Merge tag 'dm-pull-26jul22' of https://gitlab.denx.de/u-boot/custodians/u-boot-dm.git
[platform/kernel/u-boot.git] / cmd / efidebug.c
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_dt_fixup.h>
12 #include <efi_load_initrd.h>
13 #include <efi_loader.h>
14 #include <efi_rng.h>
15 #include <efi_variable.h>
16 #include <exports.h>
17 #include <hexdump.h>
18 #include <log.h>
19 #include <malloc.h>
20 #include <mapmem.h>
21 #include <part.h>
22 #include <search.h>
23 #include <linux/ctype.h>
24 #include <linux/err.h>
25
26 #define BS systab.boottime
27 #define RT systab.runtime
28
29 #ifdef CONFIG_EFI_HAVE_CAPSULE_SUPPORT
30 /**
31  * do_efi_capsule_update() - process a capsule update
32  *
33  * @cmdtp:      Command table
34  * @flag:       Command flag
35  * @argc:       Number of arguments
36  * @argv:       Argument array
37  * Return:      CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
38  *
39  * Implement efidebug "capsule update" sub-command.
40  * process a capsule update.
41  *
42  *     efidebug capsule update [-v] <capsule address>
43  */
44 static int do_efi_capsule_update(struct cmd_tbl *cmdtp, int flag,
45                                  int argc, char * const argv[])
46 {
47         struct efi_capsule_header *capsule;
48         int verbose = 0;
49         char *endp;
50         efi_status_t ret;
51
52         if (argc != 2 && argc != 3)
53                 return CMD_RET_USAGE;
54
55         if (argc == 3) {
56                 if (strcmp(argv[1], "-v"))
57                         return CMD_RET_USAGE;
58
59                 verbose = 1;
60                 argc--;
61                 argv++;
62         }
63
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;
68         }
69
70         if (verbose) {
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);
76         }
77
78         ret = EFI_CALL(RT->update_capsule(&capsule, 1, 0));
79         if (ret) {
80                 printf("Cannot handle a capsule at %p", capsule);
81                 return CMD_RET_FAILURE;
82         }
83
84         return CMD_RET_SUCCESS;
85 }
86
87 #ifdef CONFIG_EFI_CAPSULE_ON_DISK
88 static int do_efi_capsule_on_disk_update(struct cmd_tbl *cmdtp, int flag,
89                                          int argc, char * const argv[])
90 {
91         efi_status_t ret;
92
93         ret = efi_launch_capsules();
94
95         return ret == EFI_SUCCESS ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
96 }
97 #endif
98
99 /**
100  * do_efi_capsule_show() - show capsule information
101  *
102  * @cmdtp:      Command table
103  * @flag:       Command flag
104  * @argc:       Number of arguments
105  * @argv:       Argument array
106  * Return:      CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
107  *
108  * Implement efidebug "capsule show" sub-command.
109  * show capsule information.
110  *
111  *     efidebug capsule show <capsule address>
112  */
113 static int do_efi_capsule_show(struct cmd_tbl *cmdtp, int flag,
114                                int argc, char * const argv[])
115 {
116         struct efi_capsule_header *capsule;
117         char *endp;
118
119         if (argc != 2)
120                 return CMD_RET_USAGE;
121
122         capsule = (typeof(capsule))hextoul(argv[1], &endp);
123         if (endp == argv[1]) {
124                 printf("Invalid address: %s", argv[1]);
125                 return CMD_RET_FAILURE;
126         }
127
128         printf("Capsule guid: %pUl\n", &capsule->capsule_guid);
129         printf("Capsule flags: 0x%x\n", capsule->flags);
130         printf("Capsule header size: 0x%x\n", capsule->header_size);
131         printf("Capsule image size: 0x%x\n",
132                capsule->capsule_image_size);
133
134         return CMD_RET_SUCCESS;
135 }
136
137 #ifdef CONFIG_EFI_ESRT
138
139 #define EFI_ESRT_FW_TYPE_NUM 4
140 char *efi_fw_type_str[EFI_ESRT_FW_TYPE_NUM] = {"unknown", "system FW", "device FW",
141          "UEFI driver"};
142
143 #define EFI_ESRT_UPDATE_STATUS_NUM 9
144 char *efi_update_status_str[EFI_ESRT_UPDATE_STATUS_NUM] = {"success", "unsuccessful",
145         "insufficient resources", "incorrect version", "invalid format",
146         "auth error", "power event (AC)", "power event (batt)",
147         "unsatisfied dependencies"};
148
149 #define EFI_FW_TYPE_STR_GET(idx) (\
150 EFI_ESRT_FW_TYPE_NUM > (idx) ? efi_fw_type_str[(idx)] : "error"\
151 )
152
153 #define EFI_FW_STATUS_STR_GET(idx) (\
154 EFI_ESRT_UPDATE_STATUS_NUM  > (idx) ? efi_update_status_str[(idx)] : "error"\
155 )
156
157 /**
158  * do_efi_capsule_esrt() - manage UEFI capsules
159  *
160  * @cmdtp:      Command table
161  * @flag:       Command flag
162  * @argc:       Number of arguments
163  * @argv:       Argument array
164  * Return:      CMD_RET_SUCCESS on success,
165  *              CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure
166  *
167  * Implement efidebug "capsule esrt" sub-command.
168  * The prints the current ESRT table.
169  *
170  *     efidebug capsule esrt
171  */
172 static int do_efi_capsule_esrt(struct cmd_tbl *cmdtp, int flag,
173                                int argc, char * const argv[])
174 {
175         struct efi_system_resource_table *esrt = NULL;
176
177         if (argc != 1)
178                 return CMD_RET_USAGE;
179
180         for (int idx = 0; idx < systab.nr_tables; idx++)
181                 if (!guidcmp(&efi_esrt_guid, &systab.tables[idx].guid))
182                         esrt = (struct efi_system_resource_table *)systab.tables[idx].table;
183
184         if (!esrt) {
185                 log_info("ESRT: table not present\n");
186                 return CMD_RET_SUCCESS;
187         }
188
189         printf("========================================\n");
190         printf("ESRT: fw_resource_count=%d\n", esrt->fw_resource_count);
191         printf("ESRT: fw_resource_count_max=%d\n", esrt->fw_resource_count_max);
192         printf("ESRT: fw_resource_version=%lld\n", esrt->fw_resource_version);
193
194         for (int idx = 0; idx < esrt->fw_resource_count; idx++) {
195                 printf("[entry %d]==============================\n", idx);
196                 printf("ESRT: fw_class=%pUL\n", &esrt->entries[idx].fw_class);
197                 printf("ESRT: fw_type=%s\n", EFI_FW_TYPE_STR_GET(esrt->entries[idx].fw_type));
198                 printf("ESRT: fw_version=%d\n", esrt->entries[idx].fw_version);
199                 printf("ESRT: lowest_supported_fw_version=%d\n",
200                        esrt->entries[idx].lowest_supported_fw_version);
201                 printf("ESRT: capsule_flags=%d\n",
202                        esrt->entries[idx].capsule_flags);
203                 printf("ESRT: last_attempt_version=%d\n",
204                        esrt->entries[idx].last_attempt_version);
205                 printf("ESRT: last_attempt_status=%s\n",
206                        EFI_FW_STATUS_STR_GET(esrt->entries[idx].last_attempt_status));
207         }
208         printf("========================================\n");
209
210         return CMD_RET_SUCCESS;
211 }
212 #endif /*  CONFIG_EFI_ESRT */
213 /**
214  * do_efi_capsule_res() - show a capsule update result
215  *
216  * @cmdtp:      Command table
217  * @flag:       Command flag
218  * @argc:       Number of arguments
219  * @argv:       Argument array
220  * Return:      CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
221  *
222  * Implement efidebug "capsule result" sub-command.
223  * show a capsule update result.
224  * If result number is not specified, CapsuleLast will be shown.
225  *
226  *     efidebug capsule result [<capsule result number>]
227  */
228 static int do_efi_capsule_res(struct cmd_tbl *cmdtp, int flag,
229                               int argc, char * const argv[])
230 {
231         int capsule_id;
232         char *endp;
233         u16 var_name16[12];
234         efi_guid_t guid;
235         struct efi_capsule_result_variable_header *result = NULL;
236         efi_uintn_t size;
237         efi_status_t ret;
238
239         if (argc != 1 && argc != 2)
240                 return CMD_RET_USAGE;
241
242         guid = efi_guid_capsule_report;
243         if (argc == 1) {
244                 size = sizeof(var_name16);
245                 ret = efi_get_variable_int(u"CapsuleLast", &guid, NULL,
246                                            &size, var_name16, NULL);
247
248                 if (ret != EFI_SUCCESS) {
249                         if (ret == EFI_NOT_FOUND)
250                                 printf("CapsuleLast doesn't exist\n");
251                         else
252                                 printf("Failed to get CapsuleLast\n");
253
254                         return CMD_RET_FAILURE;
255                 }
256                 printf("CapsuleLast is %ls\n", var_name16);
257         } else {
258                 argc--;
259                 argv++;
260
261                 capsule_id = hextoul(argv[0], &endp);
262                 if (capsule_id < 0 || capsule_id > 0xffff)
263                         return CMD_RET_USAGE;
264
265                 efi_create_indexed_name(var_name16, sizeof(var_name16),
266                                         "Capsule", capsule_id);
267         }
268
269         size = 0;
270         ret = efi_get_variable_int(var_name16, &guid, NULL, &size, NULL, NULL);
271         if (ret == EFI_BUFFER_TOO_SMALL) {
272                 result = malloc(size);
273                 if (!result)
274                         return CMD_RET_FAILURE;
275                 ret = efi_get_variable_int(var_name16, &guid, NULL, &size,
276                                            result, NULL);
277         }
278         if (ret != EFI_SUCCESS) {
279                 free(result);
280                 printf("Failed to get %ls\n", var_name16);
281
282                 return CMD_RET_FAILURE;
283         }
284
285         printf("Result total size: 0x%x\n", result->variable_total_size);
286         printf("Capsule guid: %pUl\n", &result->capsule_guid);
287         printf("Time processed: %04d-%02d-%02d %02d:%02d:%02d\n",
288                result->capsule_processed.year, result->capsule_processed.month,
289                result->capsule_processed.day, result->capsule_processed.hour,
290                result->capsule_processed.minute,
291                result->capsule_processed.second);
292         printf("Capsule status: 0x%lx\n", result->capsule_status);
293
294         free(result);
295
296         return CMD_RET_SUCCESS;
297 }
298
299 static struct cmd_tbl cmd_efidebug_capsule_sub[] = {
300         U_BOOT_CMD_MKENT(update, CONFIG_SYS_MAXARGS, 1, do_efi_capsule_update,
301                          "", ""),
302         U_BOOT_CMD_MKENT(show, CONFIG_SYS_MAXARGS, 1, do_efi_capsule_show,
303                          "", ""),
304 #ifdef CONFIG_EFI_ESRT
305         U_BOOT_CMD_MKENT(esrt, CONFIG_SYS_MAXARGS, 1, do_efi_capsule_esrt,
306                          "", ""),
307 #endif
308 #ifdef CONFIG_EFI_CAPSULE_ON_DISK
309         U_BOOT_CMD_MKENT(disk-update, 0, 0, do_efi_capsule_on_disk_update,
310                          "", ""),
311 #endif
312         U_BOOT_CMD_MKENT(result, CONFIG_SYS_MAXARGS, 1, do_efi_capsule_res,
313                          "", ""),
314 };
315
316 /**
317  * do_efi_capsule() - manage UEFI capsules
318  *
319  * @cmdtp:      Command table
320  * @flag:       Command flag
321  * @argc:       Number of arguments
322  * @argv:       Argument array
323  * Return:      CMD_RET_SUCCESS on success,
324  *              CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure
325  *
326  * Implement efidebug "capsule" sub-command.
327  */
328 static int do_efi_capsule(struct cmd_tbl *cmdtp, int flag,
329                           int argc, char * const argv[])
330 {
331         struct cmd_tbl *cp;
332
333         if (argc < 2)
334                 return CMD_RET_USAGE;
335
336         argc--; argv++;
337
338         cp = find_cmd_tbl(argv[0], cmd_efidebug_capsule_sub,
339                           ARRAY_SIZE(cmd_efidebug_capsule_sub));
340         if (!cp)
341                 return CMD_RET_USAGE;
342
343         return cp->cmd(cmdtp, flag, argc, argv);
344 }
345 #endif /* CONFIG_EFI_HAVE_CAPSULE_SUPPORT */
346
347 /**
348  * efi_get_device_path_text() - get device path text
349  *
350  * Return the text representation of the device path of a handle.
351  *
352  * @handle:     handle of UEFI device
353  * Return:
354  * Pointer to the device path text or NULL.
355  * The caller is responsible for calling FreePool().
356  */
357 static u16 *efi_get_device_path_text(efi_handle_t handle)
358 {
359         struct efi_handler *handler;
360         efi_status_t ret;
361
362         ret = efi_search_protocol(handle, &efi_guid_device_path, &handler);
363         if (ret == EFI_SUCCESS && handler->protocol_interface) {
364                 struct efi_device_path *dp = handler->protocol_interface;
365
366                 return efi_dp_str(dp);
367         } else {
368                 return NULL;
369         }
370 }
371
372 #define EFI_HANDLE_WIDTH ((int)sizeof(efi_handle_t) * 2)
373
374 static const char spc[] = "                ";
375 static const char sep[] = "================";
376
377 /**
378  * do_efi_show_devices() - show UEFI devices
379  *
380  * @cmdtp:      Command table
381  * @flag:       Command flag
382  * @argc:       Number of arguments
383  * @argv:       Argument array
384  * Return:      CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
385  *
386  * Implement efidebug "devices" sub-command.
387  * Show all UEFI devices and their information.
388  */
389 static int do_efi_show_devices(struct cmd_tbl *cmdtp, int flag,
390                                int argc, char *const argv[])
391 {
392         efi_handle_t *handles;
393         efi_uintn_t num, i;
394         u16 *dev_path_text;
395         efi_status_t ret;
396
397         ret = EFI_CALL(efi_locate_handle_buffer(ALL_HANDLES, NULL, NULL,
398                                                 &num, &handles));
399         if (ret != EFI_SUCCESS)
400                 return CMD_RET_FAILURE;
401
402         if (!num)
403                 return CMD_RET_SUCCESS;
404
405         printf("Device%.*s Device Path\n", EFI_HANDLE_WIDTH - 6, spc);
406         printf("%.*s ====================\n", EFI_HANDLE_WIDTH, sep);
407         for (i = 0; i < num; i++) {
408                 dev_path_text = efi_get_device_path_text(handles[i]);
409                 if (dev_path_text) {
410                         printf("%p %ls\n", handles[i], dev_path_text);
411                         efi_free_pool(dev_path_text);
412                 }
413         }
414
415         efi_free_pool(handles);
416
417         return CMD_RET_SUCCESS;
418 }
419
420 /**
421  * efi_get_driver_handle_info() - get information of UEFI driver
422  *
423  * @handle:             Handle of UEFI device
424  * @driver_name:        Driver name
425  * @image_path:         Pointer to text of device path
426  * Return:              0 on success, -1 on failure
427  *
428  * Currently return no useful information as all UEFI drivers are
429  * built-in..
430  */
431 static int efi_get_driver_handle_info(efi_handle_t handle, u16 **driver_name,
432                                       u16 **image_path)
433 {
434         struct efi_handler *handler;
435         struct efi_loaded_image *image;
436         efi_status_t ret;
437
438         /*
439          * driver name
440          * TODO: support EFI_COMPONENT_NAME2_PROTOCOL
441          */
442         *driver_name = NULL;
443
444         /* image name */
445         ret = efi_search_protocol(handle, &efi_guid_loaded_image, &handler);
446         if (ret != EFI_SUCCESS) {
447                 *image_path = NULL;
448                 return 0;
449         }
450
451         image = handler->protocol_interface;
452         *image_path = efi_dp_str(image->file_path);
453
454         return 0;
455 }
456
457 /**
458  * do_efi_show_drivers() - show UEFI drivers
459  *
460  * @cmdtp:      Command table
461  * @flag:       Command flag
462  * @argc:       Number of arguments
463  * @argv:       Argument array
464  * Return:      CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
465  *
466  * Implement efidebug "drivers" sub-command.
467  * Show all UEFI drivers and their information.
468  */
469 static int do_efi_show_drivers(struct cmd_tbl *cmdtp, int flag,
470                                int argc, char *const argv[])
471 {
472         efi_handle_t *handles;
473         efi_uintn_t num, i;
474         u16 *driver_name, *image_path_text;
475         efi_status_t ret;
476
477         ret = EFI_CALL(efi_locate_handle_buffer(
478                                 BY_PROTOCOL, &efi_guid_driver_binding_protocol,
479                                 NULL, &num, &handles));
480         if (ret != EFI_SUCCESS)
481                 return CMD_RET_FAILURE;
482
483         if (!num)
484                 return CMD_RET_SUCCESS;
485
486         printf("Driver%.*s Name                 Image Path\n",
487                EFI_HANDLE_WIDTH - 6, spc);
488         printf("%.*s ==================== ====================\n",
489                EFI_HANDLE_WIDTH, sep);
490         for (i = 0; i < num; i++) {
491                 if (!efi_get_driver_handle_info(handles[i], &driver_name,
492                                                 &image_path_text)) {
493                         if (image_path_text)
494                                 printf("%p %-20ls %ls\n", handles[i],
495                                        driver_name, image_path_text);
496                         else
497                                 printf("%p %-20ls <built-in>\n",
498                                        handles[i], driver_name);
499                         efi_free_pool(driver_name);
500                         efi_free_pool(image_path_text);
501                 }
502         }
503
504         efi_free_pool(handles);
505
506         return CMD_RET_SUCCESS;
507 }
508
509 /**
510  * do_efi_show_handles() - show UEFI handles
511  *
512  * @cmdtp:      Command table
513  * @flag:       Command flag
514  * @argc:       Number of arguments
515  * @argv:       Argument array
516  * Return:      CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
517  *
518  * Implement efidebug "dh" sub-command.
519  * Show all UEFI handles and their information, currently all protocols
520  * added to handle.
521  */
522 static int do_efi_show_handles(struct cmd_tbl *cmdtp, int flag,
523                                int argc, char *const argv[])
524 {
525         efi_handle_t *handles;
526         efi_guid_t **guid;
527         efi_uintn_t num, count, i, j;
528         efi_status_t ret;
529
530         ret = EFI_CALL(efi_locate_handle_buffer(ALL_HANDLES, NULL, NULL,
531                                                 &num, &handles));
532         if (ret != EFI_SUCCESS)
533                 return CMD_RET_FAILURE;
534
535         if (!num)
536                 return CMD_RET_SUCCESS;
537
538         printf("Handle%.*s Protocols\n", EFI_HANDLE_WIDTH - 6, spc);
539         printf("%.*s ====================\n", EFI_HANDLE_WIDTH, sep);
540         for (i = 0; i < num; i++) {
541                 printf("%p", handles[i]);
542                 ret = EFI_CALL(BS->protocols_per_handle(handles[i], &guid,
543                                                         &count));
544                 if (ret || !count) {
545                         putc('\n');
546                         continue;
547                 }
548
549                 for (j = 0; j < count; j++) {
550                         if (j)
551                                 printf(", ");
552                         else
553                                 putc(' ');
554
555                         printf("%pUs", guid[j]);
556                 }
557                 putc('\n');
558         }
559
560         efi_free_pool(handles);
561
562         return CMD_RET_SUCCESS;
563 }
564
565 /**
566  * do_efi_show_images() - show UEFI images
567  *
568  * @cmdtp:      Command table
569  * @flag:       Command flag
570  * @argc:       Number of arguments
571  * @argv:       Argument array
572  * Return:      CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
573  *
574  * Implement efidebug "images" sub-command.
575  * Show all UEFI loaded images and their information.
576  */
577 static int do_efi_show_images(struct cmd_tbl *cmdtp, int flag,
578                               int argc, char *const argv[])
579 {
580         efi_print_image_infos(NULL);
581
582         return CMD_RET_SUCCESS;
583 }
584
585 static const char * const efi_mem_type_string[] = {
586         [EFI_RESERVED_MEMORY_TYPE] = "RESERVED",
587         [EFI_LOADER_CODE] = "LOADER CODE",
588         [EFI_LOADER_DATA] = "LOADER DATA",
589         [EFI_BOOT_SERVICES_CODE] = "BOOT CODE",
590         [EFI_BOOT_SERVICES_DATA] = "BOOT DATA",
591         [EFI_RUNTIME_SERVICES_CODE] = "RUNTIME CODE",
592         [EFI_RUNTIME_SERVICES_DATA] = "RUNTIME DATA",
593         [EFI_CONVENTIONAL_MEMORY] = "CONVENTIONAL",
594         [EFI_UNUSABLE_MEMORY] = "UNUSABLE MEM",
595         [EFI_ACPI_RECLAIM_MEMORY] = "ACPI RECLAIM MEM",
596         [EFI_ACPI_MEMORY_NVS] = "ACPI NVS",
597         [EFI_MMAP_IO] = "IO",
598         [EFI_MMAP_IO_PORT] = "IO PORT",
599         [EFI_PAL_CODE] = "PAL",
600         [EFI_PERSISTENT_MEMORY_TYPE] = "PERSISTENT",
601 };
602
603 static const struct efi_mem_attrs {
604         const u64 bit;
605         const char *text;
606 } efi_mem_attrs[] = {
607         {EFI_MEMORY_UC, "UC"},
608         {EFI_MEMORY_UC, "UC"},
609         {EFI_MEMORY_WC, "WC"},
610         {EFI_MEMORY_WT, "WT"},
611         {EFI_MEMORY_WB, "WB"},
612         {EFI_MEMORY_UCE, "UCE"},
613         {EFI_MEMORY_WP, "WP"},
614         {EFI_MEMORY_RP, "RP"},
615         {EFI_MEMORY_XP, "WP"},
616         {EFI_MEMORY_NV, "NV"},
617         {EFI_MEMORY_MORE_RELIABLE, "REL"},
618         {EFI_MEMORY_RO, "RO"},
619         {EFI_MEMORY_SP, "SP"},
620         {EFI_MEMORY_RUNTIME, "RT"},
621 };
622
623 /**
624  * print_memory_attributes() - print memory map attributes
625  *
626  * @attributes: Attribute value
627  *
628  * Print memory map attributes
629  */
630 static void print_memory_attributes(u64 attributes)
631 {
632         int sep, i;
633
634         for (sep = 0, i = 0; i < ARRAY_SIZE(efi_mem_attrs); i++)
635                 if (attributes & efi_mem_attrs[i].bit) {
636                         if (sep) {
637                                 putc('|');
638                         } else {
639                                 putc(' ');
640                                 sep = 1;
641                         }
642                         puts(efi_mem_attrs[i].text);
643                 }
644 }
645
646 #define EFI_PHYS_ADDR_WIDTH (int)(sizeof(efi_physical_addr_t) * 2)
647
648 /**
649  * do_efi_show_memmap() - show UEFI memory map
650  *
651  * @cmdtp:      Command table
652  * @flag:       Command flag
653  * @argc:       Number of arguments
654  * @argv:       Argument array
655  * Return:      CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
656  *
657  * Implement efidebug "memmap" sub-command.
658  * Show UEFI memory map.
659  */
660 static int do_efi_show_memmap(struct cmd_tbl *cmdtp, int flag,
661                               int argc, char *const argv[])
662 {
663         struct efi_mem_desc *memmap = NULL, *map;
664         efi_uintn_t map_size = 0;
665         const char *type;
666         int i;
667         efi_status_t ret;
668
669         ret = efi_get_memory_map(&map_size, memmap, NULL, NULL, NULL);
670         if (ret == EFI_BUFFER_TOO_SMALL) {
671                 map_size += sizeof(struct efi_mem_desc); /* for my own */
672                 ret = efi_allocate_pool(EFI_LOADER_DATA, map_size,
673                                         (void *)&memmap);
674                 if (ret != EFI_SUCCESS)
675                         return CMD_RET_FAILURE;
676                 ret = efi_get_memory_map(&map_size, memmap, NULL, NULL, NULL);
677         }
678         if (ret != EFI_SUCCESS) {
679                 efi_free_pool(memmap);
680                 return CMD_RET_FAILURE;
681         }
682
683         printf("Type             Start%.*s End%.*s Attributes\n",
684                EFI_PHYS_ADDR_WIDTH - 5, spc, EFI_PHYS_ADDR_WIDTH - 3, spc);
685         printf("================ %.*s %.*s ==========\n",
686                EFI_PHYS_ADDR_WIDTH, sep, EFI_PHYS_ADDR_WIDTH, sep);
687         /*
688          * Coverity check: dereferencing null pointer "map."
689          * This is a false positive as memmap will always be
690          * populated by allocate_pool() above.
691          */
692         for (i = 0, map = memmap; i < map_size / sizeof(*map); map++, i++) {
693                 if (map->type < ARRAY_SIZE(efi_mem_type_string))
694                         type = efi_mem_type_string[map->type];
695                 else
696                         type = "(unknown)";
697
698                 printf("%-16s %.*llx-%.*llx", type,
699                        EFI_PHYS_ADDR_WIDTH,
700                        (u64)map_to_sysmem((void *)(uintptr_t)
701                                           map->physical_start),
702                        EFI_PHYS_ADDR_WIDTH,
703                        (u64)map_to_sysmem((void *)(uintptr_t)
704                                           (map->physical_start +
705                                            map->num_pages * EFI_PAGE_SIZE)));
706
707                 print_memory_attributes(map->attribute);
708                 putc('\n');
709         }
710
711         efi_free_pool(memmap);
712
713         return CMD_RET_SUCCESS;
714 }
715
716 /**
717  * do_efi_show_tables() - show UEFI configuration tables
718  *
719  * @cmdtp:      Command table
720  * @flag:       Command flag
721  * @argc:       Number of arguments
722  * @argv:       Argument array
723  * Return:      CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
724  *
725  * Implement efidebug "tables" sub-command.
726  * Show UEFI configuration tables.
727  */
728 static int do_efi_show_tables(struct cmd_tbl *cmdtp, int flag,
729                               int argc, char *const argv[])
730 {
731         efi_uintn_t i;
732
733         for (i = 0; i < systab.nr_tables; ++i)
734                 printf("%pUl (%pUs)\n",
735                        &systab.tables[i].guid, &systab.tables[i].guid);
736
737         return CMD_RET_SUCCESS;
738 }
739
740 /**
741  * create_initrd_dp() - create a special device for our Boot### option
742  *
743  * @dev:        device
744  * @part:       disk partition
745  * @file:       filename
746  * @shortform:  create short form device path
747  * Return:      pointer to the device path or ERR_PTR
748  */
749 static
750 struct efi_device_path *create_initrd_dp(const char *dev, const char *part,
751                                          const char *file, int shortform)
752
753 {
754         struct efi_device_path *tmp_dp = NULL, *tmp_fp = NULL, *short_fp = NULL;
755         struct efi_device_path *initrd_dp = NULL;
756         efi_status_t ret;
757         const struct efi_initrd_dp id_dp = {
758                 .vendor = {
759                         {
760                         DEVICE_PATH_TYPE_MEDIA_DEVICE,
761                         DEVICE_PATH_SUB_TYPE_VENDOR_PATH,
762                         sizeof(id_dp.vendor),
763                         },
764                         EFI_INITRD_MEDIA_GUID,
765                 },
766                 .end = {
767                         DEVICE_PATH_TYPE_END,
768                         DEVICE_PATH_SUB_TYPE_END,
769                         sizeof(id_dp.end),
770                 }
771         };
772
773         ret = efi_dp_from_name(dev, part, file, &tmp_dp, &tmp_fp);
774         if (ret != EFI_SUCCESS) {
775                 printf("Cannot create device path for \"%s %s\"\n", part, file);
776                 goto out;
777         }
778         if (shortform)
779                 short_fp = efi_dp_shorten(tmp_fp);
780         if (!short_fp)
781                 short_fp = tmp_fp;
782
783         initrd_dp = efi_dp_append((const struct efi_device_path *)&id_dp,
784                                   short_fp);
785
786 out:
787         efi_free_pool(tmp_dp);
788         efi_free_pool(tmp_fp);
789         return initrd_dp;
790 }
791
792 /**
793  * do_efi_boot_add() - set UEFI load option
794  *
795  * @cmdtp:      Command table
796  * @flag:       Command flag
797  * @argc:       Number of arguments
798  * @argv:       Argument array
799  * Return:      CMD_RET_SUCCESS on success,
800  *              CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure
801  *
802  * Implement efidebug "boot add" sub-command. Create or change UEFI load option.
803  *
804  * efidebug boot add -b <id> <label> <interface> <devnum>[:<part>] <file>
805  *                   -i <file> <interface2> <devnum2>[:<part>] <initrd>
806  *                   -s '<options>'
807  */
808 static int do_efi_boot_add(struct cmd_tbl *cmdtp, int flag,
809                            int argc, char *const argv[])
810 {
811         int id;
812         char *endp;
813         u16 var_name16[9];
814         efi_guid_t guid;
815         size_t label_len, label_len16;
816         u16 *label;
817         struct efi_device_path *file_path = NULL;
818         struct efi_device_path *fp_free = NULL;
819         struct efi_device_path *final_fp = NULL;
820         struct efi_device_path *initrd_dp = NULL;
821         struct efi_load_option lo;
822         void *data = NULL;
823         efi_uintn_t size;
824         efi_uintn_t fp_size = 0;
825         efi_status_t ret;
826         int r = CMD_RET_SUCCESS;
827
828         guid = efi_global_variable_guid;
829
830         /* attributes */
831         lo.attributes = LOAD_OPTION_ACTIVE; /* always ACTIVE */
832         lo.optional_data = NULL;
833         lo.label = NULL;
834
835         argc--;
836         argv++; /* 'add' */
837         for (; argc > 0; argc--, argv++) {
838                 int shortform;
839
840                 if (*argv[0] != '-' || strlen(argv[0]) != 2) {
841                                 r = CMD_RET_USAGE;
842                                 goto out;
843                 }
844                 shortform = 0;
845                 switch (argv[0][1]) {
846                 case 'b':
847                         shortform = 1;
848                         /* fallthrough */
849                 case 'B':
850                         if (argc <  5 || lo.label) {
851                                 r = CMD_RET_USAGE;
852                                 goto out;
853                         }
854                         id = (int)hextoul(argv[1], &endp);
855                         if (*endp != '\0' || id > 0xffff)
856                                 return CMD_RET_USAGE;
857
858                         efi_create_indexed_name(var_name16, sizeof(var_name16),
859                                                 "Boot", id);
860
861                         /* label */
862                         label_len = strlen(argv[2]);
863                         label_len16 = utf8_utf16_strnlen(argv[2], label_len);
864                         label = malloc((label_len16 + 1) * sizeof(u16));
865                         if (!label)
866                                 return CMD_RET_FAILURE;
867                         lo.label = label; /* label will be changed below */
868                         utf8_utf16_strncpy(&label, argv[2], label_len);
869
870                         /* file path */
871                         ret = efi_dp_from_name(argv[3], argv[4], argv[5],
872                                                NULL, &fp_free);
873                         if (ret != EFI_SUCCESS) {
874                                 printf("Cannot create device path for \"%s %s\"\n",
875                                        argv[3], argv[4]);
876                                 r = CMD_RET_FAILURE;
877                                 goto out;
878                         }
879                         if (shortform)
880                                 file_path = efi_dp_shorten(fp_free);
881                         if (!file_path)
882                                 file_path = fp_free;
883                         fp_size += efi_dp_size(file_path) +
884                                 sizeof(struct efi_device_path);
885                         argc -= 5;
886                         argv += 5;
887                         break;
888                 case 'i':
889                         shortform = 1;
890                         /* fallthrough */
891                 case 'I':
892                         if (argc < 3 || initrd_dp) {
893                                 r = CMD_RET_USAGE;
894                                 goto out;
895                         }
896
897                         initrd_dp = create_initrd_dp(argv[1], argv[2], argv[3],
898                                                      shortform);
899                         if (!initrd_dp) {
900                                 printf("Cannot add an initrd\n");
901                                 r = CMD_RET_FAILURE;
902                                 goto out;
903                         }
904                         argc -= 3;
905                         argv += 3;
906                         fp_size += efi_dp_size(initrd_dp) +
907                                 sizeof(struct efi_device_path);
908                         break;
909                 case 's':
910                         if (argc < 1 || lo.optional_data) {
911                                 r = CMD_RET_USAGE;
912                                 goto out;
913                         }
914                         lo.optional_data = (const u8 *)argv[1];
915                         argc -= 1;
916                         argv += 1;
917                         break;
918                 default:
919                         r = CMD_RET_USAGE;
920                         goto out;
921                 }
922         }
923
924         if (!file_path) {
925                 printf("Missing binary\n");
926                 r = CMD_RET_USAGE;
927                 goto out;
928         }
929
930         final_fp = efi_dp_concat(file_path, initrd_dp);
931         if (!final_fp) {
932                 printf("Cannot create final device path\n");
933                 r = CMD_RET_FAILURE;
934                 goto out;
935         }
936
937         lo.file_path = final_fp;
938         lo.file_path_length = fp_size;
939
940         size = efi_serialize_load_option(&lo, (u8 **)&data);
941         if (!size) {
942                 r = CMD_RET_FAILURE;
943                 goto out;
944         }
945
946         ret = efi_set_variable_int(var_name16, &guid,
947                                    EFI_VARIABLE_NON_VOLATILE |
948                                    EFI_VARIABLE_BOOTSERVICE_ACCESS |
949                                    EFI_VARIABLE_RUNTIME_ACCESS,
950                                    size, data, false);
951         if (ret != EFI_SUCCESS) {
952                 printf("Cannot set %ls\n", var_name16);
953                 r = CMD_RET_FAILURE;
954         }
955
956 out:
957         free(data);
958         efi_free_pool(final_fp);
959         efi_free_pool(initrd_dp);
960         efi_free_pool(fp_free);
961         free(lo.label);
962
963         return r;
964 }
965
966 /**
967  * do_efi_boot_rm() - delete UEFI load options
968  *
969  * @cmdtp:      Command table
970  * @flag:       Command flag
971  * @argc:       Number of arguments
972  * @argv:       Argument array
973  * Return:      CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
974  *
975  * Implement efidebug "boot rm" sub-command.
976  * Delete UEFI load options.
977  *
978  *     efidebug boot rm <id> ...
979  */
980 static int do_efi_boot_rm(struct cmd_tbl *cmdtp, int flag,
981                           int argc, char *const argv[])
982 {
983         efi_guid_t guid;
984         int id, i;
985         char *endp;
986         u16 var_name16[9];
987         efi_status_t ret;
988
989         if (argc == 1)
990                 return CMD_RET_USAGE;
991
992         guid = efi_global_variable_guid;
993         for (i = 1; i < argc; i++, argv++) {
994                 id = (int)hextoul(argv[1], &endp);
995                 if (*endp != '\0' || id > 0xffff)
996                         return CMD_RET_FAILURE;
997
998                 efi_create_indexed_name(var_name16, sizeof(var_name16),
999                                         "Boot", id);
1000                 ret = efi_set_variable_int(var_name16, &guid, 0, 0, NULL,
1001                                            false);
1002                 if (ret) {
1003                         printf("Cannot remove %ls\n", var_name16);
1004                         return CMD_RET_FAILURE;
1005                 }
1006         }
1007
1008         return CMD_RET_SUCCESS;
1009 }
1010
1011 /**
1012  * show_efi_boot_opt_data() - dump UEFI load option
1013  *
1014  * @varname16:  variable name
1015  * @data:       value of UEFI load option variable
1016  * @size:       size of the boot option
1017  *
1018  * Decode the value of UEFI load option variable and print information.
1019  */
1020 static void show_efi_boot_opt_data(u16 *varname16, void *data, size_t *size)
1021 {
1022         struct efi_device_path *initrd_path = NULL;
1023         struct efi_load_option lo;
1024         efi_status_t ret;
1025
1026         ret = efi_deserialize_load_option(&lo, data, size);
1027         if (ret != EFI_SUCCESS) {
1028                 printf("%ls: invalid load option\n", varname16);
1029                 return;
1030         }
1031
1032         printf("%ls:\nattributes: %c%c%c (0x%08x)\n",
1033                varname16,
1034                /* ACTIVE */
1035                lo.attributes & LOAD_OPTION_ACTIVE ? 'A' : '-',
1036                /* FORCE RECONNECT */
1037                lo.attributes & LOAD_OPTION_FORCE_RECONNECT ? 'R' : '-',
1038                /* HIDDEN */
1039                lo.attributes & LOAD_OPTION_HIDDEN ? 'H' : '-',
1040                lo.attributes);
1041         printf("  label: %ls\n", lo.label);
1042
1043         printf("  file_path: %pD\n", lo.file_path);
1044
1045         initrd_path = efi_dp_from_lo(&lo, &efi_lf2_initrd_guid);
1046         if (initrd_path) {
1047                 printf("  initrd_path: %pD\n", initrd_path);
1048                 efi_free_pool(initrd_path);
1049         }
1050
1051         printf("  data:\n");
1052         print_hex_dump("    ", DUMP_PREFIX_OFFSET, 16, 1,
1053                        lo.optional_data, *size, true);
1054 }
1055
1056 /**
1057  * show_efi_boot_opt() - dump UEFI load option
1058  *
1059  * @varname16:  variable name
1060  *
1061  * Dump information defined by UEFI load option.
1062  */
1063 static void show_efi_boot_opt(u16 *varname16)
1064 {
1065         void *data;
1066         efi_uintn_t size;
1067         efi_status_t ret;
1068
1069         size = 0;
1070         ret = EFI_CALL(efi_get_variable(varname16, &efi_global_variable_guid,
1071                                         NULL, &size, NULL));
1072         if (ret == EFI_BUFFER_TOO_SMALL) {
1073                 data = malloc(size);
1074                 if (!data) {
1075                         printf("ERROR: Out of memory\n");
1076                         return;
1077                 }
1078                 ret = EFI_CALL(efi_get_variable(varname16,
1079                                                 &efi_global_variable_guid,
1080                                                 NULL, &size, data));
1081                 if (ret == EFI_SUCCESS)
1082                         show_efi_boot_opt_data(varname16, data, &size);
1083                 free(data);
1084         }
1085 }
1086
1087 static int u16_tohex(u16 c)
1088 {
1089         if (c >= '0' && c <= '9')
1090                 return c - '0';
1091         if (c >= 'A' && c <= 'F')
1092                 return c - 'A' + 10;
1093
1094         /* not hexadecimal */
1095         return -1;
1096 }
1097
1098 /**
1099  * show_efi_boot_dump() - dump all UEFI load options
1100  *
1101  * @cmdtp:      Command table
1102  * @flag:       Command flag
1103  * @argc:       Number of arguments
1104  * @argv:       Argument array
1105  * Return:      CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
1106  *
1107  * Implement efidebug "boot dump" sub-command.
1108  * Dump information of all UEFI load options defined.
1109  *
1110  *     efidebug boot dump
1111  */
1112 static int do_efi_boot_dump(struct cmd_tbl *cmdtp, int flag,
1113                             int argc, char *const argv[])
1114 {
1115         u16 *var_name16, *p;
1116         efi_uintn_t buf_size, size;
1117         efi_guid_t guid;
1118         int id, i, digit;
1119         efi_status_t ret;
1120
1121         if (argc > 1)
1122                 return CMD_RET_USAGE;
1123
1124         buf_size = 128;
1125         var_name16 = malloc(buf_size);
1126         if (!var_name16)
1127                 return CMD_RET_FAILURE;
1128
1129         var_name16[0] = 0;
1130         for (;;) {
1131                 size = buf_size;
1132                 ret = EFI_CALL(efi_get_next_variable_name(&size, var_name16,
1133                                                           &guid));
1134                 if (ret == EFI_NOT_FOUND)
1135                         break;
1136                 if (ret == EFI_BUFFER_TOO_SMALL) {
1137                         buf_size = size;
1138                         p = realloc(var_name16, buf_size);
1139                         if (!p) {
1140                                 free(var_name16);
1141                                 return CMD_RET_FAILURE;
1142                         }
1143                         var_name16 = p;
1144                         ret = EFI_CALL(efi_get_next_variable_name(&size,
1145                                                                   var_name16,
1146                                                                   &guid));
1147                 }
1148                 if (ret != EFI_SUCCESS) {
1149                         free(var_name16);
1150                         return CMD_RET_FAILURE;
1151                 }
1152
1153                 if (memcmp(var_name16, u"Boot", 8))
1154                         continue;
1155
1156                 for (id = 0, i = 0; i < 4; i++) {
1157                         digit = u16_tohex(var_name16[4 + i]);
1158                         if (digit < 0)
1159                                 break;
1160                         id = (id << 4) + digit;
1161                 }
1162                 if (i == 4 && !var_name16[8])
1163                         show_efi_boot_opt(var_name16);
1164         }
1165
1166         free(var_name16);
1167
1168         return CMD_RET_SUCCESS;
1169 }
1170
1171 /**
1172  * show_efi_boot_order() - show order of UEFI load options
1173  *
1174  * Return:      CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
1175  *
1176  * Show order of UEFI load options defined by BootOrder variable.
1177  */
1178 static int show_efi_boot_order(void)
1179 {
1180         u16 *bootorder;
1181         efi_uintn_t size;
1182         int num, i;
1183         u16 var_name16[9];
1184         void *data;
1185         struct efi_load_option lo;
1186         efi_status_t ret;
1187
1188         size = 0;
1189         ret = EFI_CALL(efi_get_variable(u"BootOrder", &efi_global_variable_guid,
1190                                         NULL, &size, NULL));
1191         if (ret != EFI_BUFFER_TOO_SMALL) {
1192                 if (ret == EFI_NOT_FOUND) {
1193                         printf("BootOrder not defined\n");
1194                         return CMD_RET_SUCCESS;
1195                 } else {
1196                         return CMD_RET_FAILURE;
1197                 }
1198         }
1199         bootorder = malloc(size);
1200         if (!bootorder) {
1201                 printf("ERROR: Out of memory\n");
1202                 return CMD_RET_FAILURE;
1203         }
1204         ret = EFI_CALL(efi_get_variable(u"BootOrder", &efi_global_variable_guid,
1205                                         NULL, &size, bootorder));
1206         if (ret != EFI_SUCCESS) {
1207                 ret = CMD_RET_FAILURE;
1208                 goto out;
1209         }
1210
1211         num = size / sizeof(u16);
1212         for (i = 0; i < num; i++) {
1213                 efi_create_indexed_name(var_name16, sizeof(var_name16),
1214                                         "Boot", bootorder[i]);
1215
1216                 size = 0;
1217                 ret = EFI_CALL(efi_get_variable(var_name16,
1218                                                 &efi_global_variable_guid, NULL,
1219                                                 &size, NULL));
1220                 if (ret != EFI_BUFFER_TOO_SMALL) {
1221                         printf("%2d: %ls: (not defined)\n", i + 1, var_name16);
1222                         continue;
1223                 }
1224
1225                 data = malloc(size);
1226                 if (!data) {
1227                         ret = CMD_RET_FAILURE;
1228                         goto out;
1229                 }
1230                 ret = EFI_CALL(efi_get_variable(var_name16,
1231                                                 &efi_global_variable_guid, NULL,
1232                                                 &size, data));
1233                 if (ret != EFI_SUCCESS) {
1234                         free(data);
1235                         ret = CMD_RET_FAILURE;
1236                         goto out;
1237                 }
1238
1239                 ret = efi_deserialize_load_option(&lo, data, &size);
1240                 if (ret != EFI_SUCCESS) {
1241                         printf("%ls: invalid load option\n", var_name16);
1242                         ret = CMD_RET_FAILURE;
1243                         goto out;
1244                 }
1245
1246                 printf("%2d: %ls: %ls\n", i + 1, var_name16, lo.label);
1247
1248                 free(data);
1249         }
1250 out:
1251         free(bootorder);
1252
1253         return ret;
1254 }
1255
1256 /**
1257  * do_efi_boot_next() - manage UEFI BootNext variable
1258  *
1259  * @cmdtp:      Command table
1260  * @flag:       Command flag
1261  * @argc:       Number of arguments
1262  * @argv:       Argument array
1263  * Return:      CMD_RET_SUCCESS on success,
1264  *              CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure
1265  *
1266  * Implement efidebug "boot next" sub-command.
1267  * Set BootNext variable.
1268  *
1269  *     efidebug boot next <id>
1270  */
1271 static int do_efi_boot_next(struct cmd_tbl *cmdtp, int flag,
1272                             int argc, char *const argv[])
1273 {
1274         u16 bootnext;
1275         efi_uintn_t size;
1276         char *endp;
1277         efi_guid_t guid;
1278         efi_status_t ret;
1279         int r = CMD_RET_SUCCESS;
1280
1281         if (argc != 2)
1282                 return CMD_RET_USAGE;
1283
1284         bootnext = (u16)hextoul(argv[1], &endp);
1285         if (*endp) {
1286                 printf("invalid value: %s\n", argv[1]);
1287                 r = CMD_RET_FAILURE;
1288                 goto out;
1289         }
1290
1291         guid = efi_global_variable_guid;
1292         size = sizeof(u16);
1293         ret = efi_set_variable_int(u"BootNext", &guid,
1294                                    EFI_VARIABLE_NON_VOLATILE |
1295                                    EFI_VARIABLE_BOOTSERVICE_ACCESS |
1296                                    EFI_VARIABLE_RUNTIME_ACCESS,
1297                                    size, &bootnext, false);
1298         if (ret != EFI_SUCCESS) {
1299                 printf("Cannot set BootNext\n");
1300                 r = CMD_RET_FAILURE;
1301         }
1302 out:
1303         return r;
1304 }
1305
1306 /**
1307  * do_efi_boot_order() - manage UEFI BootOrder variable
1308  *
1309  * @cmdtp:      Command table
1310  * @flag:       Command flag
1311  * @argc:       Number of arguments
1312  * @argv:       Argument array
1313  * Return:      CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
1314  *
1315  * Implement efidebug "boot order" sub-command.
1316  * Show order of UEFI load options, or change it in BootOrder variable.
1317  *
1318  *     efidebug boot order [<id> ...]
1319  */
1320 static int do_efi_boot_order(struct cmd_tbl *cmdtp, int flag,
1321                              int argc, char *const argv[])
1322 {
1323         u16 *bootorder = NULL;
1324         efi_uintn_t size;
1325         int id, i;
1326         char *endp;
1327         efi_guid_t guid;
1328         efi_status_t ret;
1329         int r = CMD_RET_SUCCESS;
1330
1331         if (argc == 1)
1332                 return show_efi_boot_order();
1333
1334         argc--;
1335         argv++;
1336
1337         size = argc * sizeof(u16);
1338         bootorder = malloc(size);
1339         if (!bootorder)
1340                 return CMD_RET_FAILURE;
1341
1342         for (i = 0; i < argc; i++) {
1343                 id = (int)hextoul(argv[i], &endp);
1344                 if (*endp != '\0' || id > 0xffff) {
1345                         printf("invalid value: %s\n", argv[i]);
1346                         r = CMD_RET_FAILURE;
1347                         goto out;
1348                 }
1349
1350                 bootorder[i] = (u16)id;
1351         }
1352
1353         guid = efi_global_variable_guid;
1354         ret = efi_set_variable_int(u"BootOrder", &guid,
1355                                    EFI_VARIABLE_NON_VOLATILE |
1356                                    EFI_VARIABLE_BOOTSERVICE_ACCESS |
1357                                    EFI_VARIABLE_RUNTIME_ACCESS,
1358                                    size, bootorder, true);
1359         if (ret != EFI_SUCCESS) {
1360                 printf("Cannot set BootOrder\n");
1361                 r = CMD_RET_FAILURE;
1362         }
1363 out:
1364         free(bootorder);
1365
1366         return r;
1367 }
1368
1369 static struct cmd_tbl cmd_efidebug_boot_sub[] = {
1370         U_BOOT_CMD_MKENT(add, CONFIG_SYS_MAXARGS, 1, do_efi_boot_add, "", ""),
1371         U_BOOT_CMD_MKENT(rm, CONFIG_SYS_MAXARGS, 1, do_efi_boot_rm, "", ""),
1372         U_BOOT_CMD_MKENT(dump, CONFIG_SYS_MAXARGS, 1, do_efi_boot_dump, "", ""),
1373         U_BOOT_CMD_MKENT(next, CONFIG_SYS_MAXARGS, 1, do_efi_boot_next, "", ""),
1374         U_BOOT_CMD_MKENT(order, CONFIG_SYS_MAXARGS, 1, do_efi_boot_order,
1375                          "", ""),
1376 };
1377
1378 /**
1379  * do_efi_boot_opt() - manage UEFI load options
1380  *
1381  * @cmdtp:      Command table
1382  * @flag:       Command flag
1383  * @argc:       Number of arguments
1384  * @argv:       Argument array
1385  * Return:      CMD_RET_SUCCESS on success,
1386  *              CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure
1387  *
1388  * Implement efidebug "boot" sub-command.
1389  */
1390 static int do_efi_boot_opt(struct cmd_tbl *cmdtp, int flag,
1391                            int argc, char *const argv[])
1392 {
1393         struct cmd_tbl *cp;
1394
1395         if (argc < 2)
1396                 return CMD_RET_USAGE;
1397
1398         argc--; argv++;
1399
1400         cp = find_cmd_tbl(argv[0], cmd_efidebug_boot_sub,
1401                           ARRAY_SIZE(cmd_efidebug_boot_sub));
1402         if (!cp)
1403                 return CMD_RET_USAGE;
1404
1405         return cp->cmd(cmdtp, flag, argc, argv);
1406 }
1407
1408 /**
1409  * do_efi_test_bootmgr() - run simple bootmgr for test
1410  *
1411  * @cmdtp:      Command table
1412  * @flag:       Command flag
1413  * @argc:       Number of arguments
1414  * @argv:       Argument array
1415  * Return:      CMD_RET_SUCCESS on success,
1416  *              CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure
1417  *
1418  * Implement efidebug "test bootmgr" sub-command.
1419  * Run simple bootmgr for test.
1420  *
1421  *     efidebug test bootmgr
1422  */
1423 static __maybe_unused int do_efi_test_bootmgr(struct cmd_tbl *cmdtp, int flag,
1424                                               int argc, char * const argv[])
1425 {
1426         efi_handle_t image;
1427         efi_uintn_t exit_data_size = 0;
1428         u16 *exit_data = NULL;
1429         efi_status_t ret;
1430         void *load_options = NULL;
1431
1432         ret = efi_bootmgr_load(&image, &load_options);
1433         printf("efi_bootmgr_load() returned: %ld\n", ret & ~EFI_ERROR_MASK);
1434
1435         /* We call efi_start_image() even if error for test purpose. */
1436         ret = EFI_CALL(efi_start_image(image, &exit_data_size, &exit_data));
1437         printf("efi_start_image() returned: %ld\n", ret & ~EFI_ERROR_MASK);
1438         if (ret && exit_data)
1439                 efi_free_pool(exit_data);
1440
1441         efi_restore_gd();
1442
1443         free(load_options);
1444         return CMD_RET_SUCCESS;
1445 }
1446
1447 static struct cmd_tbl cmd_efidebug_test_sub[] = {
1448 #ifdef CONFIG_CMD_BOOTEFI_BOOTMGR
1449         U_BOOT_CMD_MKENT(bootmgr, CONFIG_SYS_MAXARGS, 1, do_efi_test_bootmgr,
1450                          "", ""),
1451 #endif
1452 };
1453
1454 /**
1455  * do_efi_test() - manage UEFI load options
1456  *
1457  * @cmdtp:      Command table
1458  * @flag:       Command flag
1459  * @argc:       Number of arguments
1460  * @argv:       Argument array
1461  * Return:      CMD_RET_SUCCESS on success,
1462  *              CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure
1463  *
1464  * Implement efidebug "test" sub-command.
1465  */
1466 static int do_efi_test(struct cmd_tbl *cmdtp, int flag,
1467                        int argc, char * const argv[])
1468 {
1469         struct cmd_tbl *cp;
1470
1471         if (argc < 2)
1472                 return CMD_RET_USAGE;
1473
1474         argc--; argv++;
1475
1476         cp = find_cmd_tbl(argv[0], cmd_efidebug_test_sub,
1477                           ARRAY_SIZE(cmd_efidebug_test_sub));
1478         if (!cp)
1479                 return CMD_RET_USAGE;
1480
1481         return cp->cmd(cmdtp, flag, argc, argv);
1482 }
1483
1484 /**
1485  * do_efi_query_info() - QueryVariableInfo EFI service
1486  *
1487  * @cmdtp:      Command table
1488  * @flag:       Command flag
1489  * @argc:       Number of arguments
1490  * @argv:       Argument array
1491  * Return:      CMD_RET_SUCCESS on success,
1492  *              CMD_RET_USAGE or CMD_RET_FAILURE on failure
1493  *
1494  * Implement efidebug "test" sub-command.
1495  */
1496
1497 static int do_efi_query_info(struct cmd_tbl *cmdtp, int flag,
1498                              int argc, char * const argv[])
1499 {
1500         efi_status_t ret;
1501         u32 attr = 0;
1502         u64 max_variable_storage_size;
1503         u64 remain_variable_storage_size;
1504         u64 max_variable_size;
1505         int i;
1506
1507         for (i = 1; i < argc; i++) {
1508                 if (!strcmp(argv[i], "-bs"))
1509                         attr |= EFI_VARIABLE_BOOTSERVICE_ACCESS;
1510                 else if (!strcmp(argv[i], "-rt"))
1511                         attr |= EFI_VARIABLE_RUNTIME_ACCESS;
1512                 else if (!strcmp(argv[i], "-nv"))
1513                         attr |= EFI_VARIABLE_NON_VOLATILE;
1514                 else if (!strcmp(argv[i], "-at"))
1515                         attr |=
1516                                 EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS;
1517         }
1518
1519         ret = EFI_CALL(efi_query_variable_info(attr,
1520                                                &max_variable_storage_size,
1521                                                &remain_variable_storage_size,
1522                                                &max_variable_size));
1523         if (ret != EFI_SUCCESS) {
1524                 printf("Error: Cannot query UEFI variables, r = %lu\n",
1525                        ret & ~EFI_ERROR_MASK);
1526                 return CMD_RET_FAILURE;
1527         }
1528
1529         printf("Max storage size %llu\n", max_variable_storage_size);
1530         printf("Remaining storage size %llu\n", remain_variable_storage_size);
1531         printf("Max variable size %llu\n", max_variable_size);
1532
1533         return CMD_RET_SUCCESS;
1534 }
1535
1536 static struct cmd_tbl cmd_efidebug_sub[] = {
1537         U_BOOT_CMD_MKENT(boot, CONFIG_SYS_MAXARGS, 1, do_efi_boot_opt, "", ""),
1538 #ifdef CONFIG_EFI_HAVE_CAPSULE_SUPPORT
1539         U_BOOT_CMD_MKENT(capsule, CONFIG_SYS_MAXARGS, 1, do_efi_capsule,
1540                          "", ""),
1541 #endif
1542         U_BOOT_CMD_MKENT(devices, CONFIG_SYS_MAXARGS, 1, do_efi_show_devices,
1543                          "", ""),
1544         U_BOOT_CMD_MKENT(drivers, CONFIG_SYS_MAXARGS, 1, do_efi_show_drivers,
1545                          "", ""),
1546         U_BOOT_CMD_MKENT(dh, CONFIG_SYS_MAXARGS, 1, do_efi_show_handles,
1547                          "", ""),
1548         U_BOOT_CMD_MKENT(images, CONFIG_SYS_MAXARGS, 1, do_efi_show_images,
1549                          "", ""),
1550         U_BOOT_CMD_MKENT(memmap, CONFIG_SYS_MAXARGS, 1, do_efi_show_memmap,
1551                          "", ""),
1552         U_BOOT_CMD_MKENT(tables, CONFIG_SYS_MAXARGS, 1, do_efi_show_tables,
1553                          "", ""),
1554         U_BOOT_CMD_MKENT(test, CONFIG_SYS_MAXARGS, 1, do_efi_test,
1555                          "", ""),
1556         U_BOOT_CMD_MKENT(query, CONFIG_SYS_MAXARGS, 1, do_efi_query_info,
1557                          "", ""),
1558 };
1559
1560 /**
1561  * do_efidebug() - display and configure UEFI environment
1562  *
1563  * @cmdtp:      Command table
1564  * @flag:       Command flag
1565  * @argc:       Number of arguments
1566  * @argv:       Argument array
1567  * Return:      CMD_RET_SUCCESS on success,
1568  *              CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure
1569  *
1570  * Implement efidebug command which allows us to display and
1571  * configure UEFI environment.
1572  */
1573 static int do_efidebug(struct cmd_tbl *cmdtp, int flag,
1574                        int argc, char *const argv[])
1575 {
1576         struct cmd_tbl *cp;
1577         efi_status_t r;
1578
1579         if (argc < 2)
1580                 return CMD_RET_USAGE;
1581
1582         argc--; argv++;
1583
1584         /* Initialize UEFI drivers */
1585         r = efi_init_obj_list();
1586         if (r != EFI_SUCCESS) {
1587                 printf("Error: Cannot initialize UEFI sub-system, r = %lu\n",
1588                        r & ~EFI_ERROR_MASK);
1589                 return CMD_RET_FAILURE;
1590         }
1591
1592         cp = find_cmd_tbl(argv[0], cmd_efidebug_sub,
1593                           ARRAY_SIZE(cmd_efidebug_sub));
1594         if (!cp)
1595                 return CMD_RET_USAGE;
1596
1597         return cp->cmd(cmdtp, flag, argc, argv);
1598 }
1599
1600 #ifdef CONFIG_SYS_LONGHELP
1601 static char efidebug_help_text[] =
1602         "  - UEFI Shell-like interface to configure UEFI environment\n"
1603         "\n"
1604         "efidebug boot add - set UEFI BootXXXX variable\n"
1605         "  -b|-B <bootid> <label> <interface> <devnum>[:<part>] <file path>\n"
1606         "  -i|-I <interface> <devnum>[:<part>] <initrd file path>\n"
1607         "  (-b, -i for short form device path)\n"
1608         "  -s '<optional data>'\n"
1609         "efidebug boot rm <bootid#1> [<bootid#2> [<bootid#3> [...]]]\n"
1610         "  - delete UEFI BootXXXX variables\n"
1611         "efidebug boot dump\n"
1612         "  - dump all UEFI BootXXXX variables\n"
1613         "efidebug boot next <bootid>\n"
1614         "  - set UEFI BootNext variable\n"
1615         "efidebug boot order [<bootid#1> [<bootid#2> [<bootid#3> [...]]]]\n"
1616         "  - set/show UEFI boot order\n"
1617         "\n"
1618 #ifdef CONFIG_EFI_HAVE_CAPSULE_SUPPORT
1619         "efidebug capsule update [-v] <capsule address>\n"
1620         "  - process a capsule\n"
1621         "efidebug capsule disk-update\n"
1622         "  - update a capsule from disk\n"
1623         "efidebug capsule show <capsule address>\n"
1624         "  - show capsule information\n"
1625         "efidebug capsule result [<capsule result var>]\n"
1626         "  - show a capsule update result\n"
1627 #ifdef CONFIG_EFI_ESRT
1628         "efidebug capsule esrt\n"
1629         "  - print the ESRT\n"
1630 #endif
1631         "\n"
1632 #endif
1633         "efidebug devices\n"
1634         "  - show UEFI devices\n"
1635         "efidebug drivers\n"
1636         "  - show UEFI drivers\n"
1637         "efidebug dh\n"
1638         "  - show UEFI handles\n"
1639         "efidebug images\n"
1640         "  - show loaded images\n"
1641         "efidebug memmap\n"
1642         "  - show UEFI memory map\n"
1643         "efidebug tables\n"
1644         "  - show UEFI configuration tables\n"
1645 #ifdef CONFIG_CMD_BOOTEFI_BOOTMGR
1646         "efidebug test bootmgr\n"
1647         "  - run simple bootmgr for test\n"
1648 #endif
1649         "efidebug query [-nv][-bs][-rt][-at]\n"
1650         "  - show size of UEFI variables store\n";
1651 #endif
1652
1653 U_BOOT_CMD(
1654         efidebug, CONFIG_SYS_MAXARGS, 0, do_efidebug,
1655         "Configure UEFI environment",
1656         efidebug_help_text
1657 );