1 // SPDX-License-Identifier: GPL-2.0+
3 * EFI application loader
5 * Copyright (c) 2016 Alexander Graf
8 #define LOG_CATEGORY LOGC_EFI
14 #include <efi_loader.h>
15 #include <efi_selftest.h>
21 #include <linux/libfdt.h>
22 #include <linux/libfdt_env.h>
25 #include <asm-generic/sections.h>
26 #include <linux/linkage.h>
28 DECLARE_GLOBAL_DATA_PTR
;
30 static struct efi_device_path
*bootefi_image_path
;
31 static struct efi_device_path
*bootefi_device_path
;
34 * efi_env_set_load_options() - set load options from environment variable
36 * @handle: the image handle
37 * @env_var: name of the environment variable
38 * @load_options: pointer to load options (output)
41 static efi_status_t
efi_env_set_load_options(efi_handle_t handle
,
45 const char *env
= env_get(env_var
);
53 size
= sizeof(u16
) * (utf8_utf16_strlen(env
) + 1);
54 pos
= calloc(size
, 1);
56 return EFI_OUT_OF_RESOURCES
;
58 utf8_utf16_strcpy(&pos
, env
);
59 ret
= efi_set_load_options(handle
, size
, *load_options
);
60 if (ret
!= EFI_SUCCESS
) {
67 #if !CONFIG_IS_ENABLED(GENERATE_ACPI_TABLE)
70 * copy_fdt() - Copy the device tree to a new location available to EFI
72 * The FDT is copied to a suitable location within the EFI memory map.
73 * Additional 12 KiB are added to the space in case the device tree needs to be
74 * expanded later with fdt_open_into().
76 * @fdtp: On entry a pointer to the flattened device tree.
77 * On exit a pointer to the copy of the flattened device tree.
81 static efi_status_t
copy_fdt(void **fdtp
)
83 unsigned long fdt_ram_start
= -1L, fdt_pages
;
90 for (i
= 0; i
< CONFIG_NR_DRAM_BANKS
; i
++) {
91 u64 ram_start
= gd
->bd
->bi_dram
[i
].start
;
92 u64 ram_size
= gd
->bd
->bi_dram
[i
].size
;
97 if (ram_start
< fdt_ram_start
)
98 fdt_ram_start
= ram_start
;
102 * Give us at least 12 KiB of breathing room in case the device tree
103 * needs to be expanded later.
106 fdt_pages
= efi_size_in_pages(fdt_totalsize(fdt
) + 0x3000);
107 fdt_size
= fdt_pages
<< EFI_PAGE_SHIFT
;
110 * Safe fdt location is at 127 MiB.
111 * On the sandbox convert from the sandbox address space.
113 new_fdt_addr
= (uintptr_t)map_sysmem(fdt_ram_start
+ 0x7f00000 +
115 ret
= efi_allocate_pages(EFI_ALLOCATE_MAX_ADDRESS
,
116 EFI_ACPI_RECLAIM_MEMORY
, fdt_pages
,
118 if (ret
!= EFI_SUCCESS
) {
119 /* If we can't put it there, put it somewhere */
120 new_fdt_addr
= (ulong
)memalign(EFI_PAGE_SIZE
, fdt_size
);
121 ret
= efi_allocate_pages(EFI_ALLOCATE_MAX_ADDRESS
,
122 EFI_ACPI_RECLAIM_MEMORY
, fdt_pages
,
124 if (ret
!= EFI_SUCCESS
) {
125 log_err("ERROR: Failed to reserve space for FDT\n");
129 new_fdt
= (void *)(uintptr_t)new_fdt_addr
;
130 memcpy(new_fdt
, fdt
, fdt_totalsize(fdt
));
131 fdt_set_totalsize(new_fdt
, fdt_size
);
133 *fdtp
= (void *)(uintptr_t)new_fdt_addr
;
139 * efi_reserve_memory() - add reserved memory to memory map
141 * @addr: start address of the reserved memory range
142 * @size: size of the reserved memory range
143 * @nomap: indicates that the memory range shall not be accessed by the
146 static void efi_reserve_memory(u64 addr
, u64 size
, bool nomap
)
151 /* Convert from sandbox address space. */
152 addr
= (uintptr_t)map_sysmem(addr
, 0);
155 type
= EFI_RESERVED_MEMORY_TYPE
;
157 type
= EFI_BOOT_SERVICES_DATA
;
159 ret
= efi_add_memory_map(addr
, size
, type
);
160 if (ret
!= EFI_SUCCESS
)
161 log_err("Reserved memory mapping failed addr %llx size %llx\n",
166 * efi_carve_out_dt_rsv() - Carve out DT reserved memory ranges
168 * The mem_rsv entries of the FDT are added to the memory map. Any failures are
169 * ignored because this is not critical and we would rather continue to try to
172 * @fdt: Pointer to device tree
174 static void efi_carve_out_dt_rsv(void *fdt
)
178 int nodeoffset
, subnode
;
180 nr_rsv
= fdt_num_mem_rsv(fdt
);
182 /* Look for an existing entry and add it to the efi mem map. */
183 for (i
= 0; i
< nr_rsv
; i
++) {
184 if (fdt_get_mem_rsv(fdt
, i
, &addr
, &size
) != 0)
186 efi_reserve_memory(addr
, size
, false);
189 /* process reserved-memory */
190 nodeoffset
= fdt_subnode_offset(fdt
, 0, "reserved-memory");
191 if (nodeoffset
>= 0) {
192 subnode
= fdt_first_subnode(fdt
, nodeoffset
);
193 while (subnode
>= 0) {
197 /* check if this subnode has a reg property */
198 fdt_addr
= fdtdec_get_addr_size_auto_parent(
199 fdt
, nodeoffset
, subnode
,
200 "reg", 0, &fdt_size
, false);
202 * The /reserved-memory node may have children with
203 * a size instead of a reg property.
205 if (fdt_addr
!= FDT_ADDR_T_NONE
&&
206 fdtdec_get_is_enabled(fdt
, subnode
)) {
209 nomap
= !!fdt_getprop(fdt
, subnode
, "no-map",
211 efi_reserve_memory(fdt_addr
, fdt_size
, nomap
);
213 subnode
= fdt_next_subnode(fdt
, subnode
);
219 * get_config_table() - get configuration table
221 * @guid: GUID of the configuration table
222 * Return: pointer to configuration table or NULL
224 static void *get_config_table(const efi_guid_t
*guid
)
228 for (i
= 0; i
< systab
.nr_tables
; i
++) {
229 if (!guidcmp(guid
, &systab
.tables
[i
].guid
))
230 return systab
.tables
[i
].table
;
235 #endif /* !CONFIG_IS_ENABLED(GENERATE_ACPI_TABLE) */
238 * efi_install_fdt() - install device tree
240 * If fdt is not EFI_FDT_USE_INTERNAL, the device tree located at that memory
241 * address will will be installed as configuration table, otherwise the device
242 * tree located at the address indicated by environment variable fdt_addr or as
243 * fallback fdtcontroladdr will be used.
245 * On architectures using ACPI tables device trees shall not be installed as
246 * configuration table.
248 * @fdt: address of device tree or EFI_FDT_USE_INTERNAL to use the
249 * the hardware device tree as indicated by environment variable
250 * fdt_addr or as fallback the internal device tree as indicated by
251 * the environment variable fdtcontroladdr
252 * Return: status code
254 efi_status_t
efi_install_fdt(void *fdt
)
257 * The EBBR spec requires that we have either an FDT or an ACPI table
260 #if CONFIG_IS_ENABLED(GENERATE_ACPI_TABLE)
262 log_err("ERROR: can't have ACPI table and device tree.\n");
263 return EFI_LOAD_ERROR
;
266 bootm_headers_t img
= { 0 };
269 if (fdt
== EFI_FDT_USE_INTERNAL
) {
273 /* Look for device tree that is already installed */
274 if (get_config_table(&efi_guid_fdt
))
276 /* Check if there is a hardware device tree */
277 fdt_opt
= env_get("fdt_addr");
278 /* Use our own device tree as fallback */
280 fdt_opt
= env_get("fdtcontroladdr");
282 log_err("ERROR: need device tree\n");
283 return EFI_NOT_FOUND
;
286 fdt_addr
= simple_strtoul(fdt_opt
, NULL
, 16);
288 log_err("ERROR: invalid $fdt_addr or $fdtcontroladdr\n");
289 return EFI_LOAD_ERROR
;
291 fdt
= map_sysmem(fdt_addr
, 0);
294 /* Install device tree */
295 if (fdt_check_header(fdt
)) {
296 log_err("ERROR: invalid device tree\n");
297 return EFI_LOAD_ERROR
;
300 /* Prepare device tree for payload */
301 ret
= copy_fdt(&fdt
);
303 log_err("ERROR: out of memory\n");
304 return EFI_OUT_OF_RESOURCES
;
307 if (image_setup_libfdt(&img
, fdt
, 0, NULL
)) {
308 log_err("ERROR: failed to process device tree\n");
309 return EFI_LOAD_ERROR
;
312 /* Create memory reservations as indicated by the device tree */
313 efi_carve_out_dt_rsv(fdt
);
315 /* Install device tree as UEFI table */
316 ret
= efi_install_configuration_table(&efi_guid_fdt
, fdt
);
317 if (ret
!= EFI_SUCCESS
) {
318 log_err("ERROR: failed to install device tree\n");
321 #endif /* GENERATE_ACPI_TABLE */
327 * do_bootefi_exec() - execute EFI binary
329 * The image indicated by @handle is started. When it returns the allocated
330 * memory for the @load_options is freed.
332 * @handle: handle of loaded image
333 * @load_options: load options
334 * Return: status code
336 * Load the EFI binary into a newly assigned memory unwinding the relocation
337 * information, install the loaded image protocol, and call the binary.
339 static efi_status_t
do_bootefi_exec(efi_handle_t handle
, void *load_options
)
342 efi_uintn_t exit_data_size
= 0;
343 u16
*exit_data
= NULL
;
345 /* Call our payload! */
346 ret
= EFI_CALL(efi_start_image(handle
, &exit_data_size
, &exit_data
));
347 if (ret
!= EFI_SUCCESS
) {
348 log_err("## Application failed, r = %lu\n",
349 ret
& ~EFI_ERROR_MASK
);
351 log_err("## %ls\n", exit_data
);
352 efi_free_pool(exit_data
);
364 * do_efibootmgr() - execute EFI boot manager
366 * Return: status code
368 static int do_efibootmgr(void)
374 ret
= efi_bootmgr_load(&handle
, &load_options
);
375 if (ret
!= EFI_SUCCESS
) {
376 log_notice("EFI boot manager: Cannot load any image\n");
377 return CMD_RET_FAILURE
;
380 ret
= do_bootefi_exec(handle
, load_options
);
382 if (ret
!= EFI_SUCCESS
)
383 return CMD_RET_FAILURE
;
385 return CMD_RET_SUCCESS
;
389 * do_bootefi_image() - execute EFI binary
391 * Set up memory image for the binary to be loaded, prepare device path, and
392 * then call do_bootefi_exec() to execute it.
394 * @image_opt: string of image start address
395 * Return: status code
397 static int do_bootefi_image(const char *image_opt
)
400 unsigned long addr
, size
;
401 const char *size_str
;
404 #ifdef CONFIG_CMD_BOOTEFI_HELLO
405 if (!strcmp(image_opt
, "hello")) {
408 saddr
= env_get("loadaddr");
409 size
= __efi_helloworld_end
- __efi_helloworld_begin
;
412 addr
= simple_strtoul(saddr
, NULL
, 16);
414 addr
= CONFIG_SYS_LOAD_ADDR
;
416 image_buf
= map_sysmem(addr
, size
);
417 memcpy(image_buf
, __efi_helloworld_begin
, size
);
419 efi_free_pool(bootefi_device_path
);
420 efi_free_pool(bootefi_image_path
);
421 bootefi_device_path
= NULL
;
422 bootefi_image_path
= NULL
;
426 size_str
= env_get("filesize");
428 size
= simple_strtoul(size_str
, NULL
, 16);
432 addr
= simple_strtoul(image_opt
, NULL
, 16);
433 /* Check that a numeric value was passed */
434 if (!addr
&& *image_opt
!= '0')
435 return CMD_RET_USAGE
;
437 image_buf
= map_sysmem(addr
, size
);
439 ret
= efi_run_image(image_buf
, size
);
441 if (ret
!= EFI_SUCCESS
)
442 return CMD_RET_FAILURE
;
444 return CMD_RET_SUCCESS
;
448 * efi_run_image() - run loaded UEFI image
450 * @source_buffer: memory address of the UEFI image
451 * @source_size: size of the UEFI image
452 * Return: status code
454 efi_status_t
efi_run_image(void *source_buffer
, efi_uintn_t source_size
)
456 efi_handle_t mem_handle
= NULL
, handle
;
457 struct efi_device_path
*file_path
= NULL
;
458 struct efi_device_path
*msg_path
;
462 if (!bootefi_device_path
|| !bootefi_image_path
) {
464 * Special case for efi payload not loaded from disk,
465 * such as 'bootefi hello' or for example payload
466 * loaded directly into memory via JTAG, etc:
468 file_path
= efi_dp_from_mem(EFI_RESERVED_MEMORY_TYPE
,
469 (uintptr_t)source_buffer
,
472 * Make sure that device for device_path exist
473 * in load_image(). Otherwise, shell and grub will fail.
475 ret
= efi_create_handle(&mem_handle
);
476 if (ret
!= EFI_SUCCESS
)
479 ret
= efi_add_protocol(mem_handle
, &efi_guid_device_path
,
481 if (ret
!= EFI_SUCCESS
)
483 msg_path
= file_path
;
485 file_path
= efi_dp_append(bootefi_device_path
,
487 msg_path
= bootefi_image_path
;
490 log_info("Booting %pD\n", msg_path
);
492 ret
= EFI_CALL(efi_load_image(false, efi_root
, file_path
, source_buffer
,
493 source_size
, &handle
));
494 if (ret
!= EFI_SUCCESS
) {
495 log_err("Loading image failed\n");
499 /* Transfer environment variable as load options */
500 ret
= efi_env_set_load_options(handle
, "bootargs", &load_options
);
501 if (ret
!= EFI_SUCCESS
)
504 ret
= do_bootefi_exec(handle
, load_options
);
507 efi_delete_handle(mem_handle
);
508 efi_free_pool(file_path
);
512 #ifdef CONFIG_CMD_BOOTEFI_SELFTEST
513 static efi_status_t
bootefi_run_prepare(const char *load_options_path
,
514 struct efi_device_path
*device_path
,
515 struct efi_device_path
*image_path
,
516 struct efi_loaded_image_obj
**image_objp
,
517 struct efi_loaded_image
**loaded_image_infop
)
522 ret
= efi_setup_loaded_image(device_path
, image_path
, image_objp
,
524 if (ret
!= EFI_SUCCESS
)
527 /* Transfer environment variable as load options */
528 return efi_env_set_load_options((efi_handle_t
)*image_objp
,
534 * bootefi_test_prepare() - prepare to run an EFI test
536 * Prepare to run a test as if it were provided by a loaded image.
538 * @image_objp: pointer to be set to the loaded image handle
539 * @loaded_image_infop: pointer to be set to the loaded image protocol
540 * @path: dummy file path used to construct the device path
541 * set in the loaded image protocol
542 * @load_options_path: name of a U-Boot environment variable. Its value is
543 * set as load options in the loaded image protocol.
544 * Return: status code
546 static efi_status_t bootefi_test_prepare
547 (struct efi_loaded_image_obj
**image_objp
,
548 struct efi_loaded_image
**loaded_image_infop
, const char *path
,
549 const char *load_options_path
)
553 /* Construct a dummy device path */
554 bootefi_device_path
= efi_dp_from_mem(EFI_RESERVED_MEMORY_TYPE
, 0, 0);
555 if (!bootefi_device_path
)
556 return EFI_OUT_OF_RESOURCES
;
558 bootefi_image_path
= efi_dp_from_file(NULL
, 0, path
);
559 if (!bootefi_image_path
) {
560 ret
= EFI_OUT_OF_RESOURCES
;
564 ret
= bootefi_run_prepare(load_options_path
, bootefi_device_path
,
565 bootefi_image_path
, image_objp
,
567 if (ret
== EFI_SUCCESS
)
570 efi_free_pool(bootefi_image_path
);
571 bootefi_image_path
= NULL
;
573 efi_free_pool(bootefi_device_path
);
574 bootefi_device_path
= NULL
;
579 * bootefi_run_finish() - finish up after running an EFI test
581 * @loaded_image_info: Pointer to a struct which holds the loaded image info
582 * @image_obj: Pointer to a struct which holds the loaded image object
584 static void bootefi_run_finish(struct efi_loaded_image_obj
*image_obj
,
585 struct efi_loaded_image
*loaded_image_info
)
588 free(loaded_image_info
->load_options
);
589 efi_delete_handle(&image_obj
->header
);
593 * do_efi_selftest() - execute EFI selftest
595 * Return: status code
597 static int do_efi_selftest(void)
599 struct efi_loaded_image_obj
*image_obj
;
600 struct efi_loaded_image
*loaded_image_info
;
603 ret
= bootefi_test_prepare(&image_obj
, &loaded_image_info
,
604 "\\selftest", "efi_selftest");
605 if (ret
!= EFI_SUCCESS
)
606 return CMD_RET_FAILURE
;
608 /* Execute the test */
609 ret
= EFI_CALL(efi_selftest(&image_obj
->header
, &systab
));
610 bootefi_run_finish(image_obj
, loaded_image_info
);
612 return ret
!= EFI_SUCCESS
;
614 #endif /* CONFIG_CMD_BOOTEFI_SELFTEST */
617 * do_bootefi() - execute `bootefi` command
619 * @cmdtp: table entry describing command
620 * @flag: bitmap indicating how the command was invoked
621 * @argc: number of arguments
622 * @argv: command line arguments
623 * Return: status code
625 static int do_bootefi(struct cmd_tbl
*cmdtp
, int flag
, int argc
,
632 return CMD_RET_USAGE
;
634 /* Initialize EFI drivers */
635 ret
= efi_init_obj_list();
636 if (ret
!= EFI_SUCCESS
) {
637 log_err("Error: Cannot initialize UEFI sub-system, r = %lu\n",
638 ret
& ~EFI_ERROR_MASK
);
639 return CMD_RET_FAILURE
;
645 fdt_addr
= simple_strtoul(argv
[2], NULL
, 16);
646 fdt
= map_sysmem(fdt_addr
, 0);
648 fdt
= EFI_FDT_USE_INTERNAL
;
650 ret
= efi_install_fdt(fdt
);
651 if (ret
== EFI_INVALID_PARAMETER
)
652 return CMD_RET_USAGE
;
653 else if (ret
!= EFI_SUCCESS
)
654 return CMD_RET_FAILURE
;
656 if (!strcmp(argv
[1], "bootmgr"))
657 return do_efibootmgr();
658 #ifdef CONFIG_CMD_BOOTEFI_SELFTEST
659 else if (!strcmp(argv
[1], "selftest"))
660 return do_efi_selftest();
663 return do_bootefi_image(argv
[1]);
666 #ifdef CONFIG_SYS_LONGHELP
667 static char bootefi_help_text
[] =
668 "<image address> [fdt address]\n"
669 " - boot EFI payload stored at address <image address>.\n"
670 " If specified, the device tree located at <fdt address> gets\n"
671 " exposed as EFI configuration table.\n"
672 #ifdef CONFIG_CMD_BOOTEFI_HELLO
674 " - boot a sample Hello World application stored within U-Boot\n"
676 #ifdef CONFIG_CMD_BOOTEFI_SELFTEST
677 "bootefi selftest [fdt address]\n"
678 " - boot an EFI selftest application stored within U-Boot\n"
679 " Use environment variable efi_selftest to select a single test.\n"
680 " Use 'setenv efi_selftest list' to enumerate all tests.\n"
682 "bootefi bootmgr [fdt address]\n"
683 " - load and boot EFI payload based on BootOrder/BootXXXX variables.\n"
685 " If specified, the device tree located at <fdt address> gets\n"
686 " exposed as EFI configuration table.\n";
690 bootefi
, 3, 0, do_bootefi
,
691 "Boots an EFI payload from memory",
696 * efi_set_bootdev() - set boot device
698 * This function is called when a file is loaded, e.g. via the 'load' command.
699 * We use the path to this file to inform the UEFI binary about the boot device.
701 * @dev: device, e.g. "MMC"
702 * @devnr: number of the device, e.g. "1:2"
703 * @path: path to file loaded
705 void efi_set_bootdev(const char *dev
, const char *devnr
, const char *path
)
707 struct efi_device_path
*device
, *image
;
710 /* efi_set_bootdev is typically called repeatedly, recover memory */
711 efi_free_pool(bootefi_device_path
);
712 efi_free_pool(bootefi_image_path
);
714 ret
= efi_dp_from_name(dev
, devnr
, path
, &device
, &image
);
715 if (ret
== EFI_SUCCESS
) {
716 bootefi_device_path
= device
;
718 /* FIXME: image should not contain device */
719 struct efi_device_path
*image_tmp
= image
;
721 efi_dp_split_file_path(image
, &device
, &image
);
722 efi_free_pool(image_tmp
);
724 bootefi_image_path
= image
;
726 bootefi_device_path
= NULL
;
727 bootefi_image_path
= NULL
;