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

// SPDX-License-Identifier: GPL-2.0+
/*
 * efi_selftest_block
 *
 * Copyright (c) 2017 Heinrich Schuchardt <[email protected]>
 *
 * This test checks the driver for block IO devices.
 * A disk image is created in memory.
 * A handle is created for the new block IO device.
 * The block I/O protocol is installed on the handle.
 * ConnectController is used to setup partitions and to install the simple
 * file protocol.
 * A known file is read from the file system and verified.
 * The same block is read via the EFI_BLOCK_IO_PROTOCOL and compared to the file
 * contents.
 */

#include <efi_selftest.h>
#include "efi_selftest_disk_image.h"
#include <asm/cache.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

static struct efi_boot_services *boottime;

static const efi_guid_t block_io_protocol_guid = EFI_BLOCK_IO_PROTOCOL_GUID;
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_system_info = EFI_FILE_SYSTEM_INFO_GUID;
static efi_guid_t guid_vendor =
	EFI_GUID(0xdbca4c98, 0x6cb0, 0x694d,
		 0x08, 0x72, 0x81, 0x9c, 0x65, 0x0c, 0xb7, 0xb8);

static struct efi_device_path *dp;

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

/* Compressed disk image */
struct compressed_disk_image {
	size_t length;
	struct line lines[];
};

static const struct compressed_disk_image img = EFI_ST_DISK_IMG;

/* Decompressed disk image */
static u8 *image;

/*
 * Reset service of the block IO protocol.
 *
 * @this	block IO protocol
 * Return:	status code
 */
static efi_status_t EFIAPI reset(
			struct efi_block_io *this,
			char extended_verification)
{
	return EFI_SUCCESS;
}

/*
 * Read service of the block IO protocol.
 *
 * @this	block IO protocol
 * @media_id	media id
 * @lba		start of the read in logical blocks
 * @buffer_size	number of bytes to read
 * @buffer	target buffer
 * Return:	status code
 */
static efi_status_t EFIAPI read_blocks(
			struct efi_block_io *this, u32 media_id, u64 lba,
			efi_uintn_t buffer_size, void *buffer)
{
	u8 *start;

	if ((lba << LB_BLOCK_SIZE) + buffer_size > img.length)
		return EFI_INVALID_PARAMETER;
	start = image + (lba << LB_BLOCK_SIZE);

	boottime->copy_mem(buffer, start, buffer_size);

	return EFI_SUCCESS;
}

/*
 * Write service of the block IO protocol.
 *
 * @this	block IO protocol
 * @media_id	media id
 * @lba		start of the write in logical blocks
 * @buffer_size	number of bytes to read
 * @buffer	source buffer
 * Return:	status code
 */
static efi_status_t EFIAPI write_blocks(
			struct efi_block_io *this, u32 media_id, u64 lba,
			efi_uintn_t buffer_size, void *buffer)
{
	u8 *start;

	if ((lba << LB_BLOCK_SIZE) + buffer_size > img.length)
		return EFI_INVALID_PARAMETER;
	start = image + (lba << LB_BLOCK_SIZE);

	boottime->copy_mem(start, buffer, buffer_size);

	return EFI_SUCCESS;
}

/*
 * Flush service of the block IO protocol.
 *
 * @this	block IO protocol
 * Return:	status code
 */
static efi_status_t EFIAPI flush_blocks(struct efi_block_io *this)
{
	return EFI_SUCCESS;
}

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

static struct efi_block_io_media media;

static struct efi_block_io block_io = {
	.media = &media,
	.reset = reset,
	.read_blocks = read_blocks,
	.write_blocks = write_blocks,
	.flush_blocks = flush_blocks,
};

/* Handle for the block IO device */
static efi_handle_t disk_handle;

