[J-u-boot.git] / lib / efi_selftest / efi_selftest_loadimage.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * efi_selftest_loadimage
 *
 * Copyright (c) 2019 Heinrich Schuchardt <[email protected]>
 *
 * This test checks the LoadImage and StartImage boot service.
 *
 * The efi_selftest_miniapp_exit.efi application is loaded via a file device
 * path and started.
 */

#include <efi_selftest.h>
/* Include containing the efi_selftest_miniapp_exit.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 FILE_NAME L"app.efi"
#define VOLUME_NAME L"EfiDisk"

static struct efi_boot_services *boottime;
static efi_handle_t handle_image;
static efi_handle_t handle_volume;

static const efi_guid_t guid_device_path = EFI_DEVICE_PATH_PROTOCOL_GUID;
static const efi_guid_t guid_simple_file_system_protocol =
		EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID;
static const efi_guid_t guid_file_info = EFI_FILE_INFO_GUID;
static const efi_guid_t guid_file_system_info = EFI_FILE_SYSTEM_INFO_GUID;

/* 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[];
};

/* File info including file name */
struct file_info {
	struct efi_file_info info;
	u16 file_name[sizeof(FILE_NAME)];
};

/* File system info including volume name */
struct file_system_info {
	struct efi_file_system_info info;
	u16 file_name[sizeof(VOLUME_NAME)];
};

/* Compressed file image */
static struct compressed_file_image img = EFI_ST_DISK_IMG;

/* Pointer to decompressed file image */
static u8 *image;

/* File info */
static struct file_info priv_file_info = {
	{
		.size = sizeof(struct file_info),
		.attribute = EFI_FILE_READ_ONLY,
	},
	FILE_NAME,
};

/* Pointer to file info */
struct efi_file_info *file_info = &priv_file_info.info;

/* Volume device path */
static struct {
	struct efi_device_path_vendor vendor;
	struct efi_device_path end;
} __packed dp_volume = {
	.vendor = {
		.dp = {
			.type =	DEVICE_PATH_TYPE_HARDWARE_DEVICE,
			.sub_type = DEVICE_PATH_SUB_TYPE_VENDOR,
			.length = sizeof(struct efi_device_path_vendor),
		},
		.guid = EFI_GUID(0x4f9a0ebf, 0xa179, 0x88a6, 0x25, 0x68,
				 0x10, 0x72, 0xb1, 0x93, 0x51, 0x71),
	},
	.end = {
		.type = DEVICE_PATH_TYPE_END,
		.sub_type = DEVICE_PATH_SUB_TYPE_END,
		.length = sizeof(struct efi_device_path),
	}
};

/* File device path */
static struct {
	struct efi_device_path_vendor vendor;
	struct efi_device_path path;
	u16 file[sizeof(FILE_NAME)];
	struct efi_device_path end;
} __packed dp_file = {
	.vendor = {
		.dp = {
			.type =	DEVICE_PATH_TYPE_HARDWARE_DEVICE,
			.sub_type = DEVICE_PATH_SUB_TYPE_VENDOR,
			.length = sizeof(struct efi_device_path_vendor),
		},
		.guid = EFI_GUID(0x4f9a0ebf, 0xa179, 0x88a6, 0x25, 0x68,
				 0x10, 0x72, 0xb1, 0x93, 0x51, 0x71),
	},
	.path = {
		.type = DEVICE_PATH_TYPE_MEDIA_DEVICE,
		.sub_type = DEVICE_PATH_SUB_TYPE_FILE_PATH,
		.length = sizeof(struct efi_device_path) + sizeof(dp_file.file),
	},
	.file = FILE_NAME,
	.end = {
		.type = DEVICE_PATH_TYPE_END,
		.sub_type = DEVICE_PATH_SUB_TYPE_END,
		.length = sizeof(struct efi_device_path),
	}
};

/* File system info */
static struct file_system_info priv_file_system_info = {
	{
		.size = sizeof(struct file_system_info),
		.read_only = true,
		.volume_size = 0x100000,
		.free_space = 0x0,
		.block_size = 0x200,
	},
	VOLUME_NAME
};

