[u-boot.git] / lib / efi_selftest / efi_selftest_load_file.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * efi_selftest_load_file
 *
 * Copyright (c) 2020 Heinrich Schuchardt <[email protected]>
 *
 * This test checks the handling of the LOAD_FILE and the LOAD_FILE2 protocol
 * by the LoadImage() service.
 */

#include <efi_selftest.h>
/* Include containing the miniapp.efi application */
#include "efi_miniapp_file_image_exit.h"

/* Block size of compressed disk image */
#define COMPRESSED_DISK_IMAGE_BLOCK_SIZE 8

/* Binary logarithm of the block size */
#define LB_BLOCK_SIZE 9

#define GUID_VENDOR \
	EFI_GUID(0xdbca4c98, 0x6cb0, 0x694d, \
		 0x08, 0x72, 0x81, 0x9c, 0x65, 0xfc, 0xbb, 0xd1)

#define GUID_VENDOR2 \
	EFI_GUID(0xdbca4c98, 0x6cb0, 0x694d, \
		 0x08, 0x72, 0x81, 0x9c, 0x65, 0xfc, 0xbb, 0xd2)

#define FILE_NAME_SIZE 16

static const efi_guid_t efi_st_guid_load_file_protocol =
					EFI_LOAD_FILE_PROTOCOL_GUID;
static const efi_guid_t efi_st_guid_load_file2_protocol =
					EFI_LOAD_FILE2_PROTOCOL_GUID;
static const efi_guid_t efi_st_guid_device_path =
					EFI_DEVICE_PATH_PROTOCOL_GUID;

static efi_handle_t image_handle;
static struct efi_boot_services *boottime;
static efi_handle_t handle_lf;
static efi_handle_t handle_lf2;

/* One 8 byte block of the compressed disk image */
struct line {
	size_t addr;
	char *line;
};

/* Compressed file image */
struct compressed_file_image {
	size_t length;
	struct line lines[];
};

static struct compressed_file_image img = EFI_ST_DISK_IMG;

static int load_file_call_count;
static int load_file2_call_count;

/* Decompressed file image */
static u8 *image;

static struct {
	struct efi_device_path_vendor v;
	struct efi_device_path d;
} dp_lf_prot = {
	{
		{
			DEVICE_PATH_TYPE_HARDWARE_DEVICE,
			DEVICE_PATH_SUB_TYPE_VENDOR,
			sizeof(struct efi_device_path_vendor),
		},
		GUID_VENDOR,
	},
	{
		DEVICE_PATH_TYPE_END,
		DEVICE_PATH_SUB_TYPE_END,
		sizeof(struct efi_device_path),
	},
};

static struct {
	struct efi_device_path_vendor v;
	struct efi_device_path_file_path f;
	u16 file_name[FILE_NAME_SIZE];
	struct efi_device_path e;
} dp_lf_file = {
	{
		{
			DEVICE_PATH_TYPE_HARDWARE_DEVICE,
			DEVICE_PATH_SUB_TYPE_VENDOR,
			sizeof(struct efi_device_path_vendor),
		},
		GUID_VENDOR,
	},
	{
		{
			DEVICE_PATH_TYPE_MEDIA_DEVICE,
			DEVICE_PATH_SUB_TYPE_FILE_PATH,
			sizeof(struct efi_device_path_file_path) +
			FILE_NAME_SIZE * sizeof(u16),
		}
	},
	u"\\lf.efi",
	{
		DEVICE_PATH_TYPE_END,
		DEVICE_PATH_SUB_TYPE_END,
		sizeof(struct efi_device_path),
	},
};

struct efi_device_path *dp_lf_file_remainder = &dp_lf_file.f.dp;

static struct {
	struct efi_device_path_vendor v;
	struct efi_device_path d;
} dp_lf2_prot = {
	{
		{
			DEVICE_PATH_TYPE_HARDWARE_DEVICE,
			DEVICE_PATH_SUB_TYPE_VENDOR,
			sizeof(struct efi_device_path_vendor),
		},
		GUID_VENDOR2,
	},
	{
		DEVICE_PATH_TYPE_END,
		DEVICE_PATH_SUB_TYPE_END,
		sizeof(struct efi_device_path),
	},
};