/*
 * Setup unit test.
 *
 * @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;
	struct efi_device_path_vendor vendor_node;
	struct efi_device_path end_node;

	boottime = systable->boottime;

	decompress(&image);

	block_io.media->block_size = 1 << LB_BLOCK_SIZE;
	block_io.media->last_block = (img.length >> LB_BLOCK_SIZE) - 1;

	ret = boottime->install_protocol_interface(
				&disk_handle, &block_io_protocol_guid,
				EFI_NATIVE_INTERFACE, &block_io);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Failed to install block I/O protocol\n");
		return EFI_ST_FAILURE;
	}

	ret = boottime->allocate_pool(EFI_LOADER_DATA,
				      sizeof(struct efi_device_path_vendor) +
				      sizeof(struct efi_device_path),
				      (void **)&dp);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Out of memory\n");
		return EFI_ST_FAILURE;
	}
	vendor_node.dp.type = DEVICE_PATH_TYPE_HARDWARE_DEVICE;
	vendor_node.dp.sub_type = DEVICE_PATH_SUB_TYPE_VENDOR;
	vendor_node.dp.length = sizeof(struct efi_device_path_vendor);

	boottime->copy_mem(&vendor_node.guid, &guid_vendor,
			   sizeof(efi_guid_t));
	boottime->copy_mem(dp, &vendor_node,
			   sizeof(struct efi_device_path_vendor));
	end_node.type = DEVICE_PATH_TYPE_END;
	end_node.sub_type = DEVICE_PATH_SUB_TYPE_END;
	end_node.length = sizeof(struct efi_device_path);

	boottime->copy_mem((char *)dp + sizeof(struct efi_device_path_vendor),
			   &end_node, sizeof(struct efi_device_path));
	ret = boottime->install_protocol_interface(&disk_handle,
						   &guid_device_path,
						   EFI_NATIVE_INTERFACE,
						   dp);
	if (ret != EFI_SUCCESS) {
		efi_st_error("InstallProtocolInterface failed\n");
		return EFI_ST_FAILURE;
	}
	return EFI_ST_SUCCESS;
}

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

	if (disk_handle) {
		r = boottime->uninstall_protocol_interface(disk_handle,
							   &guid_device_path,
							   dp);
		if (r != EFI_SUCCESS) {
			efi_st_error("Uninstall device path failed\n");
			return EFI_ST_FAILURE;
		}
		r = boottime->uninstall_protocol_interface(
				disk_handle, &block_io_protocol_guid,
				&block_io);
		if (r != EFI_SUCCESS) {
			efi_st_error(
				"Failed to uninstall block I/O protocol\n");
			return EFI_ST_FAILURE;
		}
	}

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

/*
 * Get length of device path without end tag.
 *
 * @dp		device path
 * Return:	length of device path in bytes
 */
static efi_uintn_t dp_size(struct efi_device_path *dp)
{
	struct efi_device_path *pos = dp;

	while (pos->type != DEVICE_PATH_TYPE_END)
		pos = (struct efi_device_path *)((char *)pos + pos->length);
	return (char *)pos - (char *)dp;
}

/*
 * Execute unit test.
 *
 * Return:	EFI_ST_SUCCESS for success
 */