/* Pointer to file system info */
static struct efi_file_system_info *file_system_info =
	&priv_file_system_info.info;

/* Forward definitions of file and file system functions */
static efi_status_t EFIAPI open_volume
	(struct efi_simple_file_system_protocol *this,
	 struct efi_file_handle **root);

static efi_status_t EFIAPI open
	(struct efi_file_handle *this,
	 struct efi_file_handle **new_handle,
	 u16 *file_name, u64 open_mode, u64 attributes);

static efi_status_t EFIAPI close(struct efi_file_handle *this);

static efi_status_t EFIAPI delete(struct efi_file_handle *this);

static efi_status_t EFIAPI read
	(struct efi_file_handle *this, efi_uintn_t *buffer_size, void *buffer);

static efi_status_t EFIAPI write
	(struct efi_file_handle *this, efi_uintn_t *buffer_size, void *buffer);

static efi_status_t EFIAPI getpos(struct efi_file_handle *this, u64 *pos);

static efi_status_t EFIAPI setpos(struct efi_file_handle *this, u64 pos);

static efi_status_t EFIAPI getinfo
	(struct efi_file_handle *this, const efi_guid_t *info_type,
	 efi_uintn_t *buffer_size, void *buffer);

static efi_status_t EFIAPI setinfo
	(struct efi_file_handle *this, const efi_guid_t *info_type,
	 efi_uintn_t buffer_size, void *buffer);

static efi_status_t EFIAPI flush(struct efi_file_handle *this);

/* Internal information about status of file system */
static struct {
	/* Difference of volume open count minus volume close count */
	int volume_open_count;
	/* Difference of file open count minus file close count */
	int file_open_count;
	/* File size */
	u64 file_size;
	/* Current position in file */
	u64 file_pos;
} priv;

/* EFI_FILE_PROTOCOL for file */
static struct efi_file_handle file = {
	.rev = 0x00010000,
	.open = open,
	.close = close,
	.delete = delete,
	.read = read,
	.write = write,
	.getpos = getpos,
	.setpos = setpos,
	.getinfo = getinfo,
	.setinfo = setinfo,
	.flush = flush,
};

/* EFI_FILE_PROTOCOL for root directory */
static struct efi_file_handle volume = {
	.rev = 0x00010000,
	.open = open,
	.close = close,
	.delete = delete,
	.read = read,
	.write = write,
	.getpos = getpos,
	.setpos = setpos,
	.getinfo = getinfo,
	.setinfo = setinfo,
	.flush = flush,
};

/* EFI_SIMPLE_FILE_SYSTEM_PROTOCOL of the block device */
struct efi_simple_file_system_protocol file_system = {
	.rev = 0x00010000,
	.open_volume = open_volume,
};

static efi_status_t EFIAPI open_volume
	(struct efi_simple_file_system_protocol *this,
	 struct efi_file_handle **root)
{
	if (this != &file_system || !root)
		return EFI_INVALID_PARAMETER;

	*root = &volume;
	priv.volume_open_count++;

	return EFI_SUCCESS;
}

static efi_status_t EFIAPI open
	(struct efi_file_handle *this,
	 struct efi_file_handle **new_handle,
	 u16 *file_name, u64 open_mode, u64 attributes)
{
	if (this != &volume)
		return EFI_INVALID_PARAMETER;

	*new_handle = &file;
	priv.file_pos = 0;
	priv.file_open_count++;

	return EFI_SUCCESS;
}

static efi_status_t EFIAPI close(struct efi_file_handle *this)
{
	if (this == &file)
		priv.file_open_count--;
	else if (this == &volume)
		priv.volume_open_count--;
	else
		return EFI_INVALID_PARAMETER;

	return EFI_SUCCESS;
}

static efi_status_t EFIAPI delete(struct efi_file_handle *this)
{
	if (this != &file)
		return EFI_INVALID_PARAMETER;

	return EFI_UNSUPPORTED;
}

