brain-hackers_pepepper-mirror/u-boot-brain
1
0
Fork 0
mirror of https://github.com/brain-hackers/u-boot-brain synced 2024-09-23 05:00:24 +09:00
Code Issues Projects Releases Wiki Activity

efi_loader: set entry point in efi_load_pe()

Browse Source 
Up to now efi_load_pe() returns the entry point or NULL in case of an
error. This does not allow to return correct error codes from LoadImage().

Let efi_load_pe() return a status code and fill in the entry point in the
corresponding field of the image object.

Signed-off-by: Heinrich Schuchardt <xypron.glpk@gmx.de>
This commit is contained in:
Heinrich Schuchardt 2018-12-26 12:49:09 +01:00
parent 0e18f584de
commit 8f7e2b2980
4 changed files with 29 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
cmd/bootefi.c
View File

@ -266,9 +266,6 @@ static efi_status_t do_bootefi_exec(void *efi,
struct efi_loaded_image_obj *image_obj = NULL; struct efi_loaded_image_obj *image_obj = NULL;
struct efi_loaded_image *loaded_image_info = NULL; struct efi_loaded_image *loaded_image_info = NULL;
EFIAPI efi_status_t (*entry)(efi_handle_t image_handle,
struct efi_system_table *st);
/* /*
* Special case for efi payload not loaded from disk, such as * Special case for efi payload not loaded from disk, such as
* 'bootefi hello' or for example payload loaded directly into * 'bootefi hello' or for example payload loaded directly into
@ -300,11 +297,9 @@ static efi_status_t do_bootefi_exec(void *efi,
goto err_prepare; goto err_prepare;
/* Load the EFI payload */ /* Load the EFI payload */
entry = efi_load_pe(image_obj, efi, loaded_image_info); ret = efi_load_pe(image_obj, efi, loaded_image_info);
if (!entry) { if (ret != EFI_SUCCESS)
ret = EFI_LOAD_ERROR;
goto err_prepare; goto err_prepare;
}
if (memdp) { if (memdp) {
struct efi_device_path_memory *mdp = (void *)memdp; struct efi_device_path_memory *mdp = (void *)memdp;
@ -319,14 +314,14 @@ static efi_status_t do_bootefi_exec(void *efi,
"{ro,boot}(blob)0000000000000000"); "{ro,boot}(blob)0000000000000000");
/* Call our payload! */ /* Call our payload! */
debug("%s: Jumping to 0x%p\n", __func__, entry); debug("%s: Jumping to 0x%p\n", __func__, image_obj->entry);
if (setjmp(&image_obj->exit_jmp)) { if (setjmp(&image_obj->exit_jmp)) {
ret = image_obj->exit_status; ret = image_obj->exit_status;
goto err_prepare; goto err_prepare;
} }
ret = efi_do_enter(&image_obj->header, &systab, entry); ret = efi_do_enter(&image_obj->header, &systab, image_obj->entry);
err_prepare: err_prepare:
/* image has returned, loaded-image obj goes *poof*: */ /* image has returned, loaded-image obj goes *poof*: */

4
include/efi_loader.h
View File

@ -301,8 +301,8 @@ efi_status_t efi_set_watchdog(unsigned long timeout);
/* Called from places to check whether a timer expired */ /* Called from places to check whether a timer expired */
void efi_timer_check(void); void efi_timer_check(void);
/* PE loader implementation */ /* PE loader implementation */
void *efi_load_pe(struct efi_loaded_image_obj *handle, void *efi, efi_status_t efi_load_pe(struct efi_loaded_image_obj *handle, void *efi,
struct efi_loaded_image *loaded_image_info); struct efi_loaded_image *loaded_image_info);
/* Called once to store the pristine gd pointer */ /* Called once to store the pristine gd pointer */
void efi_save_gd(void); void efi_save_gd(void);
/* Special case handler for error/abort that just tries to dtrt to get /* Special case handler for error/abort that just tries to dtrt to get

6
lib/efi_loader/efi_boottime.c
View File

@ -1738,11 +1738,9 @@ static efi_status_t EFIAPI efi_load_image(bool boot_policy,
ret = efi_setup_loaded_image(dp, fp, image_obj, &info); ret = efi_setup_loaded_image(dp, fp, image_obj, &info);
if (ret != EFI_SUCCESS) if (ret != EFI_SUCCESS)
goto error_invalid_image; goto error_invalid_image;
(*image_obj)->entry = efi_load_pe(*image_obj, source_buffer, info); ret = efi_load_pe(*image_obj, source_buffer, info);
if (!(*image_obj)->entry) { if (ret != EFI_SUCCESS)
ret = EFI_UNSUPPORTED;
goto error_invalid_image; goto error_invalid_image;
}
/* Update the type of the allocated memory */ /* Update the type of the allocated memory */
efi_add_memory_map((uintptr_t)source_buffer, efi_add_memory_map((uintptr_t)source_buffer,
efi_size_in_pages(source_size), efi_size_in_pages(source_size),

37
lib/efi_loader/efi_image_loader.c
View File

@ -193,13 +193,19 @@ static void efi_set_code_and_data_type(
} }
} }
/* /**
* efi_load_pe() - relocate EFI binary
*
* This function loads all sections from a PE binary into a newly reserved * This function loads all sections from a PE binary into a newly reserved
* piece of memory. On successful load it then returns the entry point for * piece of memory. On success the entry point is returned as handle->entry.
* the binary. Otherwise NULL. *
* @handle: loaded image handle
* @efi: pointer to the EFI binary
* @loaded_image_info: loaded image protocol
* Return: status code
*/ */
void *efi_load_pe(struct efi_loaded_image_obj *handle, void *efi, efi_status_t efi_load_pe(struct efi_loaded_image_obj *handle, void *efi,
struct efi_loaded_image *loaded_image_info) struct efi_loaded_image *loaded_image_info)
{ {
IMAGE_NT_HEADERS32 *nt; IMAGE_NT_HEADERS32 *nt;
IMAGE_DOS_HEADER *dos; IMAGE_DOS_HEADER *dos;
@ -210,7 +216,6 @@ void *efi_load_pe(struct efi_loaded_image_obj *handle, void *efi,
const IMAGE_BASE_RELOCATION *rel; const IMAGE_BASE_RELOCATION *rel;
unsigned long rel_size; unsigned long rel_size;
int rel_idx = IMAGE_DIRECTORY_ENTRY_BASERELOC; int rel_idx = IMAGE_DIRECTORY_ENTRY_BASERELOC;
void *entry;
uint64_t image_base; uint64_t image_base;
uint64_t image_size; uint64_t image_size;
unsigned long virt_size = 0; unsigned long virt_size = 0;
@ -219,13 +224,13 @@ void *efi_load_pe(struct efi_loaded_image_obj *handle, void *efi,
dos = efi; dos = efi;
if (dos->e_magic != IMAGE_DOS_SIGNATURE) { if (dos->e_magic != IMAGE_DOS_SIGNATURE) {
printf("%s: Invalid DOS Signature\n", __func__); printf("%s: Invalid DOS Signature\n", __func__);
return NULL; return EFI_LOAD_ERROR;
} }
nt = (void *) ((char *)efi + dos->e_lfanew); nt = (void *) ((char *)efi + dos->e_lfanew);
if (nt->Signature != IMAGE_NT_SIGNATURE) { if (nt->Signature != IMAGE_NT_SIGNATURE) {
printf("%s: Invalid NT Signature\n", __func__); printf("%s: Invalid NT Signature\n", __func__);
return NULL; return EFI_LOAD_ERROR;
} }
for (i = 0; machines[i]; i++) for (i = 0; machines[i]; i++)
@ -237,7 +242,7 @@ void *efi_load_pe(struct efi_loaded_image_obj *handle, void *efi,
if (!supported) { if (!supported) {
printf("%s: Machine type 0x%04x is not supported\n", printf("%s: Machine type 0x%04x is not supported\n",
__func__, nt->FileHeader.Machine); __func__, nt->FileHeader.Machine);
return NULL; return EFI_LOAD_ERROR;
} }
/* Calculate upper virtual address boundary */ /* Calculate upper virtual address boundary */
@ -263,9 +268,9 @@ void *efi_load_pe(struct efi_loaded_image_obj *handle, void *efi,
if (!efi_reloc) { if (!efi_reloc) {
printf("%s: Could not allocate %lu bytes\n", printf("%s: Could not allocate %lu bytes\n",
__func__, virt_size); __func__, virt_size);
return NULL; return EFI_OUT_OF_RESOURCES;
} }
entry = efi_reloc + opt->AddressOfEntryPoint; handle->entry = efi_reloc + opt->AddressOfEntryPoint;
rel_size = opt->DataDirectory[rel_idx].Size; rel_size = opt->DataDirectory[rel_idx].Size;
rel = efi_reloc + opt->DataDirectory[rel_idx].VirtualAddress; rel = efi_reloc + opt->DataDirectory[rel_idx].VirtualAddress;
virt_size = ALIGN(virt_size, opt->SectionAlignment); virt_size = ALIGN(virt_size, opt->SectionAlignment);
@ -279,16 +284,16 @@ void *efi_load_pe(struct efi_loaded_image_obj *handle, void *efi,
if (!efi_reloc) { if (!efi_reloc) {
printf("%s: Could not allocate %lu bytes\n", printf("%s: Could not allocate %lu bytes\n",
__func__, virt_size); __func__, virt_size);
return NULL; return EFI_OUT_OF_RESOURCES;
} }
entry = efi_reloc + opt->AddressOfEntryPoint; handle->entry = efi_reloc + opt->AddressOfEntryPoint;
rel_size = opt->DataDirectory[rel_idx].Size; rel_size = opt->DataDirectory[rel_idx].Size;
rel = efi_reloc + opt->DataDirectory[rel_idx].VirtualAddress; rel = efi_reloc + opt->DataDirectory[rel_idx].VirtualAddress;
virt_size = ALIGN(virt_size, opt->SectionAlignment); virt_size = ALIGN(virt_size, opt->SectionAlignment);
} else { } else {
printf("%s: Invalid optional header magic %x\n", __func__, printf("%s: Invalid optional header magic %x\n", __func__,
nt->OptionalHeader.Magic); nt->OptionalHeader.Magic);
return NULL; return EFI_LOAD_ERROR;
} }
/* Load sections into RAM */ /* Load sections into RAM */
@ -306,7 +311,7 @@ void *efi_load_pe(struct efi_loaded_image_obj *handle, void *efi,
(unsigned long)image_base) != EFI_SUCCESS) { (unsigned long)image_base) != EFI_SUCCESS) {
efi_free_pages((uintptr_t) efi_reloc, efi_free_pages((uintptr_t) efi_reloc,
(virt_size + EFI_PAGE_MASK) >> EFI_PAGE_SHIFT); (virt_size + EFI_PAGE_MASK) >> EFI_PAGE_SHIFT);
return NULL; return EFI_LOAD_ERROR;
} }
/* Flush cache */ /* Flush cache */
@ -320,5 +325,5 @@ void *efi_load_pe(struct efi_loaded_image_obj *handle, void *efi,
handle->reloc_base = efi_reloc; handle->reloc_base = efi_reloc;
handle->reloc_size = virt_size; handle->reloc_size = virt_size;
return entry; return EFI_SUCCESS;
} }