static int execute(void)
{
	efi_status_t ret;
	efi_uintn_t no_handles, i, len;
	efi_handle_t *handles;
	efi_handle_t handle_partition = NULL;
	struct efi_device_path *dp_partition;
	struct efi_block_io *block_io_protocol;
	struct efi_simple_file_system_protocol *file_system;
	struct efi_file_handle *root, *file;
	struct {
		struct efi_file_system_info info;
		u16 label[12];
	} system_info;
	efi_uintn_t buf_size;
	char buf[16] __aligned(ARCH_DMA_MINALIGN);
	u32 part1_size;
	u64 pos;
	char block_io_aligned[1 << LB_BLOCK_SIZE] __aligned(1 << LB_BLOCK_SIZE);

	/* Connect controller to virtual disk */
	ret = boottime->connect_controller(disk_handle, NULL, NULL, 1);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Failed to connect controller\n");
		return EFI_ST_FAILURE;
	}

	/* Get the handle for the partition */
	ret = boottime->locate_handle_buffer(
				BY_PROTOCOL, &guid_device_path, NULL,
				&no_handles, &handles);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Failed to locate handles\n");
		return EFI_ST_FAILURE;
	}
	len = dp_size(dp);
	for (i = 0; i < no_handles; ++i) {
		ret = boottime->open_protocol(handles[i], &guid_device_path,
					      (void **)&dp_partition,
					      NULL, NULL,
					      EFI_OPEN_PROTOCOL_GET_PROTOCOL);
		if (ret != EFI_SUCCESS) {
			efi_st_error("Failed to open device path protocol\n");
			return EFI_ST_FAILURE;
		}
		if (len >= dp_size(dp_partition))
			continue;
		if (memcmp(dp, dp_partition, len))
			continue;
		handle_partition = handles[i];
		break;
	}
	ret = boottime->free_pool(handles);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Failed to free pool memory\n");
		return EFI_ST_FAILURE;
	}
	if (!handle_partition) {
		efi_st_error("Partition handle not found\n");
		return EFI_ST_FAILURE;
	}

	/* Open the block_io_protocol */
	ret = boottime->open_protocol(handle_partition,
				      &block_io_protocol_guid,
				      (void **)&block_io_protocol, NULL, NULL,
				      EFI_OPEN_PROTOCOL_GET_PROTOCOL);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Failed to open block IO protocol\n");
		return EFI_ST_FAILURE;
	}
	/* Get size of first MBR partition */
	memcpy(&part1_size, image + 0x1ca, sizeof(u32));
	if (block_io_protocol->media->last_block != part1_size - 1) {
		efi_st_error("Last LBA of partition %x, expected %x\n",
			     (unsigned int)block_io_protocol->media->last_block,
			     part1_size - 1);
		return EFI_ST_FAILURE;
	}
	/* Open the simple file system protocol */
	ret = boottime->open_protocol(handle_partition,
				      &guid_simple_file_system_protocol,
				      (void **)&file_system, NULL, NULL,
				      EFI_OPEN_PROTOCOL_GET_PROTOCOL);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Failed to open simple file system protocol\n");
		return EFI_ST_FAILURE;
	}

	/* Open volume */
	ret = file_system->open_volume(file_system, &root);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Failed to open volume\n");
		return EFI_ST_FAILURE;
	}
	buf_size = sizeof(system_info);
	ret = root->getinfo(root, &guid_file_system_info, &buf_size,
			    &system_info);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Failed to get file system info\n");
		return EFI_ST_FAILURE;
	}
	if (system_info.info.block_size != 512) {
		efi_st_error("Wrong block size %u, expected 512\n",
			     system_info.info.block_size);
		return EFI_ST_FAILURE;
	}
	if (efi_st_strcmp_16_8(system_info.info.volume_label, "U-BOOT TEST")) {
		efi_st_todo(
			"Wrong volume label '%ps', expected 'U-BOOT TEST'\n",
			system_info.info.volume_label);
	}

	/* Read file */
	ret = root->open(root, &file, u"hello.txt", EFI_FILE_MODE_READ,
			 0);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Failed to open file\n");
		return EFI_ST_FAILURE;
	}
	ret = file->setpos(file, 1);
	if (ret != EFI_SUCCESS) {
		efi_st_error("SetPosition failed\n");
		return EFI_ST_FAILURE;
	}
	buf_size = sizeof(buf) - 1;
	ret = file->read(file, &buf_size, buf);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Failed to read file\n");
		return EFI_ST_FAILURE;
	}
	if (buf_size != 12) {
		efi_st_error("Wrong number of bytes read: %u\n",
			     (unsigned int)buf_size);
		return EFI_ST_FAILURE;
	}
	if (memcmp(buf, "ello world!", 11)) {
		efi_st_error("Unexpected file content\n");
		return EFI_ST_FAILURE;
	}
	ret = file->getpos(file, &pos);
	if (ret != EFI_SUCCESS) {
		efi_st_error("GetPosition failed\n");
		return EFI_ST_FAILURE;
	}
	if (pos != 13) {
		efi_st_error("GetPosition returned %u, expected 13\n",
			     (unsigned int)pos);
		return EFI_ST_FAILURE;
	}
	ret = file->close(file);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Failed to close file\n");
		return EFI_ST_FAILURE;
	}

	/*
	 * Test that read_blocks() can read same file data.
	 *
	 * In the test data, the partition starts at block 1 and the file
	 * hello.txt with the content 'Hello world!' is located at 0x5000
	 * of the disk. Here we read block 0x27 (offset 0x4e00 of the
	 * partition) and expect the string 'Hello world!' to be at the
	 * start of block.
	 */
	ret = block_io_protocol->read_blocks(block_io_protocol,
				      block_io_protocol->media->media_id,
				      (0x5000 >> LB_BLOCK_SIZE) - 1,
				      block_io_protocol->media->block_size,
				      block_io_aligned);
	if (ret != EFI_SUCCESS) {
		efi_st_error("ReadBlocks failed\n");
		return EFI_ST_FAILURE;
	}

	if (memcmp(block_io_aligned + 1, buf, 11)) {
		efi_st_error("Unexpected block content\n");
		return EFI_ST_FAILURE;
	}

#ifdef CONFIG_FAT_WRITE
	/* Write file */
	ret = root->open(root, &file, u"u-boot.txt", EFI_FILE_MODE_READ |
			 EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE, 0);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Failed to open file\n");
		return EFI_ST_FAILURE;
	}
	buf_size = 7;
	boottime->set_mem(buf, sizeof(buf), 0);
	boottime->copy_mem(buf, "U-Boot", buf_size);
	ret = file->write(file, &buf_size, buf);
	if (ret != EFI_SUCCESS || buf_size != 7) {
		efi_st_error("Failed to write file\n");
		return EFI_ST_FAILURE;
	}
	ret = file->getpos(file, &pos);
	if (ret != EFI_SUCCESS) {
		efi_st_error("GetPosition failed\n");
		return EFI_ST_FAILURE;
	}
	if (pos != 7) {
		efi_st_error("GetPosition returned %u, expected 7\n",
			     (unsigned int)pos);
		return EFI_ST_FAILURE;
	}
	ret = file->close(file);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Failed to close file\n");
		return EFI_ST_FAILURE;
	}

	/* Verify file */
	boottime->set_mem(buf, sizeof(buf), 0);
	ret = root->open(root, &file, u"u-boot.txt", EFI_FILE_MODE_READ,
			 0);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Failed to open file\n");
		return EFI_ST_FAILURE;
	}
	buf_size = sizeof(buf) - 1;
	ret = file->read(file, &buf_size, buf);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Failed to read file\n");
		return EFI_ST_FAILURE;
	}
	if (buf_size != 7) {
		efi_st_error("Wrong number of bytes read: %u\n",
			     (unsigned int)buf_size);
		return EFI_ST_FAILURE;
	}
	if (memcmp(buf, "U-Boot", 7)) {
		efi_st_error("Unexpected file content %s\n", buf);
		return EFI_ST_FAILURE;
	}
	ret = file->close(file);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Failed to close file\n");
		return EFI_ST_FAILURE;
	}
