[PATCH v1 26/54] efi: loader: boot: implement LoadImage BootService

[Ahmad Fatoum <a.fatoum@pengutronix.de>]

We now have everything in place, so we can actually start images like
the barebox EFI payload itself, even if ExitBootServices is not yet
supported.

Signed-off-by: Ahmad Fatoum <a.fatoum@pengutronix.de>
---
 efi/loader/boot.c    | 591 ++++++++++++++++++++++++++++++++++++++++++-
 include/efi/loader.h |   4 +
 2 files changed, 591 insertions(+), 4 deletions(-)

diff --git a/efi/loader/boot.c b/efi/loader/boot.c
index 263165135944..2d208c4cafbd 100644
--- a/efi/loader/boot.c
+++ b/efi/loader/boot.c
@@ -20,6 +20,8 @@
 #include <efi/loader/devicepath.h>
 #include <efi/loader/debug.h>
 #include <efi/loader/image.h>
+#include <efi/loader/file.h>
+#include <efi/loader/pe.h>
 #include <efi/protocol/file.h>
 #include <efi/guid.h>
 #include <efi/error.h>
@@ -58,6 +60,9 @@ static bool timers_enabled = true;
 /* List of all events registered by RegisterProtocolNotify() */
 static LIST_HEAD(efi_register_notify_events);
 
+/* Handle of the currently executing image */
+static efi_handle_t current_image;
+
 efi_status_t efi_uninstall_protocol
 		(efi_handle_t handle, const efi_guid_t *protocol,
 		 void *protocol_interface, bool preserve);
@@ -1652,6 +1657,88 @@ EFIAPI efi_install_configuration_table_ext(const efi_guid_t *guid,
 	return EFI_EXIT(efi_install_configuration_table(guid, table));
 }
 