static struct {
	struct efi_device_path_vendor v;
	struct efi_device_path_file_path f;
	u16 file_name[FILE_NAME_SIZE];
	struct efi_device_path e;
} dp_lf2_file = {
	{
		{
			DEVICE_PATH_TYPE_HARDWARE_DEVICE,
			DEVICE_PATH_SUB_TYPE_VENDOR,
			sizeof(struct efi_device_path_vendor),
		},
		GUID_VENDOR2,
	},
	{
		{
			DEVICE_PATH_TYPE_MEDIA_DEVICE,
			DEVICE_PATH_SUB_TYPE_FILE_PATH,
			sizeof(struct efi_device_path_file_path) +
			FILE_NAME_SIZE * sizeof(u16),
		}
	},
	u"\\lf2.efi",
	{
		DEVICE_PATH_TYPE_END,
		DEVICE_PATH_SUB_TYPE_END,
		sizeof(struct efi_device_path),
	},
};

struct efi_device_path *dp_lf2_file_remainder = &dp_lf2_file.f.dp;

/*
 * Decompress the disk image.
 *
 * @image	decompressed disk image
 * Return:	status code
 */
static efi_status_t decompress(u8 **image)
{
	u8 *buf;
	size_t i;
	size_t addr;
	size_t len;
	efi_status_t ret;

	ret = boottime->allocate_pool(EFI_LOADER_DATA, img.length,
				      (void **)&buf);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Out of memory\n");
		return ret;
	}
	boottime->set_mem(buf, img.length, 0);

	for (i = 0; ; ++i) {
		if (!img.lines[i].line)
			break;
		addr = img.lines[i].addr;
		len = COMPRESSED_DISK_IMAGE_BLOCK_SIZE;
		if (addr + len > img.length)
			len = img.length - addr;
		boottime->copy_mem(buf + addr, img.lines[i].line, len);
	}
	*image = buf;
	return ret;
}

/*
 * load_file() - LoadFile() service of a EFI_LOAD_FILE_PROTOCOL
 *
 * @this:		instance of EFI_LOAD_FILE_PROTOCOL
 * @file_path:		remaining device path
 * @boot_policy:	true if called by boot manager
 * @buffer_size:	(required) buffer size
 * @buffer:		buffer to which the file is to be loaded
 */
static efi_status_t EFIAPI load_file(struct efi_load_file_protocol *this,
				     struct efi_device_path *file_path,
				     bool boot_policy,
				     efi_uintn_t *buffer_size,
				     void *buffer)
{
	++load_file_call_count;
	if (memcmp(file_path, dp_lf_file_remainder,
	    sizeof(struct efi_device_path_file_path) +
	    FILE_NAME_SIZE * sizeof(u16) +
	    sizeof(struct efi_device_path))) {
		efi_st_error("Wrong remaining device path\n");
		return EFI_NOT_FOUND;
	}
	if (this->load_file != load_file) {
		efi_st_error("wrong this\n");
		return EFI_INVALID_PARAMETER;
	}
	if (*buffer_size < img.length) {
		*buffer_size = img.length;
		return EFI_BUFFER_TOO_SMALL;
	}
	memcpy(buffer, image, img.length);
	*buffer_size = img.length;
	return EFI_SUCCESS;
}


/*
 * load_file2() - LoadFile() service of a EFI_LOAD_FILE2_PROTOCOL
 *
 * @this:		instance of EFI_LOAD_FILE2_PROTOCOL
 * @file_path:		remaining device path
 * @boot_policy:	true if called by boot manager
 * @buffer_size:	(required) buffer size
 * @buffer:		buffer to which the file is to be loaded
 */
static efi_status_t EFIAPI load_file2(struct efi_load_file_protocol *this,
				      struct efi_device_path *file_path,
				      bool boot_policy,
				      efi_uintn_t *buffer_size,
				      void *buffer)
{
	++load_file2_call_count;
	if (memcmp(file_path, dp_lf2_file_remainder,
	    sizeof(struct efi_device_path_file_path) +
	    FILE_NAME_SIZE * sizeof(u16) +
	    sizeof(struct efi_device_path))) {
		efi_st_error("Wrong remaining device path\n");
		return EFI_NOT_FOUND;
	}
	if (this->load_file != load_file2) {
		efi_st_error("wrong this\n");
		return EFI_INVALID_PARAMETER;
	}
	if (boot_policy) {
		efi_st_error("LOAD_FILE2 called with boot_policy = true");
		return EFI_INVALID_PARAMETER;
	}
	if (*buffer_size < img.length) {
		*buffer_size = img.length;
		return EFI_BUFFER_TOO_SMALL;
	}
	memcpy(buffer, image, img.length);
	*buffer_size = img.length;
	return EFI_SUCCESS;
}