#else
	efi_st_todo("CONFIG_FAT_WRITE is not set\n");
#endif /* CONFIG_FAT_WRITE */

	/* Close volume */
	ret = root->close(root);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Failed to close volume\n");
		return EFI_ST_FAILURE;
	}

	return EFI_ST_SUCCESS;
}

EFI_UNIT_TEST(blkdev) = {
	.name = "block device",
	.phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
	.setup = setup,
	.execute = execute,
	.teardown = teardown,
};
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
f7686192 HS	2	/*
	3	* efi_selftest_block
	4	*
	5	* Copyright (c) 2017 Heinrich Schuchardt <[email protected]>
	6	*
f7686192 HS	7	* This test checks the driver for block IO devices.
	8	* A disk image is created in memory.
	9	* A handle is created for the new block IO device.
	10	* The block I/O protocol is installed on the handle.
	11	* ConnectController is used to setup partitions and to install the simple
	12	* file protocol.
	13	* A known file is read from the file system and verified.
7a85f324 PB	14	* The same block is read via the EFI_BLOCK_IO_PROTOCOL and compared to the file
7a85f324 PB	15	* contents.
f7686192 HS	16	*/
	17
	18	#include <efi_selftest.h>
	19	#include "efi_selftest_disk_image.h"
90526e9f	20	#include <asm/cache.h>
f7686192 HS	21
	22	/* Block size of compressed disk image */
	23	#define COMPRESSED_DISK_IMAGE_BLOCK_SIZE 8
	24
	25	/* Binary logarithm of the block size */
	26	#define LB_BLOCK_SIZE 9
	27
	28	static struct efi_boot_services *boottime;
	29