+/**
+ * efi_setup_loaded_image() - initialize a loaded image
+ *
+ * Initialize a loaded_image_info and loaded_image_info object with correct
+ * protocols, boot-device, etc.
+ *
+ * In case of an error \*handle_ptr and \*info_ptr are set to NULL and an error
+ * code is returned.
+ *
+ * @device_path:	device path of the loaded image
+ * @file_path:		file path of the loaded image
+ * @handle_ptr:		handle of the loaded image
+ * @info_ptr:		loaded image protocol
+ * Return:		status code
+ */
+static efi_status_t efi_setup_loaded_image(struct efi_device_path *device_path,
+					   struct efi_device_path *file_path,
+					   struct efi_loaded_image_obj **handle_ptr,
+					   struct efi_loaded_image **info_ptr)
+{
+	efi_status_t ret;
+	struct efi_loaded_image *info = NULL;
+	struct efi_loaded_image_obj *obj = NULL;
+	struct efi_device_path *dp;
+
+	/* In case of EFI_OUT_OF_RESOURCES avoid illegal free by caller. */
+	*handle_ptr = NULL;
+	*info_ptr = NULL;
+
+	info = calloc(1, sizeof(*info));
+	if (!info)
+		return EFI_OUT_OF_RESOURCES;
+	obj = calloc(1, sizeof(*obj));
+	if (!obj) {
+		free(info);
+		return EFI_OUT_OF_RESOURCES;
+	}
+	obj->header.type = EFI_OBJECT_TYPE_LOADED_IMAGE;
+
+	/* Add internal object to object list */
+	efi_add_handle(&obj->header);
+
+	info->revision = EFI_LOADED_IMAGE_PROTOCOL_REVISION;
+	info->file_path = file_path;
+	info->system_table = &systab;
+
+	if (device_path) {
+		info->device_handle = efi_dp_find_obj(device_path, NULL, NULL);
+
+		dp = efi_dp_concat(device_path, file_path, 0);
+		if (!dp) {
+			ret = EFI_OUT_OF_RESOURCES;
+			goto failure;
+		}
+	} else {
+		dp = NULL;
+	}
+	ret = efi_add_protocol(&obj->header,
+			       &efi_loaded_image_device_path_guid, dp);
+	if (ret != EFI_SUCCESS)
+		goto failure;
+
+	/*
+	 * When asking for the loaded_image interface, just
+	 * return handle which points to loaded_image_info
+	 */
+	ret = efi_add_protocol(&obj->header,
+			       &efi_loaded_image_protocol_guid, info);
+	if (ret != EFI_SUCCESS)
+		goto failure;
+
+	*info_ptr = info;
+	*handle_ptr = obj;
+
+	return ret;
+failure:
+	pr_err("Failure to install protocols for loaded image\n");
+	efi_delete_handle(&obj->header);
+	free(info);
+	return ret;
+}
+
 /**
  * efi_locate_device_path() - Get the device path and handle of an device
  *                            implementing a protocol
@@ -1733,6 +1820,216 @@ static efi_status_t EFIAPI efi_locate_device_path(const efi_guid_t *protocol,
 	return EFI_EXIT2(ret, *device_path);
 }
 
+/**
+ * efi_load_image_from_file() - load an image from file system
+ *
+ * Read a file into a buffer allocated as EFI_BOOT_SERVICES_DATA. It is the
+ * callers obligation to update the memory type as needed.
+ *
+ * @file_path:		the path of the image to load
+ * @buffer:		buffer containing the loaded image
+ * @size:		size of the loaded image
+ * Return:		status code
+ */
+static
+efi_status_t efi_load_image_from_file(struct efi_device_path *file_path,
+				      void **buffer, efi_uintn_t *size)
+{
+	struct efi_file_handle *f;
+	efi_status_t ret;
+	u64 addr;
+	efi_uintn_t bs;
+
+	/* Open file */
+	f = efi_file_from_path(file_path);
+	if (!f)
+		return EFI_NOT_FOUND;
+
+	ret = efi_file_size(f, &bs);
+	if (ret != EFI_SUCCESS)
+		goto error;
+
+	/*
+	 * When reading the file we do not yet know if it contains an
+	 * application, a boottime driver, or a runtime driver. So here we
+	 * allocate a buffer as EFI_BOOT_SERVICES_DATA. The caller has to
+	 * update the reservation according to the image type.
+	 */
+	ret = efi_allocate_pages(EFI_ALLOCATE_ANY_PAGES,
+				 EFI_BOOT_SERVICES_DATA,
+				 efi_size_in_pages(bs), &addr,
+				 "loadimage");
+	if (ret != EFI_SUCCESS) {
+		ret = EFI_OUT_OF_RESOURCES;
+		goto error;
+	}
+
+	/* Read file */
+	EFI_CALL(ret = f->read(f, &bs, (void *)(uintptr_t)addr));
+	if (ret != EFI_SUCCESS)
+		efi_free_pages(addr, efi_size_in_pages(bs));
+	*buffer = (void *)(uintptr_t)addr;
+	*size = bs;
+error:
+	EFI_CALL(f->close(f));
+	return ret;
+}
+
+/**
+ * efi_load_image_from_path() - load an image using a file path
+ *
+ * Read a file into a buffer allocated as EFI_BOOT_SERVICES_DATA. It is the
+ * callers obligation to update the memory type as needed.
+ *
+ * @boot_policy:	true for request originating from the boot manager
+ * @file_path:		the path of the image to load
+ * @buffer:		buffer containing the loaded image
+ * @size:		size of the loaded image
+ * Return:		status code
+ */
+static
+efi_status_t efi_load_image_from_path(bool boot_policy,
+				      struct efi_device_path *file_path,
+				      void **buffer, efi_uintn_t *size)
+{
+	efi_handle_t device;
+	efi_status_t ret;
+	struct efi_device_path *dp, *rem;
+	struct efi_load_file_protocol *load_file_protocol = NULL;
+	efi_uintn_t buffer_size;
+	uint64_t addr, pages;
+	const efi_guid_t *guid;
+	struct efi_handler *handler;
+
+	/* In case of failure nothing is returned */
+	*buffer = NULL;
+	*size = 0;
+
+	dp = file_path;
+	device = efi_dp_find_obj(dp, NULL, &rem);
+	ret = efi_search_protocol(device, &efi_simple_file_system_protocol_guid,
+				  NULL);
+	if (ret == EFI_SUCCESS)
+		return efi_load_image_from_file(file_path, buffer, size);
+
+	ret = efi_search_protocol(device, &efi_load_file_protocol_guid, NULL);
+	if (ret == EFI_SUCCESS) {
+		guid = &efi_load_file_protocol_guid;
+	} else if (!boot_policy) {
+		guid = &efi_load_file2_protocol_guid;
+		ret = efi_search_protocol(device, guid, NULL);
+	}
+	if (ret != EFI_SUCCESS)
+		return EFI_NOT_FOUND;
+	ret = efi_search_protocol(device, guid, &handler);
+	if (ret != EFI_SUCCESS)
+		return EFI_NOT_FOUND;
+	buffer_size = 0;
+	load_file_protocol = handler->protocol_interface;
+	ret = EFI_CALL(load_file_protocol->load_file(
+					load_file_protocol, rem, boot_policy,
+					&buffer_size, NULL));
+	if (ret != EFI_BUFFER_TOO_SMALL)
+		goto out;
+	pages = efi_size_in_pages(buffer_size);
+	ret = efi_allocate_pages(EFI_ALLOCATE_ANY_PAGES, EFI_BOOT_SERVICES_DATA,
+				 pages, &addr, "loadimage");
+	if (ret != EFI_SUCCESS) {
+		ret = EFI_OUT_OF_RESOURCES;
+		goto out;
+	}
+	ret = EFI_CALL(load_file_protocol->load_file(
+					load_file_protocol, rem, boot_policy,
+					&buffer_size, (void *)(uintptr_t)addr));
+	if (ret != EFI_SUCCESS)
+		efi_free_pages(addr, pages);
+out:
+	efi_close_protocol(device, guid, efi_root, NULL);
+	if (ret == EFI_SUCCESS) {
+		*buffer = (void *)(uintptr_t)addr;
+		*size = buffer_size;
+	}
+
+	return ret;
+}
+
+/**
+ * efiloader_load_image() - load an EFI image into memory
+ * @boot_policy:   true for request originating from the boot manager
+ * @parent_image:  the caller's image handle
+ * @file_path:     the path of the image to load
+ * @source_buffer: memory location from which the image is installed
+ * @source_size:   size of the memory area from which the image is installed
+ * @image_handle:  handle for the newly installed image
+ *
+ * This function implements the LoadImage service.
+ *
+ * See the Unified Extensible Firmware Interface (UEFI) specification
+ * for details.
+ *
+ * Return: status code
+ */
+efi_status_t EFIAPI efiloader_load_image(bool boot_policy,
+				   efi_handle_t parent_image,
+				   struct efi_device_path *file_path,
+				   void *source_buffer,
+				   efi_uintn_t source_size,
+				   efi_handle_t *image_handle)
+{
+	struct efi_device_path *dp, *fp;
+	struct efi_loaded_image *info = NULL;
+	struct efi_loaded_image_obj **image_obj =
+		(struct efi_loaded_image_obj **)image_handle;
+	efi_status_t ret;
+	void *dest_buffer;
+
+	EFI_ENTRY("%d, %p, %pD, %p, %zu, %p", boot_policy, parent_image,
+		  file_path, source_buffer, source_size, image_handle);
+
+	if (!image_handle || (!source_buffer && !file_path) ||
+	    !efi_search_obj(parent_image) ||
+	    /* The parent image handle must refer to a loaded image */
+	    !parent_image->type) {
+		ret = EFI_INVALID_PARAMETER;
+		goto error;
+	}
+
+	if (!source_buffer) {
+		ret = efi_load_image_from_path(boot_policy, file_path,
+					       &dest_buffer, &source_size);
+		if (ret != EFI_SUCCESS)
+			goto error;
+	} else {
+		dest_buffer = source_buffer;
+	}
+	/* split file_path which contains both the device and file parts */
+	efi_dp_split_file_path(file_path, &dp, &fp);
+	ret = efi_setup_loaded_image(dp, fp, image_obj, &info);
+	if (ret == EFI_SUCCESS)
+		ret = efi_load_pe(*image_obj, dest_buffer, source_size, info);
+	if (!source_buffer)
+		/* Release buffer to which file was loaded */
+		efi_free_pages((uintptr_t)dest_buffer,
+			       efi_size_in_pages(source_size));
+	if (ret == EFI_SUCCESS || ret == EFI_SECURITY_VIOLATION) {
+		info->system_table = &systab;
+		info->parent_handle = parent_image;
+	} else {
+		/* The image is invalid. Release all associated resources. */
+		efi_delete_handle(*image_handle);
+		*image_handle = NULL;
+		free(info);
+	}
+
+	if (IS_ENABLED(CONFIG_EFI_LOADER_DEBUG_SUPPORT) && *image_handle)
+		efi_core_new_debug_image_info_entry(EFI_DEBUG_IMAGE_INFO_TYPE_NORMAL,
+						    info,
+						    *image_handle);
+
+error:
+	return EFI_EXIT2(ret, *image_handle);
+}
+
 /**
  * efi_exit_boot_services() - stop all boot services
  * @image_handle: handle of the loaded image
@@ -2666,6 +2963,104 @@ static efi_status_t EFIAPI efi_open_protocol
 	return EFI_EXIT(r);
 }
 
+/**
+ * __efi_start_image() - call the entry point of an image
+ * @image_handle:   handle of the image
+ * @exit_data_size: size of the buffer
+ * @exit_data:      buffer to receive the exit data of the called image
+ * @flags:          boot flags
+ *
+ * This function implements the StartImage service.
+ *
+ * See the Unified Extensible Firmware Interface (UEFI) specification for
+ * details.
+ *
+ * Return: status code
+ */
+efi_status_t __efi_start_image(efi_handle_t image_handle,
+			       efi_uintn_t *exit_data_size,
+			       u16 **exit_data, int flags)
+{
+	struct efi_loaded_image_obj *image_obj =
+		(struct efi_loaded_image_obj *)image_handle;
+	efi_status_t ret;
+	struct efi_loaded_image *info;
+	efi_handle_t parent_image = current_image;
+	efi_status_t exit_status;
+	struct jmp_buf_data exit_jmp;
+	EFIAPI efi_status_t (*entry)(efi_handle_t image_handle,
+				     struct efi_system_table *st);
+
+	if (!efi_search_obj(image_handle))
+		return EFI_EXIT(EFI_INVALID_PARAMETER);
+
+	/* Check parameters */
+	if (image_obj->header.type != EFI_OBJECT_TYPE_LOADED_IMAGE)
+		return EFI_EXIT(EFI_INVALID_PARAMETER);
+
+	ret = EFI_CALL(efi_open_protocol(image_handle, &efi_loaded_image_protocol_guid,
+					 (void **)&info, NULL, NULL,
+					 EFI_OPEN_PROTOCOL_GET_PROTOCOL));
+	if (ret != EFI_SUCCESS)
+		return EFI_EXIT(EFI_INVALID_PARAMETER);
+
+	image_obj->exit_data_size = exit_data_size;
+	image_obj->exit_data = exit_data;
+	image_obj->exit_status = &exit_status;
+	image_obj->exit_jmp = &exit_jmp;
+
+	/* call the image! */
+	if (setjmp(&exit_jmp)) {
+		/*
+		 * We called the entry point of the child image with EFI_CALL
+		 * in the lines below. The child image called the Exit() boot
+		 * service efi_exit() which executed the long jump that brought
+		 * us to the current line. This implies that the second half
+		 * of the EFI_CALL macro has not been executed.
+		 */
+		/*
+		 * To get ready to call EFI_EXIT below we have to execute the
+		 * missed out steps of EFI_CALL.
+		 */
+		EFI_RETURN(exit_status);
+
+		current_image = parent_image;
+
+		return EFI_EXIT(exit_status);
+	}
+
+	current_image = image_handle;
+	image_obj->header.type = EFI_OBJECT_TYPE_STARTED_IMAGE;
+
+	if (flags & EFI_DRYRUN) {
+		pr_info("Dryrun. Aborted\n");
+		ret = EFI_SUCCESS;
+		goto exit;
+	}
+
+	entry = image_obj->entry;
+
+	pr_info("Starting EFI payload at %p\n", entry);
+
+	// FIXME: we need the below if we enable CONFIG_ARM_MMU_PERMISSIONS...
+	// remap_range(info->image_base, info->image_size, MAP_ARCH(2));
+	sync_caches_for_execution();
+
+	efi_set_variable_usec("LoaderTimeExecUSec", &efi_systemd_vendor_guid,
+			      ktime_to_us(ktime_get()));
+
+	ret = EFI_CALL(entry(image_handle, &systab));
+
+exit:
+	/*
+	 * Control is returned from a started UEFI image either by calling
+	 * Exit() (where exit data can be provided) or by simply returning from
+	 * the entry point. In the latter case call Exit() on behalf of the
+	 * image.
+	 */
+	return EFI_CALL(systab.boottime->exit(image_handle, ret, 0, NULL));
+}
+
 /**
  * efi_start_image() - call the entry point of an image
  * @image_handle:   handle of the image
@@ -2685,7 +3080,54 @@ static efi_status_t EFIAPI efi_start_image(efi_handle_t image_handle,
 {
 	EFI_ENTRY("%p, %p, %p", image_handle, exit_data_size, exit_data);
 
-	return EFI_EXIT(EFI_UNSUPPORTED);
+	return __efi_start_image(image_handle, exit_data_size, exit_data, 0);
+}
+
+/**
+ * efi_delete_image() - delete loaded image from memory)
+ *
+ * @image_obj:			handle of the loaded image
+ * @loaded_image_protocol:	loaded image protocol
+ */
+static efi_status_t efi_delete_image
+			(struct efi_loaded_image_obj *image_obj,
+			 struct efi_loaded_image *loaded_image_protocol)
+{
+	struct efi_object *efiobj;
+	efi_status_t r, ret = EFI_SUCCESS;
+
+close_next:
+	list_for_each_entry(efiobj, &efi_obj_list, link) {
+		struct efi_handler *protocol;
+
+		list_for_each_entry(protocol, &efiobj->protocols, link) {
+			struct efi_open_protocol_info_item *info;
+
+			list_for_each_entry(info, &protocol->open_infos, link) {
+				if (info->info.agent_handle !=
+				    (efi_handle_t)image_obj)
+					continue;
+				r = efi_close_protocol(
+						efiobj, &protocol->guid,
+						info->info.agent_handle,
+						info->info.controller_handle);
+				if (r !=  EFI_SUCCESS)
+					ret = r;
+				/*
+				 * Closing protocols may results in further
+				 * items being deleted. To play it safe loop
+				 * over all elements again.
+				 */
+				goto close_next;
+			}
+		}
+	}
+
+	efi_free_pages((uintptr_t)loaded_image_protocol->image_base,
+		       efi_size_in_pages(loaded_image_protocol->image_size));
+	efi_delete_handle(&image_obj->header);
+
+	return ret;
 }
 
 /**
@@ -2701,7 +3143,87 @@ static efi_status_t EFIAPI efi_start_image(efi_handle_t image_handle,
  */
 static efi_status_t EFIAPI efi_unload_image(efi_handle_t image_handle)
 {
-	return EFI_EXIT(EFI_UNSUPPORTED);
+	efi_status_t ret = EFI_SUCCESS;
+	struct efi_object *efiobj;
+	struct efi_loaded_image *loaded_image_protocol;
+
+	EFI_ENTRY("%p", image_handle);
+
+	efiobj = efi_search_obj(image_handle);
+	if (!efiobj) {
+		ret = EFI_INVALID_PARAMETER;
+		goto out;
+	}
+	/* Find the loaded image protocol */
+	ret = EFI_CALL(efi_open_protocol(image_handle, &efi_loaded_image_protocol_guid,
+					 (void **)&loaded_image_protocol,
+					 NULL, NULL,
+					 EFI_OPEN_PROTOCOL_GET_PROTOCOL));
+	if (ret != EFI_SUCCESS) {
+		ret = EFI_INVALID_PARAMETER;
+		goto out;
+	}
+
+	if (IS_ENABLED(CONFIG_EFI_LOADER_DEBUG_SUPPORT))
+		efi_core_remove_debug_image_info_entry(image_handle);
+
+	switch (efiobj->type) {
+	case EFI_OBJECT_TYPE_STARTED_IMAGE:
+		/* Call the unload function */
+		if (!loaded_image_protocol->unload) {
+			ret = EFI_UNSUPPORTED;
+			goto out;
+		}
+		ret = EFI_CALL(loaded_image_protocol->unload(image_handle));
+		if (ret != EFI_SUCCESS)
+			goto out;
+		break;
+	case EFI_OBJECT_TYPE_LOADED_IMAGE:
+		break;
+	default:
+		ret = EFI_INVALID_PARAMETER;
+		goto out;
+	}
+	efi_delete_image((struct efi_loaded_image_obj *)efiobj,
+			 loaded_image_protocol);
+out:
+	return EFI_EXIT(ret);
+}
+
+/**
+ * efi_update_exit_data() - fill exit data parameters of StartImage()
+ *
+ * @image_obj:		image handle
+ * @exit_data_size:	size of the exit data buffer
+ * @exit_data:		buffer with data returned by UEFI payload
+ * Return:		status code
+ */
+static efi_status_t efi_update_exit_data(struct efi_loaded_image_obj *image_obj,
+					 efi_uintn_t exit_data_size,
+					 u16 *exit_data)
+{
+	efi_status_t ret;
+
+	/*
+	 * If exit_data is not provided to StartImage(), exit_data_size must be
+	 * ignored.
+	 */
+	if (!image_obj->exit_data)
+		return EFI_SUCCESS;
+	if (image_obj->exit_data_size)
+		*image_obj->exit_data_size = exit_data_size;
+	if (exit_data_size && exit_data) {
+		ret = efi_allocate_pool(EFI_BOOT_SERVICES_DATA,
+					exit_data_size,
+					(void **)image_obj->exit_data,
+					"exitdata");
+		if (ret != EFI_SUCCESS)
+			return ret;
+		memcpy(*image_obj->exit_data, exit_data, exit_data_size);
+	} else {
+		image_obj->exit_data = NULL;
+	}
+	return EFI_SUCCESS;
 }
 
 /**
@@ -2723,10 +3245,71 @@ static efi_status_t EFIAPI efi_exit(efi_handle_t image_handle,
 				    efi_uintn_t exit_data_size,
 				    u16 *exit_data)
 {
+	/*
+	 * TODO: We should call the unload procedure of the loaded
+	 *	 image protocol.
+	 */
+	efi_status_t ret;
+	struct efi_loaded_image *loaded_image_protocol;
+	struct efi_loaded_image_obj *image_obj =
+		(struct efi_loaded_image_obj *)image_handle;
+	struct jmp_buf_data *exit_jmp;
+
 	EFI_ENTRY("%p, %ld, %zu, %p", image_handle, exit_status,
 		  exit_data_size, exit_data);
 