static struct efi_load_file_protocol lf_prot = {load_file};
static struct efi_load_file_protocol lf2_prot = {load_file2};

/*
 * Setup unit test.
 *
 * Install an EFI_LOAD_FILE_PROTOCOL and an EFI_LOAD_FILE2_PROTOCOL.
 *
 * @handle:	handle of the loaded image
 * @systable:	system table
 * Return:	EFI_ST_SUCCESS for success
 */
static int efi_st_load_file_setup(const efi_handle_t handle,
				  const struct efi_system_table *systable)
{
	efi_status_t ret;

	image_handle = handle;
	boottime = systable->boottime;

	/* Load the application image into memory */
	decompress(&image);

	ret = boottime->install_multiple_protocol_interfaces(
		&handle_lf,
		&efi_st_guid_device_path,
		&dp_lf_prot,
		&efi_st_guid_load_file_protocol,
		&lf_prot,
		NULL);
	if (ret != EFI_SUCCESS) {
		efi_st_error("InstallMultipleProtocolInterfaces failed\n");
		return EFI_ST_FAILURE;
	}
	ret = boottime->install_multiple_protocol_interfaces(
		&handle_lf2,
		&efi_st_guid_device_path,
		&dp_lf2_prot,
		&efi_st_guid_load_file2_protocol,
		&lf2_prot,
		NULL);
	if (ret != EFI_SUCCESS) {
		efi_st_error("InstallMultipleProtocolInterfaces failed\n");
		return EFI_ST_FAILURE;
	}

	return EFI_ST_SUCCESS;
}

/*
 * Tear down unit test.
 *
 * Return:	EFI_ST_SUCCESS for success
 */
static int efi_st_load_file_teardown(void)
{
	efi_status_t ret = EFI_ST_SUCCESS;

	if (handle_lf) {
		ret = boottime->uninstall_multiple_protocol_interfaces(
			handle_lf,
			&efi_st_guid_device_path,
			&dp_lf_prot,
			&efi_st_guid_load_file_protocol,
			&lf_prot,
			NULL);
		if (ret != EFI_SUCCESS) {
			efi_st_error(
				"UninstallMultipleProtocolInterfaces failed\n");
			return EFI_ST_FAILURE;
		}
	}
	if (handle_lf2) {
		ret = boottime->uninstall_multiple_protocol_interfaces(
			handle_lf2,
			&efi_st_guid_device_path,
			&dp_lf2_prot,
			&efi_st_guid_load_file2_protocol,
			&lf2_prot,
			NULL);
		if (ret != EFI_SUCCESS) {
			efi_st_error(
				"UninstallMultipleProtocolInterfaces failed\n");
			return EFI_ST_FAILURE;
		}
	}

	if (image) {
		ret = boottime->free_pool(image);
		if (ret != EFI_SUCCESS) {
			efi_st_error("Failed to free image\n");
			return EFI_ST_FAILURE;
		}
	}
	return ret;
}

/*
 * Execute unit test.
 *
 * Try loading an image via the EFI_LOAD_FILE_PROTOCOL and the
 * EFI_LOAD_FILE2_PROTOCOL. Finally execute the image.
 *
 * Return:	EFI_ST_SUCCESS for success
 */
