2018-05-08 06:02:21 +09:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+
|
2016-03-10 08:27:20 +09:00
|
|
|
/*
|
|
|
|
* EFI application loader
|
|
|
|
*
|
|
|
|
* Copyright (c) 2016 Alexander Graf
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <common.h>
|
2019-01-09 02:13:06 +09:00
|
|
|
#include <bootm.h>
|
|
|
|
#include <charset.h>
|
2016-03-10 08:27:20 +09:00
|
|
|
#include <command.h>
|
2017-05-18 08:18:03 +09:00
|
|
|
#include <dm.h>
|
2016-03-10 08:27:20 +09:00
|
|
|
#include <efi_loader.h>
|
2017-10-19 01:13:13 +09:00
|
|
|
#include <efi_selftest.h>
|
2016-03-10 08:27:20 +09:00
|
|
|
#include <errno.h>
|
2018-03-05 01:20:11 +09:00
|
|
|
#include <linux/libfdt.h>
|
|
|
|
#include <linux/libfdt_env.h>
|
2018-06-19 00:22:58 +09:00
|
|
|
#include <mapmem.h>
|
2016-04-12 06:51:01 +09:00
|
|
|
#include <memalign.h>
|
2016-04-11 23:55:26 +09:00
|
|
|
#include <asm/global_data.h>
|
2016-09-26 06:27:32 +09:00
|
|
|
#include <asm-generic/sections.h>
|
2018-04-04 04:59:32 +09:00
|
|
|
#include <asm-generic/unaligned.h>
|
2016-09-26 06:27:32 +09:00
|
|
|
#include <linux/linkage.h>
|
2016-04-11 23:55:26 +09:00
|
|
|
|
|
|
|
DECLARE_GLOBAL_DATA_PTR;
|
2016-03-10 08:27:20 +09:00
|
|
|
|
2017-09-14 07:05:33 +09:00
|
|
|
static struct efi_device_path *bootefi_image_path;
|
|
|
|
static struct efi_device_path *bootefi_device_path;
|
2016-03-10 08:27:20 +09:00
|
|
|
|
2018-04-04 04:59:32 +09:00
|
|
|
/*
|
|
|
|
* Allow unaligned memory access.
|
|
|
|
*
|
|
|
|
* This routine is overridden by architectures providing this feature.
|
|
|
|
*/
|
|
|
|
void __weak allow_unaligned(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2017-10-19 01:13:13 +09:00
|
|
|
/*
|
|
|
|
* Set the load options of an image from an environment variable.
|
|
|
|
*
|
|
|
|
* @loaded_image_info: the image
|
|
|
|
* @env_var: name of the environment variable
|
|
|
|
*/
|
|
|
|
static void set_load_options(struct efi_loaded_image *loaded_image_info,
|
|
|
|
const char *env_var)
|
|
|
|
{
|
|
|
|
size_t size;
|
|
|
|
const char *env = env_get(env_var);
|
2018-09-01 04:31:33 +09:00
|
|
|
u16 *pos;
|
2017-10-19 01:13:13 +09:00
|
|
|
|
|
|
|
loaded_image_info->load_options = NULL;
|
|
|
|
loaded_image_info->load_options_size = 0;
|
|
|
|
if (!env)
|
|
|
|
return;
|
2018-09-01 04:31:33 +09:00
|
|
|
size = utf8_utf16_strlen(env) + 1;
|
2017-10-19 01:13:13 +09:00
|
|
|
loaded_image_info->load_options = calloc(size, sizeof(u16));
|
|
|
|
if (!loaded_image_info->load_options) {
|
|
|
|
printf("ERROR: Out of memory\n");
|
|
|
|
return;
|
|
|
|
}
|
2018-09-01 04:31:33 +09:00
|
|
|
pos = loaded_image_info->load_options;
|
|
|
|
utf8_utf16_strcpy(&pos, env);
|
2017-10-19 01:13:13 +09:00
|
|
|
loaded_image_info->load_options_size = size * 2;
|
|
|
|
}
|
|
|
|
|
efi: sandbox: Tidy up copy_fdt() to work with sandbox
At present this function takes a pointer as its argument, then passes this
to efi_allocate_pages(), which actually takes an address. It uses casts,
which are not supported on sandbox.
Also the function calculates the FDT size rounded up to the neared EFI
page size, then its caller recalculates the size and adds a bit more to
it.
This function is much better written as something that works with
addresses only, and returns both the address and the size of the relocated
FDT.
Also, copy_fdt() returns NULL on error, but really should propagate the
error from efi_allocate_pages(). To do this it needs to return an
efi_status_t, not a void *.
Update the code in this way, so that it is easier to follow, and also
supports sandbox.
Signed-off-by: Simon Glass <sjg@chromium.org>
Signed-off-by: Alexander Graf <agraf@suse.de>
2018-08-08 18:54:30 +09:00
|
|
|
/**
|
|
|
|
* copy_fdt() - Copy the device tree to a new location available to EFI
|
|
|
|
*
|
2018-11-19 01:58:52 +09:00
|
|
|
* The FDT is copied to a suitable location within the EFI memory map.
|
2018-11-19 01:58:49 +09:00
|
|
|
* Additional 12 KiB are added to the space in case the device tree needs to be
|
efi: sandbox: Tidy up copy_fdt() to work with sandbox
At present this function takes a pointer as its argument, then passes this
to efi_allocate_pages(), which actually takes an address. It uses casts,
which are not supported on sandbox.
Also the function calculates the FDT size rounded up to the neared EFI
page size, then its caller recalculates the size and adds a bit more to
it.
This function is much better written as something that works with
addresses only, and returns both the address and the size of the relocated
FDT.
Also, copy_fdt() returns NULL on error, but really should propagate the
error from efi_allocate_pages(). To do this it needs to return an
efi_status_t, not a void *.
Update the code in this way, so that it is easier to follow, and also
supports sandbox.
Signed-off-by: Simon Glass <sjg@chromium.org>
Signed-off-by: Alexander Graf <agraf@suse.de>
2018-08-08 18:54:30 +09:00
|
|
|
* expanded later with fdt_open_into().
|
|
|
|
*
|
2018-11-19 01:58:52 +09:00
|
|
|
* @fdtp: On entry a pointer to the flattened device tree.
|
|
|
|
* On exit a pointer to the copy of the flattened device tree.
|
2018-11-13 02:55:22 +09:00
|
|
|
* FDT start
|
|
|
|
* Return: status code
|
efi: sandbox: Tidy up copy_fdt() to work with sandbox
At present this function takes a pointer as its argument, then passes this
to efi_allocate_pages(), which actually takes an address. It uses casts,
which are not supported on sandbox.
Also the function calculates the FDT size rounded up to the neared EFI
page size, then its caller recalculates the size and adds a bit more to
it.
This function is much better written as something that works with
addresses only, and returns both the address and the size of the relocated
FDT.
Also, copy_fdt() returns NULL on error, but really should propagate the
error from efi_allocate_pages(). To do this it needs to return an
efi_status_t, not a void *.
Update the code in this way, so that it is easier to follow, and also
supports sandbox.
Signed-off-by: Simon Glass <sjg@chromium.org>
Signed-off-by: Alexander Graf <agraf@suse.de>
2018-08-08 18:54:30 +09:00
|
|
|
*/
|
2018-11-19 01:58:52 +09:00
|
|
|
static efi_status_t copy_fdt(void **fdtp)
|
2016-04-11 23:55:26 +09:00
|
|
|
{
|
2016-04-12 06:51:01 +09:00
|
|
|
unsigned long fdt_ram_start = -1L, fdt_pages;
|
efi: sandbox: Tidy up copy_fdt() to work with sandbox
At present this function takes a pointer as its argument, then passes this
to efi_allocate_pages(), which actually takes an address. It uses casts,
which are not supported on sandbox.
Also the function calculates the FDT size rounded up to the neared EFI
page size, then its caller recalculates the size and adds a bit more to
it.
This function is much better written as something that works with
addresses only, and returns both the address and the size of the relocated
FDT.
Also, copy_fdt() returns NULL on error, but really should propagate the
error from efi_allocate_pages(). To do this it needs to return an
efi_status_t, not a void *.
Update the code in this way, so that it is easier to follow, and also
supports sandbox.
Signed-off-by: Simon Glass <sjg@chromium.org>
Signed-off-by: Alexander Graf <agraf@suse.de>
2018-08-08 18:54:30 +09:00
|
|
|
efi_status_t ret = 0;
|
|
|
|
void *fdt, *new_fdt;
|
2016-04-12 06:51:01 +09:00
|
|
|
u64 new_fdt_addr;
|
efi: sandbox: Tidy up copy_fdt() to work with sandbox
At present this function takes a pointer as its argument, then passes this
to efi_allocate_pages(), which actually takes an address. It uses casts,
which are not supported on sandbox.
Also the function calculates the FDT size rounded up to the neared EFI
page size, then its caller recalculates the size and adds a bit more to
it.
This function is much better written as something that works with
addresses only, and returns both the address and the size of the relocated
FDT.
Also, copy_fdt() returns NULL on error, but really should propagate the
error from efi_allocate_pages(). To do this it needs to return an
efi_status_t, not a void *.
Update the code in this way, so that it is easier to follow, and also
supports sandbox.
Signed-off-by: Simon Glass <sjg@chromium.org>
Signed-off-by: Alexander Graf <agraf@suse.de>
2018-08-08 18:54:30 +09:00
|
|
|
uint fdt_size;
|
2016-04-12 06:51:01 +09:00
|
|
|
int i;
|
2016-04-11 23:55:26 +09:00
|
|
|
|
efi: sandbox: Tidy up copy_fdt() to work with sandbox
At present this function takes a pointer as its argument, then passes this
to efi_allocate_pages(), which actually takes an address. It uses casts,
which are not supported on sandbox.
Also the function calculates the FDT size rounded up to the neared EFI
page size, then its caller recalculates the size and adds a bit more to
it.
This function is much better written as something that works with
addresses only, and returns both the address and the size of the relocated
FDT.
Also, copy_fdt() returns NULL on error, but really should propagate the
error from efi_allocate_pages(). To do this it needs to return an
efi_status_t, not a void *.
Update the code in this way, so that it is easier to follow, and also
supports sandbox.
Signed-off-by: Simon Glass <sjg@chromium.org>
Signed-off-by: Alexander Graf <agraf@suse.de>
2018-08-08 18:54:30 +09:00
|
|
|
for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) {
|
|
|
|
u64 ram_start = gd->bd->bi_dram[i].start;
|
|
|
|
u64 ram_size = gd->bd->bi_dram[i].size;
|
2016-04-11 23:55:26 +09:00
|
|
|
|
2016-04-12 06:51:01 +09:00
|
|
|
if (!ram_size)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (ram_start < fdt_ram_start)
|
|
|
|
fdt_ram_start = ram_start;
|
|
|
|
}
|
|
|
|
|
2018-06-18 23:08:25 +09:00
|
|
|
/*
|
2018-11-19 01:58:49 +09:00
|
|
|
* Give us at least 12 KiB of breathing room in case the device tree
|
|
|
|
* needs to be expanded later.
|
2018-06-18 23:08:25 +09:00
|
|
|
*/
|
2018-11-19 01:58:52 +09:00
|
|
|
fdt = *fdtp;
|
2018-11-19 01:58:49 +09:00
|
|
|
fdt_pages = efi_size_in_pages(fdt_totalsize(fdt) + 0x3000);
|
|
|
|
fdt_size = fdt_pages << EFI_PAGE_SHIFT;
|
2016-04-12 06:51:01 +09:00
|
|
|
|
2018-11-19 01:58:52 +09:00
|
|
|
/*
|
|
|
|
* Safe fdt location is at 127 MiB.
|
|
|
|
* On the sandbox convert from the sandbox address space.
|
|
|
|
*/
|
|
|
|
new_fdt_addr = (uintptr_t)map_sysmem(fdt_ram_start + 0x7f00000 +
|
|
|
|
fdt_size, 0);
|
efi: sandbox: Tidy up copy_fdt() to work with sandbox
At present this function takes a pointer as its argument, then passes this
to efi_allocate_pages(), which actually takes an address. It uses casts,
which are not supported on sandbox.
Also the function calculates the FDT size rounded up to the neared EFI
page size, then its caller recalculates the size and adds a bit more to
it.
This function is much better written as something that works with
addresses only, and returns both the address and the size of the relocated
FDT.
Also, copy_fdt() returns NULL on error, but really should propagate the
error from efi_allocate_pages(). To do this it needs to return an
efi_status_t, not a void *.
Update the code in this way, so that it is easier to follow, and also
supports sandbox.
Signed-off-by: Simon Glass <sjg@chromium.org>
Signed-off-by: Alexander Graf <agraf@suse.de>
2018-08-08 18:54:30 +09:00
|
|
|
ret = efi_allocate_pages(EFI_ALLOCATE_MAX_ADDRESS,
|
|
|
|
EFI_RUNTIME_SERVICES_DATA, fdt_pages,
|
|
|
|
&new_fdt_addr);
|
|
|
|
if (ret != EFI_SUCCESS) {
|
2016-04-12 06:51:01 +09:00
|
|
|
/* If we can't put it there, put it somewhere */
|
2017-08-12 04:19:25 +09:00
|
|
|
new_fdt_addr = (ulong)memalign(EFI_PAGE_SIZE, fdt_size);
|
efi: sandbox: Tidy up copy_fdt() to work with sandbox
At present this function takes a pointer as its argument, then passes this
to efi_allocate_pages(), which actually takes an address. It uses casts,
which are not supported on sandbox.
Also the function calculates the FDT size rounded up to the neared EFI
page size, then its caller recalculates the size and adds a bit more to
it.
This function is much better written as something that works with
addresses only, and returns both the address and the size of the relocated
FDT.
Also, copy_fdt() returns NULL on error, but really should propagate the
error from efi_allocate_pages(). To do this it needs to return an
efi_status_t, not a void *.
Update the code in this way, so that it is easier to follow, and also
supports sandbox.
Signed-off-by: Simon Glass <sjg@chromium.org>
Signed-off-by: Alexander Graf <agraf@suse.de>
2018-08-08 18:54:30 +09:00
|
|
|
ret = efi_allocate_pages(EFI_ALLOCATE_MAX_ADDRESS,
|
|
|
|
EFI_RUNTIME_SERVICES_DATA, fdt_pages,
|
|
|
|
&new_fdt_addr);
|
|
|
|
if (ret != EFI_SUCCESS) {
|
2017-07-03 20:32:35 +09:00
|
|
|
printf("ERROR: Failed to reserve space for FDT\n");
|
efi: sandbox: Tidy up copy_fdt() to work with sandbox
At present this function takes a pointer as its argument, then passes this
to efi_allocate_pages(), which actually takes an address. It uses casts,
which are not supported on sandbox.
Also the function calculates the FDT size rounded up to the neared EFI
page size, then its caller recalculates the size and adds a bit more to
it.
This function is much better written as something that works with
addresses only, and returns both the address and the size of the relocated
FDT.
Also, copy_fdt() returns NULL on error, but really should propagate the
error from efi_allocate_pages(). To do this it needs to return an
efi_status_t, not a void *.
Update the code in this way, so that it is easier to follow, and also
supports sandbox.
Signed-off-by: Simon Glass <sjg@chromium.org>
Signed-off-by: Alexander Graf <agraf@suse.de>
2018-08-08 18:54:30 +09:00
|
|
|
goto done;
|
2017-07-03 20:32:35 +09:00
|
|
|
}
|
2016-04-12 06:51:01 +09:00
|
|
|
}
|
2018-11-19 01:58:52 +09:00
|
|
|
new_fdt = (void *)(uintptr_t)new_fdt_addr;
|
2016-04-11 23:55:26 +09:00
|
|
|
memcpy(new_fdt, fdt, fdt_totalsize(fdt));
|
|
|
|
fdt_set_totalsize(new_fdt, fdt_size);
|
|
|
|
|
2018-11-19 01:58:52 +09:00
|
|
|
*fdtp = (void *)(uintptr_t)new_fdt_addr;
|
efi: sandbox: Tidy up copy_fdt() to work with sandbox
At present this function takes a pointer as its argument, then passes this
to efi_allocate_pages(), which actually takes an address. It uses casts,
which are not supported on sandbox.
Also the function calculates the FDT size rounded up to the neared EFI
page size, then its caller recalculates the size and adds a bit more to
it.
This function is much better written as something that works with
addresses only, and returns both the address and the size of the relocated
FDT.
Also, copy_fdt() returns NULL on error, but really should propagate the
error from efi_allocate_pages(). To do this it needs to return an
efi_status_t, not a void *.
Update the code in this way, so that it is easier to follow, and also
supports sandbox.
Signed-off-by: Simon Glass <sjg@chromium.org>
Signed-off-by: Alexander Graf <agraf@suse.de>
2018-08-08 18:54:30 +09:00
|
|
|
done:
|
|
|
|
return ret;
|
2016-04-11 23:55:26 +09:00
|
|
|
}
|
|
|
|
|
2017-10-19 01:13:08 +09:00
|
|
|
static efi_status_t efi_do_enter(
|
2018-01-11 16:16:09 +09:00
|
|
|
efi_handle_t image_handle, struct efi_system_table *st,
|
2018-01-24 08:18:08 +09:00
|
|
|
EFIAPI efi_status_t (*entry)(
|
|
|
|
efi_handle_t image_handle,
|
|
|
|
struct efi_system_table *st))
|
2017-07-05 06:15:21 +09:00
|
|
|
{
|
|
|
|
efi_status_t ret = EFI_LOAD_ERROR;
|
|
|
|
|
|
|
|
if (entry)
|
|
|
|
ret = entry(image_handle, st);
|
|
|
|
st->boottime->exit(image_handle, ret, 0, NULL);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2018-06-18 23:08:28 +09:00
|
|
|
/*
|
|
|
|
* efi_carve_out_dt_rsv() - Carve out DT reserved memory ranges
|
|
|
|
*
|
|
|
|
* The mem_rsv entries of the FDT are added to the memory map. Any failures are
|
|
|
|
* ignored because this is not critical and we would rather continue to try to
|
|
|
|
* boot.
|
|
|
|
*
|
|
|
|
* @fdt: Pointer to device tree
|
|
|
|
*/
|
|
|
|
static void efi_carve_out_dt_rsv(void *fdt)
|
2018-04-06 16:40:51 +09:00
|
|
|
{
|
|
|
|
int nr_rsv, i;
|
|
|
|
uint64_t addr, size, pages;
|
|
|
|
|
|
|
|
nr_rsv = fdt_num_mem_rsv(fdt);
|
|
|
|
|
|
|
|
/* Look for an existing entry and add it to the efi mem map. */
|
|
|
|
for (i = 0; i < nr_rsv; i++) {
|
|
|
|
if (fdt_get_mem_rsv(fdt, i, &addr, &size) != 0)
|
|
|
|
continue;
|
|
|
|
|
2018-11-19 01:58:52 +09:00
|
|
|
/* Convert from sandbox address space. */
|
|
|
|
addr = (uintptr_t)map_sysmem(addr, 0);
|
|
|
|
|
2018-11-19 01:58:49 +09:00
|
|
|
pages = efi_size_in_pages(size + (addr & EFI_PAGE_MASK));
|
2018-11-13 02:55:23 +09:00
|
|
|
addr &= ~EFI_PAGE_MASK;
|
2018-06-18 23:08:28 +09:00
|
|
|
if (!efi_add_memory_map(addr, pages, EFI_RESERVED_MEMORY_TYPE,
|
|
|
|
false))
|
|
|
|
printf("FDT memrsv map %d: Failed to add to map\n", i);
|
2018-04-06 16:40:51 +09:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
efi: sandbox: Tidy up copy_fdt() to work with sandbox
At present this function takes a pointer as its argument, then passes this
to efi_allocate_pages(), which actually takes an address. It uses casts,
which are not supported on sandbox.
Also the function calculates the FDT size rounded up to the neared EFI
page size, then its caller recalculates the size and adds a bit more to
it.
This function is much better written as something that works with
addresses only, and returns both the address and the size of the relocated
FDT.
Also, copy_fdt() returns NULL on error, but really should propagate the
error from efi_allocate_pages(). To do this it needs to return an
efi_status_t, not a void *.
Update the code in this way, so that it is easier to follow, and also
supports sandbox.
Signed-off-by: Simon Glass <sjg@chromium.org>
Signed-off-by: Alexander Graf <agraf@suse.de>
2018-08-08 18:54:30 +09:00
|
|
|
static efi_status_t efi_install_fdt(ulong fdt_addr)
|
2018-03-03 23:29:03 +09:00
|
|
|
{
|
|
|
|
bootm_headers_t img = { 0 };
|
|
|
|
efi_status_t ret;
|
efi: sandbox: Tidy up copy_fdt() to work with sandbox
At present this function takes a pointer as its argument, then passes this
to efi_allocate_pages(), which actually takes an address. It uses casts,
which are not supported on sandbox.
Also the function calculates the FDT size rounded up to the neared EFI
page size, then its caller recalculates the size and adds a bit more to
it.
This function is much better written as something that works with
addresses only, and returns both the address and the size of the relocated
FDT.
Also, copy_fdt() returns NULL on error, but really should propagate the
error from efi_allocate_pages(). To do this it needs to return an
efi_status_t, not a void *.
Update the code in this way, so that it is easier to follow, and also
supports sandbox.
Signed-off-by: Simon Glass <sjg@chromium.org>
Signed-off-by: Alexander Graf <agraf@suse.de>
2018-08-08 18:54:30 +09:00
|
|
|
void *fdt;
|
2018-03-03 23:29:03 +09:00
|
|
|
|
efi: sandbox: Tidy up copy_fdt() to work with sandbox
At present this function takes a pointer as its argument, then passes this
to efi_allocate_pages(), which actually takes an address. It uses casts,
which are not supported on sandbox.
Also the function calculates the FDT size rounded up to the neared EFI
page size, then its caller recalculates the size and adds a bit more to
it.
This function is much better written as something that works with
addresses only, and returns both the address and the size of the relocated
FDT.
Also, copy_fdt() returns NULL on error, but really should propagate the
error from efi_allocate_pages(). To do this it needs to return an
efi_status_t, not a void *.
Update the code in this way, so that it is easier to follow, and also
supports sandbox.
Signed-off-by: Simon Glass <sjg@chromium.org>
Signed-off-by: Alexander Graf <agraf@suse.de>
2018-08-08 18:54:30 +09:00
|
|
|
fdt = map_sysmem(fdt_addr, 0);
|
2018-03-03 23:29:03 +09:00
|
|
|
if (fdt_check_header(fdt)) {
|
|
|
|
printf("ERROR: invalid device tree\n");
|
|
|
|
return EFI_INVALID_PARAMETER;
|
|
|
|
}
|
|
|
|
|
2018-11-19 01:58:53 +09:00
|
|
|
/* Create memory reservation as indicated by the device tree */
|
|
|
|
efi_carve_out_dt_rsv(fdt);
|
|
|
|
|
2018-03-03 23:29:03 +09:00
|
|
|
/* Prepare fdt for payload */
|
2018-11-19 01:58:52 +09:00
|
|
|
ret = copy_fdt(&fdt);
|
efi: sandbox: Tidy up copy_fdt() to work with sandbox
At present this function takes a pointer as its argument, then passes this
to efi_allocate_pages(), which actually takes an address. It uses casts,
which are not supported on sandbox.
Also the function calculates the FDT size rounded up to the neared EFI
page size, then its caller recalculates the size and adds a bit more to
it.
This function is much better written as something that works with
addresses only, and returns both the address and the size of the relocated
FDT.
Also, copy_fdt() returns NULL on error, but really should propagate the
error from efi_allocate_pages(). To do this it needs to return an
efi_status_t, not a void *.
Update the code in this way, so that it is easier to follow, and also
supports sandbox.
Signed-off-by: Simon Glass <sjg@chromium.org>
Signed-off-by: Alexander Graf <agraf@suse.de>
2018-08-08 18:54:30 +09:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2018-03-03 23:29:03 +09:00
|
|
|
|
|
|
|
if (image_setup_libfdt(&img, fdt, 0, NULL)) {
|
|
|
|
printf("ERROR: failed to process device tree\n");
|
|
|
|
return EFI_LOAD_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Link to it in the efi tables */
|
|
|
|
ret = efi_install_configuration_table(&efi_guid_fdt, fdt);
|
|
|
|
if (ret != EFI_SUCCESS)
|
|
|
|
return EFI_OUT_OF_RESOURCES;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2018-11-26 12:14:38 +09:00
|
|
|
static efi_status_t bootefi_run_prepare(const char *load_options_path,
|
|
|
|
struct efi_device_path *device_path,
|
|
|
|
struct efi_device_path *image_path,
|
|
|
|
struct efi_loaded_image_obj **image_objp,
|
|
|
|
struct efi_loaded_image **loaded_image_infop)
|
|
|
|
{
|
|
|
|
efi_status_t ret;
|
|
|
|
|
|
|
|
ret = efi_setup_loaded_image(device_path, image_path, image_objp,
|
|
|
|
loaded_image_infop);
|
|
|
|
if (ret != EFI_SUCCESS)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/* Transfer environment variable as load options */
|
|
|
|
set_load_options(*loaded_image_infop, load_options_path);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-11-26 12:14:39 +09:00
|
|
|
/**
|
|
|
|
* bootefi_run_finish() - finish up after running an EFI test
|
|
|
|
*
|
|
|
|
* @loaded_image_info: Pointer to a struct which holds the loaded image info
|
|
|
|
* @image_objj: Pointer to a struct which holds the loaded image object
|
|
|
|
*/
|
|
|
|
static void bootefi_run_finish(struct efi_loaded_image_obj *image_obj,
|
|
|
|
struct efi_loaded_image *loaded_image_info)
|
|
|
|
{
|
|
|
|
efi_restore_gd();
|
|
|
|
free(loaded_image_info->load_options);
|
|
|
|
efi_delete_handle(&image_obj->header);
|
|
|
|
}
|
|
|
|
|
2018-09-24 00:21:51 +09:00
|
|
|
/**
|
|
|
|
* do_bootefi_exec() - execute EFI binary
|
|
|
|
*
|
|
|
|
* @efi: address of the binary
|
|
|
|
* @device_path: path of the device from which the binary was loaded
|
|
|
|
* @image_path: device path of the binary
|
|
|
|
* Return: status code
|
|
|
|
*
|
|
|
|
* Load the EFI binary into a newly assigned memory unwinding the relocation
|
|
|
|
* information, install the loaded image protocol, and call the binary.
|
2016-03-10 08:27:20 +09:00
|
|
|
*/
|
2018-03-03 23:29:03 +09:00
|
|
|
static efi_status_t do_bootefi_exec(void *efi,
|
2017-10-19 01:13:08 +09:00
|
|
|
struct efi_device_path *device_path,
|
|
|
|
struct efi_device_path *image_path)
|
2016-03-10 08:27:20 +09:00
|
|
|
{
|
2018-09-16 14:19:48 +09:00
|
|
|
efi_handle_t mem_handle = NULL;
|
2017-10-10 21:23:06 +09:00
|
|
|
struct efi_device_path *memdp = NULL;
|
2018-03-03 23:29:01 +09:00
|
|
|
efi_status_t ret;
|
2018-09-26 12:27:54 +09:00
|
|
|
struct efi_loaded_image_obj *image_obj = NULL;
|
2018-09-24 00:21:51 +09:00
|
|
|
struct efi_loaded_image *loaded_image_info = NULL;
|
2017-09-14 07:05:33 +09:00
|
|
|
|
2018-01-24 08:18:08 +09:00
|
|
|
EFIAPI efi_status_t (*entry)(efi_handle_t image_handle,
|
|
|
|
struct efi_system_table *st);
|
2016-03-10 08:27:20 +09:00
|
|
|
|
2017-10-10 21:23:06 +09:00
|
|
|
/*
|
|
|
|
* Special case for efi payload not loaded from disk, such as
|
|
|
|
* 'bootefi hello' or for example payload loaded directly into
|
2018-10-19 04:51:38 +09:00
|
|
|
* memory via JTAG, etc:
|
2017-10-10 21:23:06 +09:00
|
|
|
*/
|
|
|
|
if (!device_path && !image_path) {
|
|
|
|
printf("WARNING: using memory device/image path, this may confuse some payloads!\n");
|
|
|
|
/* actual addresses filled in after efi_load_pe() */
|
2018-12-27 06:23:00 +09:00
|
|
|
memdp = efi_dp_from_mem(EFI_RESERVED_MEMORY_TYPE, 0, 0);
|
2017-10-10 21:23:06 +09:00
|
|
|
device_path = image_path = memdp;
|
2018-09-16 14:19:48 +09:00
|
|
|
/*
|
|
|
|
* Grub expects that the device path of the loaded image is
|
|
|
|
* installed on a handle.
|
|
|
|
*/
|
|
|
|
ret = efi_create_handle(&mem_handle);
|
|
|
|
if (ret != EFI_SUCCESS)
|
2018-11-26 12:14:39 +09:00
|
|
|
return ret; /* TODO: leaks device_path */
|
2018-09-16 14:19:48 +09:00
|
|
|
ret = efi_add_protocol(mem_handle, &efi_guid_device_path,
|
2018-06-12 17:21:16 +09:00
|
|
|
device_path);
|
|
|
|
if (ret != EFI_SUCCESS)
|
2018-11-26 12:14:39 +09:00
|
|
|
goto err_add_protocol;
|
2017-10-10 21:23:06 +09:00
|
|
|
} else {
|
|
|
|
assert(device_path && image_path);
|
|
|
|
}
|
|
|
|
|
2018-11-26 12:14:38 +09:00
|
|
|
ret = bootefi_run_prepare("bootargs", device_path, image_path,
|
|
|
|
&image_obj, &loaded_image_info);
|
|
|
|
if (ret)
|
2018-11-26 12:14:39 +09:00
|
|
|
goto err_prepare;
|
2017-09-14 07:05:33 +09:00
|
|
|
|
2016-03-10 08:27:20 +09:00
|
|
|
/* Load the EFI payload */
|
2018-09-26 12:27:54 +09:00
|
|
|
entry = efi_load_pe(image_obj, efi, loaded_image_info);
|
2017-09-14 07:05:33 +09:00
|
|
|
if (!entry) {
|
2018-03-03 23:29:01 +09:00
|
|
|
ret = EFI_LOAD_ERROR;
|
2018-11-26 12:14:39 +09:00
|
|
|
goto err_prepare;
|
2017-09-14 07:05:33 +09:00
|
|
|
}
|
2016-08-17 04:08:45 +09:00
|
|
|
|
2017-10-10 21:23:06 +09:00
|
|
|
if (memdp) {
|
|
|
|
struct efi_device_path_memory *mdp = (void *)memdp;
|
2018-09-24 00:21:51 +09:00
|
|
|
mdp->memory_type = loaded_image_info->image_code_type;
|
|
|
|
mdp->start_address = (uintptr_t)loaded_image_info->image_base;
|
2017-10-10 21:23:06 +09:00
|
|
|
mdp->end_address = mdp->start_address +
|
2018-09-24 00:21:51 +09:00
|
|
|
loaded_image_info->image_size;
|
2017-10-10 21:23:06 +09:00
|
|
|
}
|
|
|
|
|
efi_loader: efi variable support
Add EFI variable support, mapping to u-boot environment variables.
Variables are pretty important for setting up boot order, among other
things. If the board supports saveenv, then it will be called in
ExitBootServices() to persist variables set by the efi payload. (For
example, fallback.efi configuring BootOrder and BootXXXX load-option
variables.)
Variables are *not* currently exposed at runtime, post ExitBootServices.
On boards without a dedicated device for storage, which the loaded OS
is not trying to also use, this is rather tricky. One idea, at least
for boards that can persist RAM across reboot, is to keep a "journal"
of modified variables in RAM, and then turn halt into a reboot into
u-boot, plus store variables, plus halt. Whatever the solution, it
likely involves some per-board support.
Mapping between EFI variables and u-boot variables:
efi_$guid_$varname = {attributes}(type)value
For example:
efi_8be4df61-93ca-11d2-aa0d-00e098032b8c_OsIndicationsSupported=
"{ro,boot,run}(blob)0000000000000000"
efi_8be4df61-93ca-11d2-aa0d-00e098032b8c_BootOrder=
"(blob)00010000"
The attributes are a comma separated list of these possible
attributes:
+ ro - read-only
+ boot - boot-services access
+ run - runtime access
NOTE: with current implementation, no variables are available after
ExitBootServices, and all are persisted (if possible).
If not specified, the attributes default to "{boot}".
The required type is one of:
+ utf8 - raw utf8 string
+ blob - arbitrary length hex string
Signed-off-by: Rob Clark <robdclark@gmail.com>
Signed-off-by: Alexander Graf <agraf@suse.de>
2017-09-14 07:05:37 +09:00
|
|
|
/* we don't support much: */
|
|
|
|
env_set("efi_8be4df61-93ca-11d2-aa0d-00e098032b8c_OsIndicationsSupported",
|
|
|
|
"{ro,boot}(blob)0000000000000000");
|
|
|
|
|
2016-03-10 08:27:20 +09:00
|
|
|
/* Call our payload! */
|
2018-12-28 20:41:14 +09:00
|
|
|
debug("%s: Jumping to 0x%p\n", __func__, entry);
|
2016-05-21 06:28:23 +09:00
|
|
|
|
2018-09-26 12:27:54 +09:00
|
|
|
if (setjmp(&image_obj->exit_jmp)) {
|
|
|
|
ret = image_obj->exit_status;
|
2018-11-26 12:14:39 +09:00
|
|
|
goto err_prepare;
|
2016-05-21 06:28:23 +09:00
|
|
|
}
|
|
|
|
|
2018-09-26 12:27:56 +09:00
|
|
|
ret = efi_do_enter(&image_obj->header, &systab, entry);
|
2017-09-14 07:05:33 +09:00
|
|
|
|
2018-11-26 12:14:39 +09:00
|
|
|
err_prepare:
|
2017-09-14 07:05:33 +09:00
|
|
|
/* image has returned, loaded-image obj goes *poof*: */
|
2018-11-26 12:14:39 +09:00
|
|
|
bootefi_run_finish(image_obj, loaded_image_info);
|
|
|
|
|
|
|
|
err_add_protocol:
|
2018-09-16 14:19:48 +09:00
|
|
|
if (mem_handle)
|
|
|
|
efi_delete_handle(mem_handle);
|
2017-09-14 07:05:33 +09:00
|
|
|
|
|
|
|
return ret;
|
2016-03-10 08:27:20 +09:00
|
|
|
}
|
|
|
|
|
2018-11-26 12:14:37 +09:00
|
|
|
#ifdef CONFIG_CMD_BOOTEFI_SELFTEST
|
|
|
|
/**
|
|
|
|
* bootefi_test_prepare() - prepare to run an EFI test
|
|
|
|
*
|
|
|
|
* This sets things up so we can call EFI functions. This involves preparing
|
|
|
|
* the 'gd' pointer and setting up the load ed image data structures.
|
|
|
|
*
|
|
|
|
* @image_objp: loaded_image_infop: Pointer to a struct which will hold the
|
|
|
|
* loaded image object. This struct will be inited by this function before
|
|
|
|
* use.
|
|
|
|
* @loaded_image_infop: Pointer to a struct which will hold the loaded image
|
|
|
|
* info. This struct will be inited by this function before use.
|
|
|
|
* @path: File path to the test being run (often just the test name with a
|
|
|
|
* backslash before it
|
|
|
|
* @test_func: Address of the test function that is being run
|
2018-11-26 12:14:38 +09:00
|
|
|
* @load_options_path: U-Boot environment variable to use as load options
|
2018-11-26 12:14:37 +09:00
|
|
|
* @return 0 if OK, -ve on error
|
|
|
|
*/
|
|
|
|
static efi_status_t bootefi_test_prepare
|
|
|
|
(struct efi_loaded_image_obj **image_objp,
|
2018-11-26 12:14:38 +09:00
|
|
|
struct efi_loaded_image **loaded_image_infop, const char *path,
|
|
|
|
ulong test_func, const char *load_options_path)
|
2018-11-26 12:14:37 +09:00
|
|
|
{
|
|
|
|
/* Construct a dummy device path */
|
|
|
|
bootefi_device_path = efi_dp_from_mem(EFI_RESERVED_MEMORY_TYPE,
|
|
|
|
(uintptr_t)test_func,
|
|
|
|
(uintptr_t)test_func);
|
|
|
|
if (!bootefi_device_path)
|
|
|
|
return EFI_OUT_OF_RESOURCES;
|
|
|
|
bootefi_image_path = efi_dp_from_file(NULL, 0, path);
|
|
|
|
if (!bootefi_image_path)
|
|
|
|
return EFI_OUT_OF_RESOURCES;
|
|
|
|
|
2018-11-26 12:14:38 +09:00
|
|
|
return bootefi_run_prepare(load_options_path, bootefi_device_path,
|
|
|
|
bootefi_image_path, image_objp,
|
|
|
|
loaded_image_infop);
|
2018-11-26 12:14:37 +09:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* CONFIG_CMD_BOOTEFI_SELFTEST */
|
|
|
|
|
2018-03-03 23:29:03 +09:00
|
|
|
static int do_bootefi_bootmgr_exec(void)
|
2017-09-14 07:05:38 +09:00
|
|
|
{
|
|
|
|
struct efi_device_path *device_path, *file_path;
|
|
|
|
void *addr;
|
|
|
|
efi_status_t r;
|
|
|
|
|
|
|
|
addr = efi_bootmgr_load(&device_path, &file_path);
|
|
|
|
if (!addr)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
printf("## Starting EFI application at %p ...\n", addr);
|
2018-03-03 23:29:03 +09:00
|
|
|
r = do_bootefi_exec(addr, device_path, file_path);
|
2017-09-14 07:05:38 +09:00
|
|
|
printf("## Application terminated, r = %lu\n",
|
|
|
|
r & ~EFI_ERROR_MASK);
|
|
|
|
|
|
|
|
if (r != EFI_SUCCESS)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-03-10 08:27:20 +09:00
|
|
|
/* Interpreter command to boot an arbitrary EFI image from memory */
|
|
|
|
static int do_bootefi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
|
|
|
|
{
|
2018-03-03 23:29:03 +09:00
|
|
|
unsigned long addr;
|
|
|
|
char *saddr;
|
2017-10-19 01:13:08 +09:00
|
|
|
efi_status_t r;
|
2018-06-19 00:22:58 +09:00
|
|
|
unsigned long fdt_addr;
|
2016-03-10 08:27:20 +09:00
|
|
|
|
2018-04-04 04:59:32 +09:00
|
|
|
/* Allow unaligned memory access */
|
|
|
|
allow_unaligned();
|
|
|
|
|
2019-01-09 02:13:06 +09:00
|
|
|
switch_to_non_secure_mode();
|
|
|
|
|
2018-03-03 23:29:02 +09:00
|
|
|
/* Initialize EFI drivers */
|
|
|
|
r = efi_init_obj_list();
|
|
|
|
if (r != EFI_SUCCESS) {
|
|
|
|
printf("Error: Cannot set up EFI drivers, r = %lu\n",
|
|
|
|
r & ~EFI_ERROR_MASK);
|
|
|
|
return CMD_RET_FAILURE;
|
|
|
|
}
|
|
|
|
|
2016-03-10 08:27:20 +09:00
|
|
|
if (argc < 2)
|
2016-08-13 20:02:06 +09:00
|
|
|
return CMD_RET_USAGE;
|
2018-03-03 23:29:03 +09:00
|
|
|
|
|
|
|
if (argc > 2) {
|
2018-06-19 00:22:58 +09:00
|
|
|
fdt_addr = simple_strtoul(argv[2], NULL, 16);
|
2018-03-03 23:29:03 +09:00
|
|
|
if (!fdt_addr && *argv[2] != '0')
|
|
|
|
return CMD_RET_USAGE;
|
|
|
|
/* Install device tree */
|
efi: sandbox: Tidy up copy_fdt() to work with sandbox
At present this function takes a pointer as its argument, then passes this
to efi_allocate_pages(), which actually takes an address. It uses casts,
which are not supported on sandbox.
Also the function calculates the FDT size rounded up to the neared EFI
page size, then its caller recalculates the size and adds a bit more to
it.
This function is much better written as something that works with
addresses only, and returns both the address and the size of the relocated
FDT.
Also, copy_fdt() returns NULL on error, but really should propagate the
error from efi_allocate_pages(). To do this it needs to return an
efi_status_t, not a void *.
Update the code in this way, so that it is easier to follow, and also
supports sandbox.
Signed-off-by: Simon Glass <sjg@chromium.org>
Signed-off-by: Alexander Graf <agraf@suse.de>
2018-08-08 18:54:30 +09:00
|
|
|
r = efi_install_fdt(fdt_addr);
|
2018-03-03 23:29:03 +09:00
|
|
|
if (r != EFI_SUCCESS) {
|
|
|
|
printf("ERROR: failed to install device tree\n");
|
|
|
|
return CMD_RET_FAILURE;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* Remove device tree. EFI_NOT_FOUND can be ignored here */
|
|
|
|
efi_install_configuration_table(&efi_guid_fdt, NULL);
|
|
|
|
printf("WARNING: booting without device tree\n");
|
|
|
|
}
|
2016-11-08 00:47:08 +09:00
|
|
|
#ifdef CONFIG_CMD_BOOTEFI_HELLO
|
|
|
|
if (!strcmp(argv[1], "hello")) {
|
2017-09-05 10:19:37 +09:00
|
|
|
ulong size = __efi_helloworld_end - __efi_helloworld_begin;
|
2016-03-10 08:27:20 +09:00
|
|
|
|
2017-08-29 01:54:30 +09:00
|
|
|
saddr = env_get("loadaddr");
|
|
|
|
if (saddr)
|
|
|
|
addr = simple_strtoul(saddr, NULL, 16);
|
|
|
|
else
|
|
|
|
addr = CONFIG_SYS_LOAD_ADDR;
|
2018-06-19 00:22:58 +09:00
|
|
|
memcpy(map_sysmem(addr, size), __efi_helloworld_begin, size);
|
2016-11-08 00:47:08 +09:00
|
|
|
} else
|
2017-09-15 17:06:11 +09:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_CMD_BOOTEFI_SELFTEST
|
|
|
|
if (!strcmp(argv[1], "selftest")) {
|
2018-09-26 12:27:54 +09:00
|
|
|
struct efi_loaded_image_obj *image_obj;
|
2018-09-24 00:21:51 +09:00
|
|
|
struct efi_loaded_image *loaded_image_info;
|
2017-09-21 05:54:58 +09:00
|
|
|
|
2018-11-26 12:14:37 +09:00
|
|
|
if (bootefi_test_prepare(&image_obj, &loaded_image_info,
|
2018-11-26 12:14:38 +09:00
|
|
|
"\\selftest", (uintptr_t)&efi_selftest,
|
|
|
|
"efi_selftest"))
|
2018-11-26 12:14:36 +09:00
|
|
|
return CMD_RET_FAILURE;
|
2017-10-19 01:13:09 +09:00
|
|
|
|
2017-10-19 01:13:13 +09:00
|
|
|
/* Execute the test */
|
2018-09-26 12:27:56 +09:00
|
|
|
r = efi_selftest(&image_obj->header, &systab);
|
2018-11-26 12:14:39 +09:00
|
|
|
bootefi_run_finish(image_obj, loaded_image_info);
|
2017-10-19 01:13:14 +09:00
|
|
|
return r != EFI_SUCCESS;
|
2017-09-15 17:06:11 +09:00
|
|
|
} else
|
2016-11-08 00:47:08 +09:00
|
|
|
#endif
|
2017-09-14 07:05:38 +09:00
|
|
|
if (!strcmp(argv[1], "bootmgr")) {
|
2018-03-03 23:29:03 +09:00
|
|
|
return do_bootefi_bootmgr_exec();
|
2017-09-14 07:05:38 +09:00
|
|
|
} else {
|
2016-11-08 00:47:08 +09:00
|
|
|
saddr = argv[1];
|
2016-03-10 08:27:20 +09:00
|
|
|
|
2016-11-08 00:47:08 +09:00
|
|
|
addr = simple_strtoul(saddr, NULL, 16);
|
2018-01-25 04:33:54 +09:00
|
|
|
/* Check that a numeric value was passed */
|
|
|
|
if (!addr && *saddr != '0')
|
|
|
|
return CMD_RET_USAGE;
|
2016-11-08 00:47:08 +09:00
|
|
|
|
2016-04-14 23:07:53 +09:00
|
|
|
}
|
|
|
|
|
2016-11-08 00:47:05 +09:00
|
|
|
printf("## Starting EFI application at %08lx ...\n", addr);
|
2018-06-19 00:22:58 +09:00
|
|
|
r = do_bootefi_exec(map_sysmem(addr, 0), bootefi_device_path,
|
2018-03-03 23:29:03 +09:00
|
|
|
bootefi_image_path);
|
2017-07-05 06:15:23 +09:00
|
|
|
printf("## Application terminated, r = %lu\n",
|
|
|
|
r & ~EFI_ERROR_MASK);
|
2016-03-10 08:27:20 +09:00
|
|
|
|
2017-07-05 06:15:23 +09:00
|
|
|
if (r != EFI_SUCCESS)
|
|
|
|
return 1;
|
|
|
|
else
|
|
|
|
return 0;
|
2016-03-10 08:27:20 +09:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_SYS_LONGHELP
|
|
|
|
static char bootefi_help_text[] =
|
2016-04-14 23:07:53 +09:00
|
|
|
"<image address> [fdt address]\n"
|
|
|
|
" - boot EFI payload stored at address <image address>.\n"
|
|
|
|
" If specified, the device tree located at <fdt address> gets\n"
|
2016-11-08 00:47:08 +09:00
|
|
|
" exposed as EFI configuration table.\n"
|
|
|
|
#ifdef CONFIG_CMD_BOOTEFI_HELLO
|
2017-09-15 17:06:11 +09:00
|
|
|
"bootefi hello\n"
|
|
|
|
" - boot a sample Hello World application stored within U-Boot\n"
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_CMD_BOOTEFI_SELFTEST
|
2018-03-03 23:29:03 +09:00
|
|
|
"bootefi selftest [fdt address]\n"
|
2017-09-15 17:06:11 +09:00
|
|
|
" - boot an EFI selftest application stored within U-Boot\n"
|
2017-10-19 01:13:13 +09:00
|
|
|
" Use environment variable efi_selftest to select a single test.\n"
|
|
|
|
" Use 'setenv efi_selftest list' to enumerate all tests.\n"
|
2016-11-08 00:47:08 +09:00
|
|
|
#endif
|
2018-01-31 03:47:43 +09:00
|
|
|
"bootefi bootmgr [fdt addr]\n"
|
2017-09-14 07:05:38 +09:00
|
|
|
" - load and boot EFI payload based on BootOrder/BootXXXX variables.\n"
|
|
|
|
"\n"
|
|
|
|
" If specified, the device tree located at <fdt address> gets\n"
|
|
|
|
" exposed as EFI configuration table.\n";
|
2016-03-10 08:27:20 +09:00
|
|
|
#endif
|
|
|
|
|
|
|
|
U_BOOT_CMD(
|
2016-04-14 23:07:53 +09:00
|
|
|
bootefi, 3, 0, do_bootefi,
|
2016-06-08 03:14:31 +09:00
|
|
|
"Boots an EFI payload from memory",
|
2016-03-10 08:27:20 +09:00
|
|
|
bootefi_help_text
|
|
|
|
);
|
2016-03-04 09:10:14 +09:00
|
|
|
|
2017-09-14 07:05:33 +09:00
|
|
|
void efi_set_bootdev(const char *dev, const char *devnr, const char *path)
|
|
|
|
{
|
2018-10-17 16:32:03 +09:00
|
|
|
struct efi_device_path *device, *image;
|
|
|
|
efi_status_t ret;
|
2016-08-05 21:49:53 +09:00
|
|
|
|
2018-09-16 14:20:21 +09:00
|
|
|
/* efi_set_bootdev is typically called repeatedly, recover memory */
|
|
|
|
efi_free_pool(bootefi_device_path);
|
|
|
|
efi_free_pool(bootefi_image_path);
|
2017-09-14 07:05:38 +09:00
|
|
|
|
2018-10-17 16:32:03 +09:00
|
|
|
ret = efi_dp_from_name(dev, devnr, path, &device, &image);
|
|
|
|
if (ret == EFI_SUCCESS) {
|
|
|
|
bootefi_device_path = device;
|
|
|
|
bootefi_image_path = image;
|
2016-07-21 08:44:46 +09:00
|
|
|
} else {
|
2018-10-17 16:32:03 +09:00
|
|
|
bootefi_device_path = NULL;
|
|
|
|
bootefi_image_path = NULL;
|
2016-07-21 08:44:46 +09:00
|
|
|
}
|
2016-03-04 09:10:14 +09:00
|
|
|
}
|