1
2
3
4
5
6
7
8#define LOG_CATEGORY LOGC_EFI
9
10#include <common.h>
11#include <bootm.h>
12#include <charset.h>
13#include <command.h>
14#include <dm.h>
15#include <efi_loader.h>
16#include <efi_selftest.h>
17#include <env.h>
18#include <errno.h>
19#include <image.h>
20#include <log.h>
21#include <malloc.h>
22#include <asm/global_data.h>
23#include <linux/libfdt.h>
24#include <linux/libfdt_env.h>
25#include <mapmem.h>
26#include <memalign.h>
27#include <asm-generic/sections.h>
28#include <linux/linkage.h>
29
30DECLARE_GLOBAL_DATA_PTR;
31
32static struct efi_device_path *bootefi_image_path;
33static struct efi_device_path *bootefi_device_path;
34static void *image_addr;
35static size_t image_size;
36
37
38
39
40
41
42
43void efi_get_image_parameters(void **img_addr, size_t *img_size)
44{
45 *img_addr = image_addr;
46 *img_size = image_size;
47}
48
49
50
51
52static void efi_clear_bootdev(void)
53{
54 efi_free_pool(bootefi_device_path);
55 efi_free_pool(bootefi_image_path);
56 bootefi_device_path = NULL;
57 bootefi_image_path = NULL;
58 image_addr = NULL;
59 image_size = 0;
60}
61
62
63
64
65
66
67
68
69
70
71
72
73
74void efi_set_bootdev(const char *dev, const char *devnr, const char *path,
75 void *buffer, size_t buffer_size)
76{
77 struct efi_device_path *device, *image;
78 efi_status_t ret;
79
80 log_debug("dev=%s, devnr=%s, path=%s, buffer=%p, size=%zx\n", dev,
81 devnr, path, buffer, buffer_size);
82
83
84 if (buffer + buffer_size >= image_addr &&
85 image_addr + image_size >= buffer)
86 efi_clear_bootdev();
87
88
89 if (efi_check_pe(buffer, buffer_size, NULL) != EFI_SUCCESS) {
90 if (IS_ENABLED(CONFIG_FIT) &&
91 !fit_check_format(buffer, IMAGE_SIZE_INVAL)) {
92
93
94
95
96
97 buffer = 0;
98 buffer_size = 0;
99 } else {
100 log_debug("- not remembering image\n");
101 return;
102 }
103 }
104
105
106 efi_clear_bootdev();
107
108 image_addr = buffer;
109 image_size = buffer_size;
110
111 ret = efi_dp_from_name(dev, devnr, path, &device, &image);
112 if (ret == EFI_SUCCESS) {
113 bootefi_device_path = device;
114 if (image) {
115
116 struct efi_device_path *image_tmp = image;
117
118 efi_dp_split_file_path(image, &device, &image);
119 efi_free_pool(image_tmp);
120 }
121 bootefi_image_path = image;
122 log_debug("- boot device %pD\n", device);
123 if (image)
124 log_debug("- image %pD\n", image);
125 } else {
126 log_debug("- efi_dp_from_name() failed, err=%lx\n", ret);
127 efi_clear_bootdev();
128 }
129}
130
131
132
133
134
135
136
137
138
139static efi_status_t efi_env_set_load_options(efi_handle_t handle,
140 const char *env_var,
141 u16 **load_options)
142{
143 const char *env = env_get(env_var);
144 size_t size;
145 u16 *pos;
146 efi_status_t ret;
147
148 *load_options = NULL;
149 if (!env)
150 return EFI_SUCCESS;
151 size = sizeof(u16) * (utf8_utf16_strlen(env) + 1);
152 pos = calloc(size, 1);
153 if (!pos)
154 return EFI_OUT_OF_RESOURCES;
155 *load_options = pos;
156 utf8_utf16_strcpy(&pos, env);
157 ret = efi_set_load_options(handle, size, *load_options);
158 if (ret != EFI_SUCCESS) {
159 free(*load_options);
160 *load_options = NULL;
161 }
162 return ret;
163}
164
165#if !CONFIG_IS_ENABLED(GENERATE_ACPI_TABLE)
166
167
168
169
170
171
172
173
174
175
176
177
178
179static efi_status_t copy_fdt(void **fdtp)
180{
181 unsigned long fdt_ram_start = -1L, fdt_pages;
182 efi_status_t ret = 0;
183 void *fdt, *new_fdt;
184 u64 new_fdt_addr;
185 uint fdt_size;
186 int i;
187
188 for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) {
189 u64 ram_start = gd->bd->bi_dram[i].start;
190 u64 ram_size = gd->bd->bi_dram[i].size;
191
192 if (!ram_size)
193 continue;
194
195 if (ram_start < fdt_ram_start)
196 fdt_ram_start = ram_start;
197 }
198
199
200
201
202
203 fdt = *fdtp;
204 fdt_pages = efi_size_in_pages(fdt_totalsize(fdt) + 0x3000);
205 fdt_size = fdt_pages << EFI_PAGE_SHIFT;
206
207 ret = efi_allocate_pages(EFI_ALLOCATE_ANY_PAGES,
208 EFI_ACPI_RECLAIM_MEMORY, fdt_pages,
209 &new_fdt_addr);
210 if (ret != EFI_SUCCESS) {
211 log_err("ERROR: Failed to reserve space for FDT\n");
212 goto done;
213 }
214 new_fdt = (void *)(uintptr_t)new_fdt_addr;
215 memcpy(new_fdt, fdt, fdt_totalsize(fdt));
216 fdt_set_totalsize(new_fdt, fdt_size);
217
218 *fdtp = (void *)(uintptr_t)new_fdt_addr;
219done:
220 return ret;
221}
222
223
224
225
226
227
228
229static void *get_config_table(const efi_guid_t *guid)
230{
231 size_t i;
232
233 for (i = 0; i < systab.nr_tables; i++) {
234 if (!guidcmp(guid, &systab.tables[i].guid))
235 return systab.tables[i].table;
236 }
237 return NULL;
238}
239
240#endif
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259efi_status_t efi_install_fdt(void *fdt)
260{
261
262
263
264
265#if CONFIG_IS_ENABLED(GENERATE_ACPI_TABLE)
266 if (fdt) {
267 log_warning("WARNING: Can't have ACPI table and device tree - ignoring DT.\n");
268 return EFI_SUCCESS;
269 }
270#else
271 struct bootm_headers img = { 0 };
272 efi_status_t ret;
273
274 if (fdt == EFI_FDT_USE_INTERNAL) {
275 const char *fdt_opt;
276 uintptr_t fdt_addr;
277
278
279 if (get_config_table(&efi_guid_fdt))
280 return EFI_SUCCESS;
281
282 fdt_opt = env_get("fdt_addr");
283
284 if (!fdt_opt) {
285 fdt_opt = env_get("fdtcontroladdr");
286 if (!fdt_opt) {
287 log_err("ERROR: need device tree\n");
288 return EFI_NOT_FOUND;
289 }
290 }
291 fdt_addr = hextoul(fdt_opt, NULL);
292 if (!fdt_addr) {
293 log_err("ERROR: invalid $fdt_addr or $fdtcontroladdr\n");
294 return EFI_LOAD_ERROR;
295 }
296 fdt = map_sysmem(fdt_addr, 0);
297 }
298
299
300 if (fdt_check_header(fdt)) {
301 log_err("ERROR: invalid device tree\n");
302 return EFI_LOAD_ERROR;
303 }
304
305
306 ret = copy_fdt(&fdt);
307 if (ret) {
308 log_err("ERROR: out of memory\n");
309 return EFI_OUT_OF_RESOURCES;
310 }
311
312 if (image_setup_libfdt(&img, fdt, 0, NULL)) {
313 log_err("ERROR: failed to process device tree\n");
314 return EFI_LOAD_ERROR;
315 }
316
317
318 efi_carve_out_dt_rsv(fdt);
319
320 efi_try_purge_kaslr_seed(fdt);
321
322 if (CONFIG_IS_ENABLED(EFI_TCG2_PROTOCOL_MEASURE_DTB)) {
323 ret = efi_tcg2_measure_dtb(fdt);
324 if (ret == EFI_SECURITY_VIOLATION) {
325 log_err("ERROR: failed to measure DTB\n");
326 return ret;
327 }
328 }
329
330
331 ret = efi_install_configuration_table(&efi_guid_fdt, fdt);
332 if (ret != EFI_SUCCESS) {
333 log_err("ERROR: failed to install device tree\n");
334 return ret;
335 }
336#endif
337
338 return EFI_SUCCESS;
339}
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354static efi_status_t do_bootefi_exec(efi_handle_t handle, void *load_options)
355{
356 efi_status_t ret;
357 efi_uintn_t exit_data_size = 0;
358 u16 *exit_data = NULL;
359
360
361 switch_to_non_secure_mode();
362
363
364
365
366
367
368
369
370 ret = efi_set_watchdog(300);
371 if (ret != EFI_SUCCESS) {
372 log_err("ERROR: Failed to set watchdog timer\n");
373 goto out;
374 }
375
376
377 ret = EFI_CALL(efi_start_image(handle, &exit_data_size, &exit_data));
378 if (ret != EFI_SUCCESS) {
379 log_err("## Application failed, r = %lu\n",
380 ret & ~EFI_ERROR_MASK);
381 if (exit_data) {
382 log_err("## %ls\n", exit_data);
383 efi_free_pool(exit_data);
384 }
385 }
386
387 efi_restore_gd();
388
389out:
390 free(load_options);
391
392 if (IS_ENABLED(CONFIG_EFI_LOAD_FILE2_INITRD)) {
393 if (efi_initrd_deregister() != EFI_SUCCESS)
394 log_err("Failed to remove loadfile2 for initrd\n");
395 }
396
397
398 efi_set_watchdog(0);
399
400 return ret;
401}
402
403
404
405
406
407
408static int do_efibootmgr(void)
409{
410 efi_handle_t handle;
411 efi_status_t ret;
412 void *load_options;
413
414 ret = efi_bootmgr_load(&handle, &load_options);
415 if (ret != EFI_SUCCESS) {
416 log_notice("EFI boot manager: Cannot load any image\n");
417 return CMD_RET_FAILURE;
418 }
419
420 ret = do_bootefi_exec(handle, load_options);
421
422 if (ret != EFI_SUCCESS)
423 return CMD_RET_FAILURE;
424
425 return CMD_RET_SUCCESS;
426}
427
428
429
430
431
432
433
434
435
436
437
438static int do_bootefi_image(const char *image_opt, const char *size_opt)
439{
440 void *image_buf;
441 unsigned long addr, size;
442 efi_status_t ret;
443
444#ifdef CONFIG_CMD_BOOTEFI_HELLO
445 if (!strcmp(image_opt, "hello")) {
446 image_buf = __efi_helloworld_begin;
447 size = __efi_helloworld_end - __efi_helloworld_begin;
448 efi_clear_bootdev();
449 } else
450#endif
451 {
452 addr = strtoul(image_opt, NULL, 16);
453
454 if (!addr)
455 return CMD_RET_USAGE;
456 image_buf = map_sysmem(addr, 0);
457
458 if (size_opt) {
459 size = strtoul(size_opt, NULL, 16);
460 if (!size)
461 return CMD_RET_USAGE;
462 efi_clear_bootdev();
463 } else {
464 if (image_buf != image_addr) {
465 log_err("No UEFI binary known at %s\n",
466 image_opt);
467 return CMD_RET_FAILURE;
468 }
469 size = image_size;
470 }
471 }
472 ret = efi_run_image(image_buf, size);
473
474 if (ret != EFI_SUCCESS)
475 return CMD_RET_FAILURE;
476
477 return CMD_RET_SUCCESS;
478}
479
480
481
482
483
484
485
486
487efi_status_t efi_run_image(void *source_buffer, efi_uintn_t source_size)
488{
489 efi_handle_t mem_handle = NULL, handle;
490 struct efi_device_path *file_path = NULL;
491 struct efi_device_path *msg_path;
492 efi_status_t ret, ret2;
493 u16 *load_options;
494
495 if (!bootefi_device_path || !bootefi_image_path) {
496 log_debug("Not loaded from disk\n");
497
498
499
500
501
502 file_path = efi_dp_from_mem(EFI_RESERVED_MEMORY_TYPE,
503 (uintptr_t)source_buffer,
504 source_size);
505
506
507
508
509 ret = efi_install_multiple_protocol_interfaces(&mem_handle,
510 &efi_guid_device_path,
511 file_path, NULL);
512 if (ret != EFI_SUCCESS)
513 goto out;
514 msg_path = file_path;
515 } else {
516 file_path = efi_dp_append(bootefi_device_path,
517 bootefi_image_path);
518 msg_path = bootefi_image_path;
519 log_debug("Loaded from disk\n");
520 }
521
522 log_info("Booting %pD\n", msg_path);
523
524 ret = EFI_CALL(efi_load_image(false, efi_root, file_path, source_buffer,
525 source_size, &handle));
526 if (ret != EFI_SUCCESS) {
527 log_err("Loading image failed\n");
528 goto out;
529 }
530
531
532 ret = efi_env_set_load_options(handle, "bootargs", &load_options);
533 if (ret != EFI_SUCCESS)
534 goto out;
535
536 ret = do_bootefi_exec(handle, load_options);
537
538out:
539 ret2 = efi_uninstall_multiple_protocol_interfaces(mem_handle,
540 &efi_guid_device_path,
541 file_path, NULL);
542 efi_free_pool(file_path);
543 return (ret != EFI_SUCCESS) ? ret : ret2;
544}
545
546#ifdef CONFIG_CMD_BOOTEFI_SELFTEST
547static efi_status_t bootefi_run_prepare(const char *load_options_path,
548 struct efi_device_path *device_path,
549 struct efi_device_path *image_path,
550 struct efi_loaded_image_obj **image_objp,
551 struct efi_loaded_image **loaded_image_infop)
552{
553 efi_status_t ret;
554 u16 *load_options;
555
556 ret = efi_setup_loaded_image(device_path, image_path, image_objp,
557 loaded_image_infop);
558 if (ret != EFI_SUCCESS)
559 return ret;
560
561
562 return efi_env_set_load_options((efi_handle_t)*image_objp,
563 load_options_path,
564 &load_options);
565}
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580static efi_status_t bootefi_test_prepare
581 (struct efi_loaded_image_obj **image_objp,
582 struct efi_loaded_image **loaded_image_infop, const char *path,
583 const char *load_options_path)
584{
585 efi_status_t ret;
586
587
588 bootefi_device_path = efi_dp_from_mem(EFI_RESERVED_MEMORY_TYPE, 0, 0);
589 if (!bootefi_device_path)
590 return EFI_OUT_OF_RESOURCES;
591
592 bootefi_image_path = efi_dp_from_file(NULL, path);
593 if (!bootefi_image_path) {
594 ret = EFI_OUT_OF_RESOURCES;
595 goto failure;
596 }
597
598 ret = bootefi_run_prepare(load_options_path, bootefi_device_path,
599 bootefi_image_path, image_objp,
600 loaded_image_infop);
601 if (ret == EFI_SUCCESS)
602 return ret;
603
604failure:
605 efi_clear_bootdev();
606 return ret;
607}
608
609
610
611
612
613
614
615static void bootefi_run_finish(struct efi_loaded_image_obj *image_obj,
616 struct efi_loaded_image *loaded_image_info)
617{
618 efi_restore_gd();
619 free(loaded_image_info->load_options);
620 efi_delete_handle(&image_obj->header);
621}
622
623
624
625
626
627
628static int do_efi_selftest(void)
629{
630 struct efi_loaded_image_obj *image_obj;
631 struct efi_loaded_image *loaded_image_info;
632 efi_status_t ret;
633
634 ret = bootefi_test_prepare(&image_obj, &loaded_image_info,
635 "\\selftest", "efi_selftest");
636 if (ret != EFI_SUCCESS)
637 return CMD_RET_FAILURE;
638
639
640 ret = EFI_CALL(efi_selftest(&image_obj->header, &systab));
641 bootefi_run_finish(image_obj, loaded_image_info);
642
643 return ret != EFI_SUCCESS;
644}
645#endif
646
647
648
649
650
651
652
653
654
655
656static int do_bootefi(struct cmd_tbl *cmdtp, int flag, int argc,
657 char *const argv[])
658{
659 efi_status_t ret;
660 char *img_addr, *img_size, *str_copy, *pos;
661 void *fdt;
662
663 if (argc < 2)
664 return CMD_RET_USAGE;
665
666
667 ret = efi_init_obj_list();
668 if (ret != EFI_SUCCESS) {
669 log_err("Error: Cannot initialize UEFI sub-system, r = %lu\n",
670 ret & ~EFI_ERROR_MASK);
671 return CMD_RET_FAILURE;
672 }
673
674 if (argc > 2) {
675 uintptr_t fdt_addr;
676
677 fdt_addr = hextoul(argv[2], NULL);
678 fdt = map_sysmem(fdt_addr, 0);
679 } else {
680 fdt = EFI_FDT_USE_INTERNAL;
681 }
682 ret = efi_install_fdt(fdt);
683 if (ret == EFI_INVALID_PARAMETER)
684 return CMD_RET_USAGE;
685 else if (ret != EFI_SUCCESS)
686 return CMD_RET_FAILURE;
687
688 if (IS_ENABLED(CONFIG_CMD_BOOTEFI_BOOTMGR)) {
689 if (!strcmp(argv[1], "bootmgr"))
690 return do_efibootmgr();
691 }
692#ifdef CONFIG_CMD_BOOTEFI_SELFTEST
693 if (!strcmp(argv[1], "selftest"))
694 return do_efi_selftest();
695#endif
696 str_copy = strdup(argv[1]);
697 if (!str_copy) {
698 log_err("Out of memory\n");
699 return CMD_RET_FAILURE;
700 }
701 pos = str_copy;
702 img_addr = strsep(&pos, ":");
703 img_size = strsep(&pos, ":");
704 ret = do_bootefi_image(img_addr, img_size);
705 free(str_copy);
706
707 return ret;
708}
709
710#ifdef CONFIG_SYS_LONGHELP
711static char bootefi_help_text[] =
712 "<image address>[:<image size>] [<fdt address>]\n"
713 " - boot EFI payload\n"
714#ifdef CONFIG_CMD_BOOTEFI_HELLO
715 "bootefi hello\n"
716 " - boot a sample Hello World application stored within U-Boot\n"
717#endif
718#ifdef CONFIG_CMD_BOOTEFI_SELFTEST
719 "bootefi selftest [fdt address]\n"
720 " - boot an EFI selftest application stored within U-Boot\n"
721 " Use environment variable efi_selftest to select a single test.\n"
722 " Use 'setenv efi_selftest list' to enumerate all tests.\n"
723#endif
724#ifdef CONFIG_CMD_BOOTEFI_BOOTMGR
725 "bootefi bootmgr [fdt address]\n"
726 " - load and boot EFI payload based on BootOrder/BootXXXX variables.\n"
727 "\n"
728 " If specified, the device tree located at <fdt address> gets\n"
729 " exposed as EFI configuration table.\n"
730#endif
731 ;
732#endif
733
734U_BOOT_CMD(
735 bootefi, 4, 0, do_bootefi,
736 "Boots an EFI payload from memory",
737 bootefi_help_text
738);
739