static int efi_st_load_file_execute(void)
{
	efi_status_t ret;
	efi_handle_t handle;
	efi_uintn_t exit_data_size = 0;
	u16 *exit_data = NULL;
	u16 expected_text[] = EFI_ST_SUCCESS_STR;

	load_file_call_count = 0;
	load_file2_call_count = 0;
	handle = NULL;
	ret = boottime->load_image(true, image_handle, &dp_lf_file.v.dp, NULL,
				   0, &handle);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Failed to load image\n");
		return EFI_ST_FAILURE;
	}
	if (load_file2_call_count || !load_file_call_count) {
		efi_st_error("Wrong image loaded\n");
		return EFI_ST_FAILURE;
	}
	ret = boottime->unload_image(handle);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Failed to unload image\n");
		return EFI_ST_FAILURE;
	}

	load_file_call_count = 0;
	load_file2_call_count = 0;
	handle = NULL;
	ret = boottime->load_image(false, image_handle, &dp_lf_file.v.dp, NULL,
				   0, &handle);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Failed to load image\n");
		return EFI_ST_FAILURE;
	}
	if (load_file2_call_count || !load_file_call_count) {
		efi_st_error("Wrong image loaded\n");
		return EFI_ST_FAILURE;
	}
	ret = boottime->unload_image(handle);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Failed to unload image\n");
		return EFI_ST_FAILURE;
	}

	ret = boottime->load_image(true, image_handle, &dp_lf2_file.v.dp, NULL,
				   0, &handle);
	if (ret != EFI_NOT_FOUND) {
		efi_st_error(
			"Boot manager should not use LOAD_FILE2_PROTOCOL\n");
		return EFI_ST_FAILURE;
	}

	load_file_call_count = 0;
	load_file2_call_count = 0;
	handle = NULL;
	ret = boottime->load_image(false, image_handle, &dp_lf2_file.v.dp, NULL,
				   0, &handle);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Failed to load image\n");
		return EFI_ST_FAILURE;
	}
	if (!load_file2_call_count || load_file_call_count) {
		efi_st_error("Wrong image loaded\n");
		return EFI_ST_FAILURE;
	}

	ret = boottime->start_image(handle, &exit_data_size, &exit_data);
	if (ret != EFI_UNSUPPORTED) {
		efi_st_error("Wrong return value from application\n");
		return EFI_ST_FAILURE;
	}
	if (!exit_data || exit_data_size != sizeof(expected_text) ||
	    memcmp(exit_data, expected_text, sizeof(expected_text))) {
		efi_st_error("Incorrect exit data\n");
		return EFI_ST_FAILURE;
	}
	ret = boottime->free_pool(exit_data);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Failed to free exit data\n");
		return EFI_ST_FAILURE;
	}

	return EFI_ST_SUCCESS;
}