dec88e41 HS	30	static const efi_guid_t block_io_protocol_guid = EFI_BLOCK_IO_PROTOCOL_GUID;
dec88e41 HS	31	static const efi_guid_t guid_device_path = EFI_DEVICE_PATH_PROTOCOL_GUID;
f7686192 HS	32	static const efi_guid_t guid_simple_file_system_protocol =
f7686192 HS	33	EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID;
1348c17a	34	static const efi_guid_t guid_file_system_info = EFI_FILE_SYSTEM_INFO_GUID;
f7686192 HS	35	static efi_guid_t guid_vendor =
	36	EFI_GUID(0xdbca4c98, 0x6cb0, 0x694d,
	37	0x08, 0x72, 0x81, 0x9c, 0x65, 0x0c, 0xb7, 0xb8);
	38
	39	static struct efi_device_path *dp;
	40
	41	/* One 8 byte block of the compressed disk image */
	42	struct line {
	43	size_t addr;
	44	char *line;
	45	};
	46
	47	/* Compressed disk image */
	48	struct compressed_disk_image {
	49	size_t length;
	50	struct line lines[];
	51	};
	52
	53	static const struct compressed_disk_image img = EFI_ST_DISK_IMG;
	54
	55	/* Decompressed disk image */
	56	static u8 *image;
	57
	58	/*
	59	* Reset service of the block IO protocol.
	60	*
	61	* @this block IO protocol
185f812c	62	* Return: status code
f7686192 HS	63	*/
	64	static efi_status_t EFIAPI reset(
	65	struct efi_block_io *this,
	66	char extended_verification)
	67	{
	68	return EFI_SUCCESS;
	69	}
	70
	71	/*
	72	* Read service of the block IO protocol.
	73	*
	74	* @this block IO protocol
	75	* @media_id media id
	76	* @lba start of the read in logical blocks
	77	* @buffer_size number of bytes to read
	78	* @buffer target buffer
185f812c	79	* Return: status code
f7686192 HS	80	*/
	81	static efi_status_t EFIAPI read_blocks(
	82	struct efi_block_io *this, u32 media_id, u64 lba,
	83	efi_uintn_t buffer_size, void *buffer)
	84	{
	85	u8 *start;
	86
	87	if ((lba << LB_BLOCK_SIZE) + buffer_size > img.length)
	88	return EFI_INVALID_PARAMETER;
	89	start = image + (lba << LB_BLOCK_SIZE);
	90
	91	boottime->copy_mem(buffer, start, buffer_size);
	92
	93	return EFI_SUCCESS;
	94	}
	95
	96	/*
	97	* Write service of the block IO protocol.
	98	*
	99	* @this block IO protocol
	100	* @media_id media id
	101	* @lba start of the write in logical blocks
	102	* @buffer_size number of bytes to read
	103	* @buffer source buffer
185f812c	104	* Return: status code
f7686192 HS	105	*/
	106	static efi_status_t EFIAPI write_blocks(
	107	struct efi_block_io *this, u32 media_id, u64 lba,
	108	efi_uintn_t buffer_size, void *buffer)
	109	{
	110	u8 *start;
	111
	112	if ((lba << LB_BLOCK_SIZE) + buffer_size > img.length)
	113	return EFI_INVALID_PARAMETER;
	114	start = image + (lba << LB_BLOCK_SIZE);
	115
	116	boottime->copy_mem(start, buffer, buffer_size);
	117
	118	return EFI_SUCCESS;
	119	}
	120
	121	/*
	122	* Flush service of the block IO protocol.
	123	*
	124	* @this block IO protocol
185f812c	125	* Return: status code
f7686192 HS	126	*/
	127	static efi_status_t EFIAPI flush_blocks(struct efi_block_io *this)
	128	{
	129	return EFI_SUCCESS;
	130	}
	131
	132	/*
	133	* Decompress the disk image.
	134	*
	135	* @image decompressed disk image
185f812c	136	* Return: status code
f7686192 HS	137	*/
	138	static efi_status_t decompress(u8 **image)
	139	{
	140	u8 *buf;
	141	size_t i;
	142	size_t addr;
	143	size_t len;
	144	efi_status_t ret;
	145
	146	ret = boottime->allocate_pool(EFI_LOADER_DATA, img.length,
	147	(void **)&buf);
	148	if (ret != EFI_SUCCESS) {
	149	efi_st_error("Out of memory\n");
	150	return ret;
	151	}
	152	boottime->set_mem(buf, img.length, 0);
	153
	154	for (i = 0; ; ++i) {
	155	if (!img.lines[i].line)
	156	break;
	157	addr = img.lines[i].addr;
	158	len = COMPRESSED_DISK_IMAGE_BLOCK_SIZE;
	159	if (addr + len > img.length)
	160	len = img.length - addr;
	161	boottime->copy_mem(buf + addr, img.lines[i].line, len);
	162	}
	163	*image = buf;
	164	return ret;
	165	}
	166
	167	static struct efi_block_io_media media;
	168
	169	static struct efi_block_io block_io = {
	170	.media = &media,
	171	.reset = reset,
	172	.read_blocks = read_blocks,
	173	.write_blocks = write_blocks,
	174	.flush_blocks = flush_blocks,
	175	};
	176
	177	/* Handle for the block IO device */
	178	static efi_handle_t disk_handle;
	179
	180	/*
	181	* Setup unit test.
	182	*
	183	* @handle: handle of the loaded image
	184	* @systable: system table
3dd719d4	185	* Return: EFI_ST_SUCCESS for success
f7686192 HS	186	*/
	187	static int setup(const efi_handle_t handle,
	188	const struct efi_system_table *systable)
	189	{
	190	efi_status_t ret;
	191	struct efi_device_path_vendor vendor_node;
	192	struct efi_device_path end_node;
	193
	194	boottime = systable->boottime;
	195
	196	decompress(&image);
	197
	198	block_io.media->block_size = 1 << LB_BLOCK_SIZE;
74a614d7	199	block_io.media->last_block = (img.length >> LB_BLOCK_SIZE) - 1;
f7686192 HS	200
	201	ret = boottime->install_protocol_interface(
	202	&disk_handle, &block_io_protocol_guid,
	203	EFI_NATIVE_INTERFACE, &block_io);
	204	if (ret != EFI_SUCCESS) {
	205	efi_st_error("Failed to install block I/O protocol\n");
	206	return EFI_ST_FAILURE;
	207	}
	208
	209	ret = boottime->allocate_pool(EFI_LOADER_DATA,
	210	sizeof(struct efi_device_path_vendor) +
	211	sizeof(struct efi_device_path),
	212	(void **)&dp);
	213	if (ret != EFI_SUCCESS) {
	214	efi_st_error("Out of memory\n");
	215	return EFI_ST_FAILURE;
	216	}
	217	vendor_node.dp.type = DEVICE_PATH_TYPE_HARDWARE_DEVICE;
	218	vendor_node.dp.sub_type = DEVICE_PATH_SUB_TYPE_VENDOR;
	219	vendor_node.dp.length = sizeof(struct efi_device_path_vendor);
	220
	221	boottime->copy_mem(&vendor_node.guid, &guid_vendor,
	222	sizeof(efi_guid_t));
	223	boottime->copy_mem(dp, &vendor_node,
	224	sizeof(struct efi_device_path_vendor));
	225	end_node.type = DEVICE_PATH_TYPE_END;
	226	end_node.sub_type = DEVICE_PATH_SUB_TYPE_END;
	227	end_node.length = sizeof(struct efi_device_path);
	228
	229	boottime->copy_mem((char *)dp + sizeof(struct efi_device_path_vendor),
	230	&end_node, sizeof(struct efi_device_path));
	231	ret = boottime->install_protocol_interface(&disk_handle,
	232	&guid_device_path,
	233	EFI_NATIVE_INTERFACE,
	234	dp);
	235	if (ret != EFI_SUCCESS) {
	236	efi_st_error("InstallProtocolInterface failed\n");
	237	return EFI_ST_FAILURE;
	238	}
	239	return EFI_ST_SUCCESS;
	240	}
	241
	242	/*
	243	* Tear down unit test.
	244	*
3dd719d4	245	* Return: EFI_ST_SUCCESS for success
f7686192 HS	246	*/
	247	static int teardown(void)
	248	{
	249	efi_status_t r = EFI_ST_SUCCESS;
	250
	251	if (disk_handle) {
	252	r = boottime->uninstall_protocol_interface(disk_handle,
	253	&guid_device_path,
	254	dp);
	255	if (r != EFI_SUCCESS) {
	256	efi_st_error("Uninstall device path failed\n");
	257	return EFI_ST_FAILURE;
	258	}
	259	r = boottime->uninstall_protocol_interface(
	260	disk_handle, &block_io_protocol_guid,
	261	&block_io);
	262	if (r != EFI_SUCCESS) {
d7431042	263	efi_st_error(
f7686192	264	"Failed to uninstall block I/O protocol\n");
d7431042	265	return EFI_ST_FAILURE;
f7686192 HS	266	}
	267	}
	268
	269	if (image) {
afa17aa2	270	r = boottime->free_pool(image);
f7686192 HS	271	if (r != EFI_SUCCESS) {
	272	efi_st_error("Failed to free image\n");
	273	return EFI_ST_FAILURE;
	274	}
	275	}
	276	return r;
	277	}
	278
	279	/*
	280	* Get length of device path without end tag.
	281	*
	282	* @dp device path
185f812c	283	* Return: length of device path in bytes
f7686192 HS	284	*/
	285	static efi_uintn_t dp_size(struct efi_device_path *dp)
	286	{
	287	struct efi_device_path *pos = dp;
	288
	289	while (pos->type != DEVICE_PATH_TYPE_END)
	290	pos = (struct efi_device_path )((char )pos + pos->length);
	291	return (char )pos - (char )dp;
	292	}
	293
	294	/*
	295	* Execute unit test.
	296	*
3dd719d4	297	* Return: EFI_ST_SUCCESS for success
f7686192 HS	298	*/
	299	static int execute(void)
	300	{
	301	efi_status_t ret;
	302	efi_uintn_t no_handles, i, len;
	303	efi_handle_t *handles;
	304	efi_handle_t handle_partition = NULL;
	305	struct efi_device_path *dp_partition;
74a614d7	306	struct efi_block_io *block_io_protocol;
f7686192 HS	307	struct efi_simple_file_system_protocol *file_system;
f7686192 HS	308	struct efi_file_handle root, file;
1348c17a HS	309	struct {
	310	struct efi_file_system_info info;
	311	u16 label[12];
	312	} system_info;
b6dd5777	313	efi_uintn_t buf_size;
f7686192	314	char buf[16] __aligned(ARCH_DMA_MINALIGN);
74a614d7	315	u32 part1_size;
0801d4d2	316	u64 pos;
7a85f324	317	char block_io_aligned[1 << LB_BLOCK_SIZE] __aligned(1 << LB_BLOCK_SIZE);
f7686192	318
1bfb1579	319	/* Connect controller to virtual disk */
f7686192 HS	320	ret = boottime->connect_controller(disk_handle, NULL, NULL, 1);
	321	if (ret != EFI_SUCCESS) {
	322	efi_st_error("Failed to connect controller\n");
	323	return EFI_ST_FAILURE;
	324	}
1bfb1579 HS	325
1bfb1579 HS	326	/* Get the handle for the partition */
f7686192 HS	327	ret = boottime->locate_handle_buffer(
	328	BY_PROTOCOL, &guid_device_path, NULL,
	329	&no_handles, &handles);
	330	if (ret != EFI_SUCCESS) {
	331	efi_st_error("Failed to locate handles\n");
	332	return EFI_ST_FAILURE;
	333	}
	334	len = dp_size(dp);
	335	for (i = 0; i < no_handles; ++i) {
	336	ret = boottime->open_protocol(handles[i], &guid_device_path,
	337	(void **)&dp_partition,
	338	NULL, NULL,
	339	EFI_OPEN_PROTOCOL_GET_PROTOCOL);
	340	if (ret != EFI_SUCCESS) {
	341	efi_st_error("Failed to open device path protocol\n");
	342	return EFI_ST_FAILURE;
	343	}
	344	if (len >= dp_size(dp_partition))
	345	continue;
8101dd3d	346	if (memcmp(dp, dp_partition, len))
f7686192 HS	347	continue;
	348	handle_partition = handles[i];
	349	break;
	350	}
	351	ret = boottime->free_pool(handles);
	352	if (ret != EFI_SUCCESS) {
	353	efi_st_error("Failed to free pool memory\n");
	354	return EFI_ST_FAILURE;
	355	}
	356	if (!handle_partition) {
	357	efi_st_error("Partition handle not found\n");
	358	return EFI_ST_FAILURE;
	359	}
1bfb1579	360
74a614d7 HS	361	/* Open the block_io_protocol */
	362	ret = boottime->open_protocol(handle_partition,
	363	&block_io_protocol_guid,
	364	(void **)&block_io_protocol, NULL, NULL,
	365	EFI_OPEN_PROTOCOL_GET_PROTOCOL);
	366	if (ret != EFI_SUCCESS) {
	367	efi_st_error("Failed to open block IO protocol\n");
	368	return EFI_ST_FAILURE;
	369	}
	370	/* Get size of first MBR partition */
	371	memcpy(&part1_size, image + 0x1ca, sizeof(u32));
	372	if (block_io_protocol->media->last_block != part1_size - 1) {
	373	efi_st_error("Last LBA of partition %x, expected %x\n",
	374	(unsigned int)block_io_protocol->media->last_block,
	375	part1_size - 1);
	376	return EFI_ST_FAILURE;
	377	}
1bfb1579	378	/* Open the simple file system protocol */
f7686192 HS	379	ret = boottime->open_protocol(handle_partition,
	380	&guid_simple_file_system_protocol,
	381	(void **)&file_system, NULL, NULL,
	382	EFI_OPEN_PROTOCOL_GET_PROTOCOL);
	383	if (ret != EFI_SUCCESS) {
	384	efi_st_error("Failed to open simple file system protocol\n");
	385	return EFI_ST_FAILURE;
	386	}
1bfb1579 HS	387
1bfb1579 HS	388	/* Open volume */
f7686192 HS	389	ret = file_system->open_volume(file_system, &root);
	390	if (ret != EFI_SUCCESS) {
	391	efi_st_error("Failed to open volume\n");
	392	return EFI_ST_FAILURE;
	393	}
1348c17a HS	394	buf_size = sizeof(system_info);
	395	ret = root->getinfo(root, &guid_file_system_info, &buf_size,
	396	&system_info);
	397	if (ret != EFI_SUCCESS) {
	398	efi_st_error("Failed to get file system info\n");
	399	return EFI_ST_FAILURE;
	400	}
	401	if (system_info.info.block_size != 512) {
	402	efi_st_error("Wrong block size %u, expected 512\n",
	403	system_info.info.block_size);
	404	return EFI_ST_FAILURE;
	405	}
	406	if (efi_st_strcmp_16_8(system_info.info.volume_label, "U-BOOT TEST")) {
	407	efi_st_todo(
	408	"Wrong volume label '%ps', expected 'U-BOOT TEST'\n",
	409	system_info.info.volume_label);
	410	}
1bfb1579 HS	411
1bfb1579 HS	412	/* Read file */
156ccbc3	413	ret = root->open(root, &file, u"hello.txt", EFI_FILE_MODE_READ,
f7686192 HS	414	0);
	415	if (ret != EFI_SUCCESS) {
	416	efi_st_error("Failed to open file\n");
	417	return EFI_ST_FAILURE;
	418	}
0801d4d2 HS	419	ret = file->setpos(file, 1);
	420	if (ret != EFI_SUCCESS) {
	421	efi_st_error("SetPosition failed\n");
	422	return EFI_ST_FAILURE;
	423	}
f7686192 HS	424	buf_size = sizeof(buf) - 1;
	425	ret = file->read(file, &buf_size, buf);
	426	if (ret != EFI_SUCCESS) {
	427	efi_st_error("Failed to read file\n");
	428	return EFI_ST_FAILURE;
	429	}
0801d4d2	430	if (buf_size != 12) {
1bfb1579 HS	431	efi_st_error("Wrong number of bytes read: %u\n",
	432	(unsigned int)buf_size);
	433	return EFI_ST_FAILURE;
	434	}
8101dd3d	435	if (memcmp(buf, "ello world!", 11)) {
f7686192 HS	436	efi_st_error("Unexpected file content\n");
	437	return EFI_ST_FAILURE;
	438	}
0801d4d2 HS	439	ret = file->getpos(file, &pos);
	440	if (ret != EFI_SUCCESS) {
	441	efi_st_error("GetPosition failed\n");
	442	return EFI_ST_FAILURE;
	443	}
	444	if (pos != 13) {
	445	efi_st_error("GetPosition returned %u, expected 13\n",
	446	(unsigned int)pos);
	447	return EFI_ST_FAILURE;
	448	}
f7686192 HS	449	ret = file->close(file);
	450	if (ret != EFI_SUCCESS) {
	451	efi_st_error("Failed to close file\n");
	452	return EFI_ST_FAILURE;
	453	}
1bfb1579	454
7a85f324 PB	455	/*
	456	* Test that read_blocks() can read same file data.
	457	*
	458	* In the test data, the partition starts at block 1 and the file
	459	* hello.txt with the content 'Hello world!' is located at 0x5000
	460	* of the disk. Here we read block 0x27 (offset 0x4e00 of the
	461	* partition) and expect the string 'Hello world!' to be at the
	462	* start of block.
	463	*/
	464	ret = block_io_protocol->read_blocks(block_io_protocol,
	465	block_io_protocol->media->media_id,
	466	(0x5000 >> LB_BLOCK_SIZE) - 1,
	467	block_io_protocol->media->block_size,
	468	block_io_aligned);
	469	if (ret != EFI_SUCCESS) {
	470	efi_st_error("ReadBlocks failed\n");
	471	return EFI_ST_FAILURE;
	472	}
	473
	474	if (memcmp(block_io_aligned + 1, buf, 11)) {
	475	efi_st_error("Unexpected block content\n");
	476	return EFI_ST_FAILURE;
	477	}
	478
1bfb1579 HS	479	#ifdef CONFIG_FAT_WRITE
1bfb1579 HS	480	/* Write file */
156ccbc3	481	ret = root->open(root, &file, u"u-boot.txt", EFI_FILE_MODE_READ \|
1bfb1579 HS	482	EFI_FILE_MODE_WRITE \| EFI_FILE_MODE_CREATE, 0);
	483	if (ret != EFI_SUCCESS) {
	484	efi_st_error("Failed to open file\n");
	485	return EFI_ST_FAILURE;
	486	}
	487	buf_size = 7;
	488	boottime->set_mem(buf, sizeof(buf), 0);
	489	boottime->copy_mem(buf, "U-Boot", buf_size);
	490	ret = file->write(file, &buf_size, buf);
	491	if (ret != EFI_SUCCESS \|\| buf_size != 7) {
	492	efi_st_error("Failed to write file\n");
	493	return EFI_ST_FAILURE;
	494	}
0801d4d2 HS	495	ret = file->getpos(file, &pos);
	496	if (ret != EFI_SUCCESS) {
	497	efi_st_error("GetPosition failed\n");
	498	return EFI_ST_FAILURE;
	499	}
	500	if (pos != 7) {
	501	efi_st_error("GetPosition returned %u, expected 7\n",
	502	(unsigned int)pos);
	503	return EFI_ST_FAILURE;
	504	}
05aceb2b HS	505	ret = file->close(file);
	506	if (ret != EFI_SUCCESS) {
	507	efi_st_error("Failed to close file\n");
	508	return EFI_ST_FAILURE;
	509	}
1bfb1579 HS	510
	511	/* Verify file */
	512	boottime->set_mem(buf, sizeof(buf), 0);
156ccbc3	513	ret = root->open(root, &file, u"u-boot.txt", EFI_FILE_MODE_READ,
1bfb1579 HS	514	0);
	515	if (ret != EFI_SUCCESS) {
	516	efi_st_error("Failed to open file\n");
	517	return EFI_ST_FAILURE;
	518	}
	519	buf_size = sizeof(buf) - 1;
	520	ret = file->read(file, &buf_size, buf);
	521	if (ret != EFI_SUCCESS) {
	522	efi_st_error("Failed to read file\n");
	523	return EFI_ST_FAILURE;
	524	}
	525	if (buf_size != 7) {
	526	efi_st_error("Wrong number of bytes read: %u\n",
	527	(unsigned int)buf_size);
	528	return EFI_ST_FAILURE;
	529	}
8101dd3d	530	if (memcmp(buf, "U-Boot", 7)) {
1bfb1579 HS	531	efi_st_error("Unexpected file content %s\n", buf);
	532	return EFI_ST_FAILURE;
	533	}
	534	ret = file->close(file);
	535	if (ret != EFI_SUCCESS) {
	536	efi_st_error("Failed to close file\n");
	537	return EFI_ST_FAILURE;
	538	}
	539	#else
	540	efi_st_todo("CONFIG_FAT_WRITE is not set\n");
	541	#endif /* CONFIG_FAT_WRITE */
	542
	543	/* Close volume */
f7686192 HS	544	ret = root->close(root);
	545	if (ret != EFI_SUCCESS) {
	546	efi_st_error("Failed to close volume\n");
	547	return EFI_ST_FAILURE;
	548	}
	549
	550	return EFI_ST_SUCCESS;
	551	}
	552
	553	EFI_UNIT_TEST(blkdev) = {
	554	.name = "block device",
	555	.phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
	556	.setup = setup,
	557	.execute = execute,
	558	.teardown = teardown,
	559	};