static efi_status_t EFIAPI read
	(struct efi_file_handle *this, efi_uintn_t *buffer_size, void *buffer)
{
	if (this != &file)
		return EFI_INVALID_PARAMETER;

	if (priv.file_pos >= img.length)
		*buffer_size = 0;
	else if (priv.file_pos + *buffer_size > img.length)
		*buffer_size = img.length - priv.file_pos;

	boottime->copy_mem(buffer, &image[priv.file_pos], *buffer_size);
	priv.file_pos += *buffer_size;

	return EFI_SUCCESS;
}

static efi_status_t EFIAPI write
	(struct efi_file_handle *this, efi_uintn_t *buffer_size, void *buffer)
{
	if (this != &file)
		return EFI_INVALID_PARAMETER;

	return EFI_UNSUPPORTED;
}

static efi_status_t EFIAPI getpos(struct efi_file_handle *this, u64 *pos)
{
	if (this != &file)
		return EFI_INVALID_PARAMETER;

	*pos = priv.file_pos;

	return EFI_SUCCESS;
}

static efi_status_t EFIAPI setpos(struct efi_file_handle *this, u64 pos)
{
	if (this != &file)
		return EFI_INVALID_PARAMETER;

	priv.file_pos = pos;

	return EFI_SUCCESS;
}

static efi_status_t EFIAPI getinfo
	(struct efi_file_handle *this, const efi_guid_t *info_type,
	 efi_uintn_t *buffer_size, void *buffer)
{
	if (this == &file) {
		if (memcmp(info_type, &guid_file_info, sizeof(efi_guid_t)))
			return EFI_INVALID_PARAMETER;
		if (*buffer_size >= sizeof(struct file_info)) {
			boottime->copy_mem(buffer, file_info,
					   sizeof(struct file_info));
		} else {
			*buffer_size = sizeof(struct file_info);
			return EFI_BUFFER_TOO_SMALL;
		}
	} else if (this == &volume) {
		if (memcmp(info_type, &guid_file_system_info,
			   sizeof(efi_guid_t)))
			return EFI_INVALID_PARAMETER;
		if (*buffer_size >= sizeof(struct file_system_info)) {
			boottime->copy_mem(buffer, file_system_info,
					   sizeof(struct file_system_info));
		} else {
			*buffer_size = sizeof(struct file_system_info);
			return EFI_BUFFER_TOO_SMALL;
		}
	} else {
		return EFI_INVALID_PARAMETER;
	}
	return EFI_SUCCESS;
}

static efi_status_t EFIAPI setinfo
	(struct efi_file_handle *this, const efi_guid_t *info_type,
	 efi_uintn_t buffer_size, void *buffer)
{
	if (this != &file)
		return EFI_INVALID_PARAMETER;

	return EFI_UNSUPPORTED;
}

static efi_status_t EFIAPI flush(struct efi_file_handle *this)
{
	if (this != &file)
		return EFI_INVALID_PARAMETER;

	return EFI_UNSUPPORTED;
}

/*
 * 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;
	priv.file_size = img.length;
	file_info->file_size = img.length;
	return ret;
}

/*
 * Setup unit test.
 *
 * Decompress application image and provide a handle for the in memory block
 * device.
 *
 * @handle:	handle of the loaded image
 * @systable:	system table
 * @return:	EFI_ST_SUCCESS for success
 */
static int setup(const efi_handle_t handle,
		 const struct efi_system_table *systable)
{
	efi_status_t ret;

	handle_image = handle;
	boottime = systable->boottime;

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

	ret = boottime->install_protocol_interface
		(&handle_volume, &guid_device_path, EFI_NATIVE_INTERFACE,
		 &dp_volume);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Failed to install device path\n");
		return EFI_ST_FAILURE;
	}
	ret = boottime->install_protocol_interface
		(&handle_volume, &guid_simple_file_system_protocol,
		 EFI_NATIVE_INTERFACE, &file_system);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Failed to install simple file system protocol\n");
		return EFI_ST_FAILURE;
	}

	return EFI_ST_SUCCESS;
}