EFI_UNIT_TEST(load_file_protocol) = {
	.name = "load file protocol",
	.phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
	.setup = efi_st_load_file_setup,
	.execute = efi_st_load_file_execute,
	.teardown = efi_st_load_file_teardown,
};
Commit	Line	Data
7f8e6563 HS	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* efi_selftest_load_file
	4	*
	5	* Copyright (c) 2020 Heinrich Schuchardt <[email protected]>
	6	*
	7	* This test checks the handling of the LOAD_FILE and the LOAD_FILE2 protocol
	8	* by the LoadImage() service.
	9	*/
	10
	11	#include <efi_selftest.h>
	12	/* Include containing the miniapp.efi application */
	13	#include "efi_miniapp_file_image_exit.h"
	14
	15	/* Block size of compressed disk image */
	16	#define COMPRESSED_DISK_IMAGE_BLOCK_SIZE 8
	17
	18	/* Binary logarithm of the block size */
	19	#define LB_BLOCK_SIZE 9
	20
	21	#define GUID_VENDOR \
	22	EFI_GUID(0xdbca4c98, 0x6cb0, 0x694d, \
	23	0x08, 0x72, 0x81, 0x9c, 0x65, 0xfc, 0xbb, 0xd1)
	24
	25	#define GUID_VENDOR2 \
	26	EFI_GUID(0xdbca4c98, 0x6cb0, 0x694d, \
	27	0x08, 0x72, 0x81, 0x9c, 0x65, 0xfc, 0xbb, 0xd2)
	28
	29	#define FILE_NAME_SIZE 16
	30
	31	static const efi_guid_t efi_st_guid_load_file_protocol =
	32	EFI_LOAD_FILE_PROTOCOL_GUID;
	33	static const efi_guid_t efi_st_guid_load_file2_protocol =
	34	EFI_LOAD_FILE2_PROTOCOL_GUID;
	35	static const efi_guid_t efi_st_guid_device_path =
	36	EFI_DEVICE_PATH_PROTOCOL_GUID;
	37
	38	static efi_handle_t image_handle;
	39	static struct efi_boot_services *boottime;
	40	static efi_handle_t handle_lf;
	41	static efi_handle_t handle_lf2;
	42
	43	/* One 8 byte block of the compressed disk image */
	44	struct line {
	45	size_t addr;
	46	char *line;
	47	};
	48
	49	/* Compressed file image */
	50	struct compressed_file_image {
	51	size_t length;
	52	struct line lines[];
	53	};
	54
	55	static struct compressed_file_image img = EFI_ST_DISK_IMG;
	56
	57	static int load_file_call_count;
	58	static int load_file2_call_count;
	59
	60	/* Decompressed file image */
	61	static u8 *image;
	62
	63	static struct {
	64	struct efi_device_path_vendor v;
65	struct efi_device_path d;
66	} dp_lf_prot = {
67	{
68	{
69	DEVICE_PATH_TYPE_HARDWARE_DEVICE,
70	DEVICE_PATH_SUB_TYPE_VENDOR,
71	sizeof(struct efi_device_path_vendor),
72	},
73	GUID_VENDOR,
74	},
75	{
76	DEVICE_PATH_TYPE_END,
77	DEVICE_PATH_SUB_TYPE_END,
78	sizeof(struct efi_device_path),
79	},
80	};
81
82	static struct {
83	struct efi_device_path_vendor v;
84	struct efi_device_path_file_path f;
85	u16 file_name[FILE_NAME_SIZE];
86	struct efi_device_path e;
87	} dp_lf_file = {
88	{
89	{
90	DEVICE_PATH_TYPE_HARDWARE_DEVICE,
91	DEVICE_PATH_SUB_TYPE_VENDOR,
92	sizeof(struct efi_device_path_vendor),
93	},
94	GUID_VENDOR,
95	},
96	{
97	{
98	DEVICE_PATH_TYPE_MEDIA_DEVICE,
99	DEVICE_PATH_SUB_TYPE_FILE_PATH,
100	sizeof(struct efi_device_path_file_path) +
101	FILE_NAME_SIZE * sizeof(u16),
102	}
103	},
156ccbc3	104	u"\\lf.efi",
7f8e6563 HS	105	{
	106	DEVICE_PATH_TYPE_END,
	107	DEVICE_PATH_SUB_TYPE_END,
	108	sizeof(struct efi_device_path),
	109	},
	110	};
	111
	112	struct efi_device_path *dp_lf_file_remainder = &dp_lf_file.f.dp;
	113
	114	static struct {
	115	struct efi_device_path_vendor v;
	116	struct efi_device_path d;
	117	} dp_lf2_prot = {
	118	{
	119	{
	120	DEVICE_PATH_TYPE_HARDWARE_DEVICE,
	121	DEVICE_PATH_SUB_TYPE_VENDOR,
	122	sizeof(struct efi_device_path_vendor),
	123	},
	124	GUID_VENDOR2,
	125	},
	126	{
	127	DEVICE_PATH_TYPE_END,
	128	DEVICE_PATH_SUB_TYPE_END,
	129	sizeof(struct efi_device_path),
	130	},
	131	};
	132
	133	static struct {
	134	struct efi_device_path_vendor v;
	135	struct efi_device_path_file_path f;
	136	u16 file_name[FILE_NAME_SIZE];
	137	struct efi_device_path e;
	138	} dp_lf2_file = {
	139	{
	140	{
	141	DEVICE_PATH_TYPE_HARDWARE_DEVICE,
	142	DEVICE_PATH_SUB_TYPE_VENDOR,
	143	sizeof(struct efi_device_path_vendor),
	144	},
	145	GUID_VENDOR2,
	146	},
	147	{
	148	{
	149	DEVICE_PATH_TYPE_MEDIA_DEVICE,
	150	DEVICE_PATH_SUB_TYPE_FILE_PATH,
	151	sizeof(struct efi_device_path_file_path) +
	152	FILE_NAME_SIZE * sizeof(u16),
	153	}
	154	},
156ccbc3	155	u"\\lf2.efi",
7f8e6563 HS	156	{
	157	DEVICE_PATH_TYPE_END,
	158	DEVICE_PATH_SUB_TYPE_END,
	159	sizeof(struct efi_device_path),
	160	},
	161	};
	162
	163	struct efi_device_path *dp_lf2_file_remainder = &dp_lf2_file.f.dp;
	164
	165	/*
	166	* Decompress the disk image.
	167	*
	168	* @image decompressed disk image
185f812c	169	* Return: status code
7f8e6563 HS	170	*/
	171	static efi_status_t decompress(u8 **image)
	172	{
	173	u8 *buf;
	174	size_t i;
	175	size_t addr;
	176	size_t len;
	177	efi_status_t ret;
	178
	179	ret = boottime->allocate_pool(EFI_LOADER_DATA, img.length,
	180	(void **)&buf);
	181	if (ret != EFI_SUCCESS) {
	182	efi_st_error("Out of memory\n");
	183	return ret;
	184	}
	185	boottime->set_mem(buf, img.length, 0);
	186
	187	for (i = 0; ; ++i) {
	188	if (!img.lines[i].line)
	189	break;
	190	addr = img.lines[i].addr;
	191	len = COMPRESSED_DISK_IMAGE_BLOCK_SIZE;
	192	if (addr + len > img.length)
	193	len = img.length - addr;
	194	boottime->copy_mem(buf + addr, img.lines[i].line, len);
	195	}
	196	*image = buf;
	197	return ret;
	198	}
	199
	200	/*
	201	* load_file() - LoadFile() service of a EFI_LOAD_FILE_PROTOCOL
	202	*
	203	* @this: instance of EFI_LOAD_FILE_PROTOCOL
	204	* @file_path: remaining device path
	205	* @boot_policy: true if called by boot manager
	206	* @buffer_size: (required) buffer size
	207	* @buffer: buffer to which the file is to be loaded
	208	*/