-	return EFI_EXIT(EFI_UNSUPPORTED);
+	/* Check parameters */
+	ret = EFI_CALL(efi_open_protocol(image_handle, &efi_loaded_image_protocol_guid,
+					 (void **)&loaded_image_protocol,
+					 NULL, NULL,
+					 EFI_OPEN_PROTOCOL_GET_PROTOCOL));
+	if (ret != EFI_SUCCESS) {
+		ret = EFI_INVALID_PARAMETER;
+		goto out;
+	}
+
+	/* Unloading of unstarted images */
+	switch (image_obj->header.type) {
+	case EFI_OBJECT_TYPE_STARTED_IMAGE:
+		break;
+	case EFI_OBJECT_TYPE_LOADED_IMAGE:
+		efi_delete_image(image_obj, loaded_image_protocol);
+		ret = EFI_SUCCESS;
+		goto out;
+	default:
+		/* Handle does not refer to loaded image */
+		ret = EFI_INVALID_PARAMETER;
+		goto out;
+	}
+	/* A started image can only be unloaded it is the last one started. */
+	if (image_handle != current_image) {
+		ret = EFI_INVALID_PARAMETER;
+		goto out;
+	}
+
+	/* Exit data is only foreseen in case of failure. */
+	if (exit_status != EFI_SUCCESS) {
+		ret = efi_update_exit_data(image_obj, exit_data_size,
+					   exit_data);
+		/* Exiting has priority. Don't return error to caller. */
+		if (ret != EFI_SUCCESS)
+			EFI_PRINT("%s: out of memory\n", __func__);
+	}
+	/* efi_delete_image() frees image_obj. Copy before the call. */
+	exit_jmp = image_obj->exit_jmp;
+	*image_obj->exit_status = exit_status;
+	if (image_obj->image_type == IMAGE_SUBSYSTEM_EFI_APPLICATION ||
+	    exit_status != EFI_SUCCESS)
+		efi_delete_image(image_obj, loaded_image_protocol);
+
+	/* Make sure entry/exit counts for EFI world cross-overs match */
+	EFI_EXIT(exit_status);
+
+	longjmp(exit_jmp, 1);
+
+	panic("EFI application exited");
+out:
+	return EFI_EXIT(ret);
 }
 
 /**
@@ -3170,7 +3753,7 @@ static struct efi_boot_services efi_boot_services = {
 	.locate_handle = efi_locate_handle_ext,
 	.locate_device_path = efi_locate_device_path,
 	.install_configuration_table = efi_install_configuration_table_ext,
-	.load_image = (void *)efi_unimplemented,
+	.load_image = efiloader_load_image,
 	.start_image = efi_start_image,
 	.exit = efi_exit,
 	.unload_image = efi_unload_image,
diff --git a/include/efi/loader.h b/include/efi/loader.h
index 466541c1e2b5..74d177568353 100644
--- a/include/efi/loader.h
+++ b/include/efi/loader.h
@@ -29,6 +29,10 @@ efi_status_t efi_initialize_system_table(void);
 /* Called by efi_set_watchdog_timer to reset the timer */
 efi_status_t efi_set_watchdog(unsigned long timeout);
 
+efi_status_t __efi_start_image(efi_handle_t image_handle,
+			       efi_uintn_t *exit_data_size,
+			       u16 **exit_data, int flags);
+
 /* Allocate boot service data pool memory */
 void *efi_alloc(size_t len, const char *name);
 /* Reallocate boot service data pool memory */
-- 
2.47.3