/*
 * Tear down unit test.
 *
 * Uninstall protocols and free memory.
 *
 * @return:	EFI_ST_SUCCESS for success
 */
static int teardown(void)
{
	efi_status_t ret = EFI_ST_SUCCESS;

	if (handle_volume) {
		ret = boottime->uninstall_protocol_interface
			(handle_volume, &guid_simple_file_system_protocol,
			 &file_system);
		if (ret != EFI_SUCCESS) {
			efi_st_error
				("Failed to uninstall simple file system protocol\n");
			return EFI_ST_FAILURE;
		}
		ret = boottime->uninstall_protocol_interface
			(handle_volume, &guid_device_path, &dp_volume);
		if (ret != EFI_SUCCESS) {
			efi_st_error
				("Failed to uninstall device path protocol\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.
 *
 * Load and start the application image.
 *
 * @return:	EFI_ST_SUCCESS for success
 */
static int execute(void)
{
	efi_status_t ret;
	efi_handle_t handle;

	ret = boottime->load_image(false, handle_image, &dp_file.vendor.dp,
				   NULL, 0, &handle);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Failed to load image\n");
		return EFI_ST_FAILURE;
	}
	ret = boottime->start_image(handle, NULL, NULL);
	if (ret != EFI_UNSUPPORTED) {
		efi_st_error("Wrong return value from application\n");
		return EFI_ST_FAILURE;
	}

	if (priv.file_open_count) {
		efi_st_error("File open count = %d, expected 0\n",
			     priv.file_open_count);
		return EFI_ST_FAILURE;
	}
	if (priv.volume_open_count) {
		efi_st_error("Volume open count = %d, expected 0\n",
			     priv.volume_open_count);
		return EFI_ST_FAILURE;
	}

	return EFI_ST_SUCCESS;
}

EFI_UNIT_TEST(loadimage) = {
	.name = "load image from file",
	.phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
	.setup = setup,
	.execute = execute,
	.teardown = teardown,
};
Commit	Line	Data
d787cadd HS	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* efi_selftest_loadimage
	4	*
	5	* Copyright (c) 2019 Heinrich Schuchardt <[email protected]>
	6	*
	7	* This test checks the LoadImage and StartImage boot service.
	8	*
	9	* The efi_selftest_miniapp_exit.efi application is loaded via a file device
	10	* path and started.
	11	*/
	12
	13	#include <efi_selftest.h>
	14	/* Include containing the efi_selftest_miniapp_exit.efi application */
	15	#include "efi_miniapp_file_image_exit.h"
	16
	17	/* Block size of compressed disk image */
	18	#define COMPRESSED_DISK_IMAGE_BLOCK_SIZE 8
	19
	20	/* Binary logarithm of the block size */
	21	#define LB_BLOCK_SIZE 9
	22
	23	#define FILE_NAME L"app.efi"
	24	#define VOLUME_NAME L"EfiDisk"
	25
	26	static struct efi_boot_services *boottime;
	27	static efi_handle_t handle_image;
	28	static efi_handle_t handle_volume;
	29
dec88e41	30	static const efi_guid_t guid_device_path = EFI_DEVICE_PATH_PROTOCOL_GUID;
d787cadd HS	31	static const efi_guid_t guid_simple_file_system_protocol =
	32	EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID;
	33	static const efi_guid_t guid_file_info = EFI_FILE_INFO_GUID;
	34	static const efi_guid_t guid_file_system_info = EFI_FILE_SYSTEM_INFO_GUID;
	35
	36	/* One 8 byte block of the compressed disk image */
	37	struct line {
	38	size_t addr;
	39	char *line;
	40	};
	41
	42	/* Compressed file image */
	43	struct compressed_file_image {
	44	size_t length;
	45	struct line lines[];
	46	};
	47
	48	/* File info including file name */
	49	struct file_info {
	50	struct efi_file_info info;
	51	u16 file_name[sizeof(FILE_NAME)];
	52	};
	53
	54	/* File system info including volume name */
	55	struct file_system_info {
	56	struct efi_file_system_info info;
	57	u16 file_name[sizeof(VOLUME_NAME)];
	58	};
	59
	60	/* Compressed file image */
	61	static struct compressed_file_image img = EFI_ST_DISK_IMG;
	62
	63	/* Pointer to decompressed file image */
	64	static u8 *image;
	65
	66	/* File info */
	67	static struct file_info priv_file_info = {
	68	{
	69	.size = sizeof(struct file_info),
	70	.attribute = EFI_FILE_READ_ONLY,
	71	},
	72	FILE_NAME,
	73	};
	74
	75	/* Pointer to file info */
	76	struct efi_file_info *file_info = &priv_file_info.info;
	77
	78	/* Volume device path */
	79	static struct {
	80	struct efi_device_path_vendor vendor;
	81	struct efi_device_path end;
	82	} __packed dp_volume = {
	83	.vendor = {
	84	.dp = {
	85	.type = DEVICE_PATH_TYPE_HARDWARE_DEVICE,
	86	.sub_type = DEVICE_PATH_SUB_TYPE_VENDOR,
	87	.length = sizeof(struct efi_device_path_vendor),
	88	},
	89	.guid = EFI_GUID(0x4f9a0ebf, 0xa179, 0x88a6, 0x25, 0x68,
	90	0x10, 0x72, 0xb1, 0x93, 0x51, 0x71),
	91	},
	92	.end = {
	93	.type = DEVICE_PATH_TYPE_END,
	94	.sub_type = DEVICE_PATH_SUB_TYPE_END,
95	.length = sizeof(struct efi_device_path),
96	}
97	};
98
99	/* File device path */
100	static struct {
101	struct efi_device_path_vendor vendor;
102	struct efi_device_path path;
103	u16 file[sizeof(FILE_NAME)];
104	struct efi_device_path end;
105	} __packed dp_file = {
106	.vendor = {
107	.dp = {
108	.type = DEVICE_PATH_TYPE_HARDWARE_DEVICE,
109	.sub_type = DEVICE_PATH_SUB_TYPE_VENDOR,
110	.length = sizeof(struct efi_device_path_vendor),
111	},
112	.guid = EFI_GUID(0x4f9a0ebf, 0xa179, 0x88a6, 0x25, 0x68,
113	0x10, 0x72, 0xb1, 0x93, 0x51, 0x71),
114	},
115	.path = {
116	.type = DEVICE_PATH_TYPE_MEDIA_DEVICE,
117	.sub_type = DEVICE_PATH_SUB_TYPE_FILE_PATH,
118	.length = sizeof(struct efi_device_path) + sizeof(dp_file.file),
119	},
120	.file = FILE_NAME,
121	.end = {
122	.type = DEVICE_PATH_TYPE_END,
123	.sub_type = DEVICE_PATH_SUB_TYPE_END,
124	.length = sizeof(struct efi_device_path),
125	}
126	};
127
128	/* File system info */
129	static struct file_system_info priv_file_system_info = {
130	{
131	.size = sizeof(struct file_system_info),
132	.read_only = true,
133	.volume_size = 0x100000,
134	.free_space = 0x0,
135	.block_size = 0x200,
136	},
137	VOLUME_NAME
138	};
139
140	/* Pointer to file system info */
141	static struct efi_file_system_info *file_system_info =
142	&priv_file_system_info.info;
143
144	/* Forward definitions of file and file system functions */
145	static efi_status_t EFIAPI open_volume
146	(struct efi_simple_file_system_protocol *this,
147	struct efi_file_handle **root);
148
149	static efi_status_t EFIAPI open
150	(struct efi_file_handle *this,
151	struct efi_file_handle **new_handle,
152	u16 *file_name, u64 open_mode, u64 attributes);
153
154	static efi_status_t EFIAPI close(struct efi_file_handle *this);
155
156	static efi_status_t EFIAPI delete(struct efi_file_handle *this);
157
158	static efi_status_t EFIAPI read
159	(struct efi_file_handle this, efi_uintn_t buffer_size, void *buffer);
160
161	static efi_status_t EFIAPI write
162	(struct efi_file_handle this, efi_uintn_t buffer_size, void *buffer);
163
164	static efi_status_t EFIAPI getpos(struct efi_file_handle this, u64 pos);
165
166	static efi_status_t EFIAPI setpos(struct efi_file_handle *this, u64 pos);
167
168	static efi_status_t EFIAPI getinfo
169	(struct efi_file_handle this, const efi_guid_t info_type,
170	efi_uintn_t buffer_size, void buffer);
171
172	static efi_status_t EFIAPI setinfo
173	(struct efi_file_handle this, const efi_guid_t info_type,
174	efi_uintn_t buffer_size, void *buffer);
175
176	static efi_status_t EFIAPI flush(struct efi_file_handle *this);
177
178	/* Internal information about status of file system */
179	static struct {
180	/* Difference of volume open count minus volume close count */
181	int volume_open_count;
182	/* Difference of file open count minus file close count */
183	int file_open_count;
184	/* File size */
185	u64 file_size;
186	/* Current position in file */
187	u64 file_pos;
188	} priv;
189
190	/* EFI_FILE_PROTOCOL for file */
191	static struct efi_file_handle file = {
192	.rev = 0x00010000,
193	.open = open,
194	.close = close,
195	.delete = delete,
196	.read = read,
197	.write = write,
198	.getpos = getpos,
199	.setpos = setpos,
200	.getinfo = getinfo,
201	.setinfo = setinfo,
202	.flush = flush,
203	};
204
205	/* EFI_FILE_PROTOCOL for root directory */
206	static struct efi_file_handle volume = {
207	.rev = 0x00010000,
208	.open = open,
209	.close = close,
210	.delete = delete,
211	.read = read,
212	.write = write,
213	.getpos = getpos,
214	.setpos = setpos,
215	.getinfo = getinfo,
216	.setinfo = setinfo,
217	.flush = flush,
218	};
219
220	/* EFI_SIMPLE_FILE_SYSTEM_PROTOCOL of the block device */
221	struct efi_simple_file_system_protocol file_system = {
222	.rev = 0x00010000,
223	.open_volume = open_volume,
224	};
225
226	static efi_status_t EFIAPI open_volume
227	(struct efi_simple_file_system_protocol *this,
228	struct efi_file_handle **root)
229	{
230	if (this != &file_system \|\| !root)
231	return EFI_INVALID_PARAMETER;
232
233	*root = &volume;
234	priv.volume_open_count++;
235
236	return EFI_SUCCESS;
237	}
238
239	static efi_status_t EFIAPI open
240	(struct efi_file_handle *this,
241	struct efi_file_handle **new_handle,
242	u16 *file_name, u64 open_mode, u64 attributes)
243	{
244	if (this != &volume)
245	return EFI_INVALID_PARAMETER;
246
247	*new_handle = &file;
248	priv.file_pos = 0;
249	priv.file_open_count++;
250
251	return EFI_SUCCESS;
252	}
253
254	static efi_status_t EFIAPI close(struct efi_file_handle *this)
255	{
256	if (this == &file)
257	priv.file_open_count--;
258	else if (this == &volume)
259	priv.volume_open_count--;
260	else
261	return EFI_INVALID_PARAMETER;
262
263	return EFI_SUCCESS;
264	}
265
266	static efi_status_t EFIAPI delete(struct efi_file_handle *this)
267	{
268	if (this != &file)
269	return EFI_INVALID_PARAMETER;
270
271	return EFI_UNSUPPORTED;
272	}
273
274	static efi_status_t EFIAPI read
275	(struct efi_file_handle this, efi_uintn_t buffer_size, void *buffer)
276	{
277	if (this != &file)
278	return EFI_INVALID_PARAMETER;
279
280	if (priv.file_pos >= img.length)
281	*buffer_size = 0;
282	else if (priv.file_pos + *buffer_size > img.length)
283	*buffer_size = img.length - priv.file_pos;
284
285	boottime->copy_mem(buffer, &image[priv.file_pos], *buffer_size);
286	priv.file_pos += *buffer_size;
287
288	return EFI_SUCCESS;
289	}
290
291	static efi_status_t EFIAPI write
292	(struct efi_file_handle this, efi_uintn_t buffer_size, void *buffer)
293	{
294	if (this != &file)
295	return EFI_INVALID_PARAMETER;
296
297	return EFI_UNSUPPORTED;
298	}
299
300	static efi_status_t EFIAPI getpos(struct efi_file_handle this, u64 pos)
301	{
302	if (this != &file)
303	return EFI_INVALID_PARAMETER;
304
305	*pos = priv.file_pos;
306
307	return EFI_SUCCESS;
308	}
309
310	static efi_status_t EFIAPI setpos(struct efi_file_handle *this, u64 pos)
311	{
312	if (this != &file)
313	return EFI_INVALID_PARAMETER;
314
315	priv.file_pos = pos;
316
317	return EFI_SUCCESS;
318	}
319
320	static efi_status_t EFIAPI getinfo
321	(struct efi_file_handle this, const efi_guid_t info_type,
322	efi_uintn_t buffer_size, void buffer)
323	{
324	if (this == &file) {
8101dd3d	325	if (memcmp(info_type, &guid_file_info, sizeof(efi_guid_t)))
d787cadd HS	326	return EFI_INVALID_PARAMETER;
	327	if (*buffer_size >= sizeof(struct file_info)) {
	328	boottime->copy_mem(buffer, file_info,
	329	sizeof(struct file_info));
	330	} else {
	331	*buffer_size = sizeof(struct file_info);
	332	return EFI_BUFFER_TOO_SMALL;
	333	}
	334	} else if (this == &volume) {
8101dd3d HS	335	if (memcmp(info_type, &guid_file_system_info,
8101dd3d HS	336	sizeof(efi_guid_t)))
d787cadd HS	337	return EFI_INVALID_PARAMETER;
	338	if (*buffer_size >= sizeof(struct file_system_info)) {
	339	boottime->copy_mem(buffer, file_system_info,
	340	sizeof(struct file_system_info));
	341	} else {
	342	*buffer_size = sizeof(struct file_system_info);
	343	return EFI_BUFFER_TOO_SMALL;
	344	}
	345	} else {
	346	return EFI_INVALID_PARAMETER;
	347	}
	348	return EFI_SUCCESS;
	349	}
	350
	351	static efi_status_t EFIAPI setinfo
	352	(struct efi_file_handle this, const efi_guid_t info_type,
	353	efi_uintn_t buffer_size, void *buffer)
	354	{
	355	if (this != &file)
	356	return EFI_INVALID_PARAMETER;
	357
	358	return EFI_UNSUPPORTED;
	359	}
	360
	361	static efi_status_t EFIAPI flush(struct efi_file_handle *this)
	362	{
	363	if (this != &file)
	364	return EFI_INVALID_PARAMETER;
	365
	366	return EFI_UNSUPPORTED;
	367	}
	368
	369	/*
	370	* Decompress the disk image.
	371	*
	372	* @image decompressed disk image
	373	* @return status code
	374	*/
	375	static efi_status_t decompress(u8 **image)
	376	{
	377	u8 *buf;
	378	size_t i;
	379	size_t addr;
	380	size_t len;
	381	efi_status_t ret;
	382
	383	ret = boottime->allocate_pool(EFI_LOADER_DATA, img.length,
	384	(void **)&buf);
	385	if (ret != EFI_SUCCESS) {
	386	efi_st_error("Out of memory\n");
	387	return ret;
	388	}
	389	boottime->set_mem(buf, img.length, 0);
	390
	391	for (i = 0; ; ++i) {
	392	if (!img.lines[i].line)
	393	break;
	394	addr = img.lines[i].addr;
	395	len = COMPRESSED_DISK_IMAGE_BLOCK_SIZE;
	396	if (addr + len > img.length)
	397	len = img.length - addr;
	398	boottime->copy_mem(buf + addr, img.lines[i].line, len);
	399	}
	400	*image = buf;
401	priv.file_size = img.length;
402	file_info->file_size = img.length;
403	return ret;
404	}
405
406	/*
407	* Setup unit test.
408	*
409	* Decompress application image and provide a handle for the in memory block
410	* device.
411	*
412	* @handle: handle of the loaded image
413	* @systable: system table
414	* @return: EFI_ST_SUCCESS for success
415	*/
416	static int setup(const efi_handle_t handle,
417	const struct efi_system_table *systable)
418	{
419	efi_status_t ret;
420
421	handle_image = handle;
422	boottime = systable->boottime;
423
424	/* Load the application image into memory */
425	decompress(&image);
426
427	ret = boottime->install_protocol_interface
428	(&handle_volume, &guid_device_path, EFI_NATIVE_INTERFACE,
429	&dp_volume);
430	if (ret != EFI_SUCCESS) {
431	efi_st_error("Failed to install device path\n");
432	return EFI_ST_FAILURE;
433	}
434	ret = boottime->install_protocol_interface
435	(&handle_volume, &guid_simple_file_system_protocol,
436	EFI_NATIVE_INTERFACE, &file_system);
437	if (ret != EFI_SUCCESS) {
438	efi_st_error("Failed to install simple file system protocol\n");
439	return EFI_ST_FAILURE;
440	}
441
442	return EFI_ST_SUCCESS;
443	}
444
445	/*
446	* Tear down unit test.
447	*
448	* Uninstall protocols and free memory.
449	*
450	* @return: EFI_ST_SUCCESS for success
451	*/
452	static int teardown(void)
453	{
454	efi_status_t ret = EFI_ST_SUCCESS;
455
456	if (handle_volume) {
457	ret = boottime->uninstall_protocol_interface
458	(handle_volume, &guid_simple_file_system_protocol,
459	&file_system);
460	if (ret != EFI_SUCCESS) {
461	efi_st_error
462	("Failed to uninstall simple file system protocol\n");
463	return EFI_ST_FAILURE;
464	}
465	ret = boottime->uninstall_protocol_interface
466	(handle_volume, &guid_device_path, &dp_volume);
467	if (ret != EFI_SUCCESS) {
468	efi_st_error
469	("Failed to uninstall device path protocol\n");
470	return EFI_ST_FAILURE;
471	}
472	}
473
474	if (image) {
475	ret = boottime->free_pool(image);
476	if (ret != EFI_SUCCESS) {
477	efi_st_error("Failed to free image\n");
478	return EFI_ST_FAILURE;
479	}
480	}
481	return ret;
482	}
483
484	/*
485	* Execute unit test.
486	*
487	* Load and start the application image.
488	*
489	* @return: EFI_ST_SUCCESS for success
490	*/
491	static int execute(void)
492	{
493	efi_status_t ret;
494	efi_handle_t handle;
495
496	ret = boottime->load_image(false, handle_image, &dp_file.vendor.dp,
497	NULL, 0, &handle);
498	if (ret != EFI_SUCCESS) {
499	efi_st_error("Failed to load image\n");
500	return EFI_ST_FAILURE;
501	}
502	ret = boottime->start_image(handle, NULL, NULL);
503	if (ret != EFI_UNSUPPORTED) {
504	efi_st_error("Wrong return value from application\n");
505	return EFI_ST_FAILURE;
506	}
507
508	if (priv.file_open_count) {
509	efi_st_error("File open count = %d, expected 0\n",
510	priv.file_open_count);
511	return EFI_ST_FAILURE;
512	}
513	if (priv.volume_open_count) {
514	efi_st_error("Volume open count = %d, expected 0\n",
515	priv.volume_open_count);
516	return EFI_ST_FAILURE;
517	}
518
519	return EFI_ST_SUCCESS;
520	}
521
522	EFI_UNIT_TEST(loadimage) = {
523	.name = "load image from file",
524	.phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
525	.setup = setup,
526	.execute = execute,
527	.teardown = teardown,
528	};