8063c55e BM	209	static efi_status_t EFIAPI load_file(struct efi_load_file_protocol *this,
	210	struct efi_device_path *file_path,
	211	bool boot_policy,
	212	efi_uintn_t *buffer_size,
	213	void *buffer)
7f8e6563 HS	214	{
	215	++load_file_call_count;
	216	if (memcmp(file_path, dp_lf_file_remainder,
	217	sizeof(struct efi_device_path_file_path) +
	218	FILE_NAME_SIZE * sizeof(u16) +
	219	sizeof(struct efi_device_path))) {
	220	efi_st_error("Wrong remaining device path\n");
	221	return EFI_NOT_FOUND;
	222	}
	223	if (this->load_file != load_file) {
	224	efi_st_error("wrong this\n");
	225	return EFI_INVALID_PARAMETER;
	226	}
	227	if (*buffer_size < img.length) {
	228	*buffer_size = img.length;
	229	return EFI_BUFFER_TOO_SMALL;
	230	}
	231	memcpy(buffer, image, img.length);
	232	*buffer_size = img.length;
	233	return EFI_SUCCESS;
	234	}
	235
	236
	237	/*
	238	* load_file2() - LoadFile() service of a EFI_LOAD_FILE2_PROTOCOL
	239	*
	240	* @this: instance of EFI_LOAD_FILE2_PROTOCOL
	241	* @file_path: remaining device path
	242	* @boot_policy: true if called by boot manager
	243	* @buffer_size: (required) buffer size
	244	* @buffer: buffer to which the file is to be loaded
	245	*/
8063c55e BM	246	static efi_status_t EFIAPI load_file2(struct efi_load_file_protocol *this,
	247	struct efi_device_path *file_path,
	248	bool boot_policy,
	249	efi_uintn_t *buffer_size,
	250	void *buffer)
7f8e6563 HS	251	{
	252	++load_file2_call_count;
	253	if (memcmp(file_path, dp_lf2_file_remainder,
	254	sizeof(struct efi_device_path_file_path) +
	255	FILE_NAME_SIZE * sizeof(u16) +
	256	sizeof(struct efi_device_path))) {
	257	efi_st_error("Wrong remaining device path\n");
	258	return EFI_NOT_FOUND;
	259	}
	260	if (this->load_file != load_file2) {
	261	efi_st_error("wrong this\n");
	262	return EFI_INVALID_PARAMETER;
	263	}
	264	if (boot_policy) {
	265	efi_st_error("LOAD_FILE2 called with boot_policy = true");
	266	return EFI_INVALID_PARAMETER;
	267	}
	268	if (*buffer_size < img.length) {
	269	*buffer_size = img.length;
	270	return EFI_BUFFER_TOO_SMALL;
	271	}
	272	memcpy(buffer, image, img.length);
	273	*buffer_size = img.length;
	274	return EFI_SUCCESS;
	275	}
	276
	277	static struct efi_load_file_protocol lf_prot = {load_file};
	278	static struct efi_load_file_protocol lf2_prot = {load_file2};
	279
	280	/*
	281	* Setup unit test.
	282	*
	283	* Install an EFI_LOAD_FILE_PROTOCOL and an EFI_LOAD_FILE2_PROTOCOL.
	284	*
	285	* @handle: handle of the loaded image
	286	* @systable: system table
3dd719d4	287	* Return: EFI_ST_SUCCESS for success
7f8e6563 HS	288	*/
	289	static int efi_st_load_file_setup(const efi_handle_t handle,
	290	const struct efi_system_table *systable)
	291	{
	292	efi_status_t ret;
	293
	294	image_handle = handle;
	295	boottime = systable->boottime;
	296
	297	/* Load the application image into memory */
	298	decompress(&image);
	299
	300	ret = boottime->install_multiple_protocol_interfaces(
	301	&handle_lf,
	302	&efi_st_guid_device_path,
	303	&dp_lf_prot,
	304	&efi_st_guid_load_file_protocol,
	305	&lf_prot,
	306	NULL);
	307	if (ret != EFI_SUCCESS) {
	308	efi_st_error("InstallMultipleProtocolInterfaces failed\n");
	309	return EFI_ST_FAILURE;
	310	}
	311	ret = boottime->install_multiple_protocol_interfaces(
	312	&handle_lf2,
	313	&efi_st_guid_device_path,
	314	&dp_lf2_prot,
	315	&efi_st_guid_load_file2_protocol,
	316	&lf2_prot,
	317	NULL);
	318	if (ret != EFI_SUCCESS) {
	319	efi_st_error("InstallMultipleProtocolInterfaces failed\n");
	320	return EFI_ST_FAILURE;
	321	}
	322
	323	return EFI_ST_SUCCESS;
	324	}
	325
	326	/*
	327	* Tear down unit test.
	328	*
3dd719d4	329	* Return: EFI_ST_SUCCESS for success
7f8e6563 HS	330	*/
	331	static int efi_st_load_file_teardown(void)
	332	{
	333	efi_status_t ret = EFI_ST_SUCCESS;
	334
	335	if (handle_lf) {
	336	ret = boottime->uninstall_multiple_protocol_interfaces(
	337	handle_lf,
	338	&efi_st_guid_device_path,
	339	&dp_lf_prot,
	340	&efi_st_guid_load_file_protocol,
	341	&lf_prot,
	342	NULL);
	343	if (ret != EFI_SUCCESS) {
	344	efi_st_error(
	345	"UninstallMultipleProtocolInterfaces failed\n");
	346	return EFI_ST_FAILURE;
	347	}
	348	}
	349	if (handle_lf2) {
	350	ret = boottime->uninstall_multiple_protocol_interfaces(
	351	handle_lf2,
	352	&efi_st_guid_device_path,
	353	&dp_lf2_prot,
	354	&efi_st_guid_load_file2_protocol,
	355	&lf2_prot,
	356	NULL);
	357	if (ret != EFI_SUCCESS) {
	358	efi_st_error(
	359	"UninstallMultipleProtocolInterfaces failed\n");
	360	return EFI_ST_FAILURE;
	361	}
	362	}
	363
	364	if (image) {
	365	ret = boottime->free_pool(image);
	366	if (ret != EFI_SUCCESS) {
	367	efi_st_error("Failed to free image\n");
	368	return EFI_ST_FAILURE;
	369	}
	370	}
	371	return ret;
	372	}
	373
	374	/*
	375	* Execute unit test.
	376	*
	377	* Try loading an image via the EFI_LOAD_FILE_PROTOCOL and the
	378	* EFI_LOAD_FILE2_PROTOCOL. Finally execute the image.
	379	*
3dd719d4	380	* Return: EFI_ST_SUCCESS for success
7f8e6563 HS	381	*/
	382	static int efi_st_load_file_execute(void)
	383	{
	384	efi_status_t ret;
	385	efi_handle_t handle;
	386	efi_uintn_t exit_data_size = 0;
	387	u16 *exit_data = NULL;
	388	u16 expected_text[] = EFI_ST_SUCCESS_STR;
	389
	390	load_file_call_count = 0;
	391	load_file2_call_count = 0;
	392	handle = NULL;
	393	ret = boottime->load_image(true, image_handle, &dp_lf_file.v.dp, NULL,
	394	0, &handle);
	395	if (ret != EFI_SUCCESS) {
	396	efi_st_error("Failed to load image\n");
	397	return EFI_ST_FAILURE;
	398	}
	399	if (load_file2_call_count \|\| !load_file_call_count) {
	400	efi_st_error("Wrong image loaded\n");
	401	return EFI_ST_FAILURE;
	402	}
	403	ret = boottime->unload_image(handle);
	404	if (ret != EFI_SUCCESS) {
	405	efi_st_error("Failed to unload image\n");
	406	return EFI_ST_FAILURE;
	407	}
	408
	409	load_file_call_count = 0;
	410	load_file2_call_count = 0;
	411	handle = NULL;
	412	ret = boottime->load_image(false, image_handle, &dp_lf_file.v.dp, NULL,
	413	0, &handle);
	414	if (ret != EFI_SUCCESS) {
	415	efi_st_error("Failed to load image\n");
	416	return EFI_ST_FAILURE;
	417	}
	418	if (load_file2_call_count \|\| !load_file_call_count) {
	419	efi_st_error("Wrong image loaded\n");
	420	return EFI_ST_FAILURE;
	421	}
	422	ret = boottime->unload_image(handle);
	423	if (ret != EFI_SUCCESS) {
	424	efi_st_error("Failed to unload image\n");
	425	return EFI_ST_FAILURE;
	426	}
	427
	428	ret = boottime->load_image(true, image_handle, &dp_lf2_file.v.dp, NULL,
	429	0, &handle);
	430	if (ret != EFI_NOT_FOUND) {
	431	efi_st_error(
	432	"Boot manager should not use LOAD_FILE2_PROTOCOL\n");
	433	return EFI_ST_FAILURE;
	434	}
	435
	436	load_file_call_count = 0;
	437	load_file2_call_count = 0;
	438	handle = NULL;
	439	ret = boottime->load_image(false, image_handle, &dp_lf2_file.v.dp, NULL,
	440	0, &handle);
	441	if (ret != EFI_SUCCESS) {
	442	efi_st_error("Failed to load image\n");
	443	return EFI_ST_FAILURE;
	444	}
445	if (!load_file2_call_count \|\| load_file_call_count) {
446	efi_st_error("Wrong image loaded\n");
447	return EFI_ST_FAILURE;
448	}
449
450	ret = boottime->start_image(handle, &exit_data_size, &exit_data);
451	if (ret != EFI_UNSUPPORTED) {
452	efi_st_error("Wrong return value from application\n");
453	return EFI_ST_FAILURE;
454	}
455	if (!exit_data \|\| exit_data_size != sizeof(expected_text) \|\|
456	memcmp(exit_data, expected_text, sizeof(expected_text))) {
457	efi_st_error("Incorrect exit data\n");
458	return EFI_ST_FAILURE;
459	}
460	ret = boottime->free_pool(exit_data);
461	if (ret != EFI_SUCCESS) {
462	efi_st_error("Failed to free exit data\n");
463	return EFI_ST_FAILURE;
464	}
465
466	return EFI_ST_SUCCESS;
467	}
468
469	EFI_UNIT_TEST(load_file_protocol) = {
470	.name = "load file protocol",
471	.phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
472	.setup = efi_st_load_file_setup,
473	.execute = efi_st_load_file_execute,
474	.teardown = efi_st_load_file_teardown,
475	};