Commit 9697d84f authored by Jin Yu's avatar Jin Yu Committed by Tomasz Zawadzki
Browse files

test: add unit test for split IO 



This unit test is for MAX_SIZE and MAX_SEGS
splitting IO.

Change-Id: I47278a9213986d8aa0e6db041b2795e595558498
Signed-off-by: default avatarJin Yu <jin.yu@intel.com>
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/4820


Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: default avatarChangpeng Liu <changpeng.liu@intel.com>
Reviewed-by: default avatarShuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
Community-CI: Mellanox Build Bot
parent 3b616c0f

test/unit/lib/bdev/bdev.c/bdev_ut.c

+549 −2
Original line number Diff line number Diff line
@@ -1076,7 +1076,7 @@ bdev_io_spans_split_test(void) 
}



static void

bdev_io_split_test(void)

bdev_io_boundary_split_test(void)

{

	struct spdk_bdev *bdev;

	struct spdk_bdev_desc *desc = NULL;
@@ -1715,6 +1715,552 @@ bdev_io_split_test(void) 
	poll_threads();

}



static void

bdev_io_max_size_and_segment_split_test(void)

{

	struct spdk_bdev *bdev;

	struct spdk_bdev_desc *desc = NULL;

	struct spdk_io_channel *io_ch;

	struct spdk_bdev_opts bdev_opts = {

		.bdev_io_pool_size = 512,

		.bdev_io_cache_size = 64,

	};

	struct iovec iov[BDEV_IO_NUM_CHILD_IOV * 2];

	struct ut_expected_io *expected_io;

	uint64_t i;

	int rc;



	rc = spdk_bdev_set_opts(&bdev_opts);

	CU_ASSERT(rc == 0);

	spdk_bdev_initialize(bdev_init_cb, NULL);



	bdev = allocate_bdev("bdev0");



	rc = spdk_bdev_open_ext(bdev->name, true, bdev_ut_event_cb, NULL, &desc);

	CU_ASSERT(rc == 0);

	SPDK_CU_ASSERT_FATAL(desc != NULL);

	io_ch = spdk_bdev_get_io_channel(desc);

	CU_ASSERT(io_ch != NULL);



	bdev->split_on_optimal_io_boundary = false;

	bdev->optimal_io_boundary = 0;



	/* Case 0 max_num_segments == 0.

	 * but segment size 2 * 512 > 512

	 */

	bdev->max_segment_size = 512;

	bdev->max_num_segments = 0;

	g_io_done = false;



	expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, 14, 2, 2);

	ut_expected_io_set_iov(expected_io, 0, (void *)0xF000, 512);

	ut_expected_io_set_iov(expected_io, 1, (void *)(0xF000 + 512), 512);

	TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



	rc = spdk_bdev_read_blocks(desc, io_ch, (void *)0xF000, 14, 2, io_done, NULL);

	CU_ASSERT(rc == 0);

	CU_ASSERT(g_io_done == false);



	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == 1);

	stub_complete_io(1);

	CU_ASSERT(g_io_done == true);

	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == 0);



	/* Case 1 max_segment_size == 0

	 * but iov num 2 > 1.

	 */

	bdev->max_segment_size = 0;

	bdev->max_num_segments = 1;

	g_io_done = false;



	iov[0].iov_base = (void *)0x10000;

	iov[0].iov_len = 512;

	iov[1].iov_base = (void *)0x20000;

	iov[1].iov_len = 8 * 512;



	expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, 14, 1, 1);

	ut_expected_io_set_iov(expected_io, 0, iov[0].iov_base, iov[0].iov_len);

	TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



	expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, 15, 8, 1);

	ut_expected_io_set_iov(expected_io, 0, iov[1].iov_base, iov[1].iov_len);

	TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



	rc = spdk_bdev_readv_blocks(desc, io_ch, iov, 2, 14, 9, io_done, NULL);

	CU_ASSERT(rc == 0);

	CU_ASSERT(g_io_done == false);



	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == 2);

	stub_complete_io(2);

	CU_ASSERT(g_io_done == true);

	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == 0);



	/* Test that a non-vector command is split correctly.

	 * Set up the expected values before calling spdk_bdev_read_blocks

	 */

	bdev->max_segment_size = 512;

	bdev->max_num_segments = 1;

	g_io_done = false;



	/* Child IO 0 */

	expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, 14, 1, 1);

	ut_expected_io_set_iov(expected_io, 0, (void *)0xF000, 512);

	TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



	/* Child IO 1 */

	expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, 15, 1, 1);

	ut_expected_io_set_iov(expected_io, 0, (void *)(0xF000 + 1 * 512), 512);

	TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



	/* spdk_bdev_read_blocks will submit the first child immediately. */

	rc = spdk_bdev_read_blocks(desc, io_ch, (void *)0xF000, 14, 2, io_done, NULL);

	CU_ASSERT(rc == 0);

	CU_ASSERT(g_io_done == false);



	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == 2);

	stub_complete_io(2);

	CU_ASSERT(g_io_done == true);

	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == 0);



	/* Now set up a more complex, multi-vector command that needs to be split,

	 * including splitting iovecs.

	 */

	bdev->max_segment_size = 2 * 512;

	bdev->max_num_segments = 1;

	g_io_done = false;



	iov[0].iov_base = (void *)0x10000;

	iov[0].iov_len = 2 * 512;

	iov[1].iov_base = (void *)0x20000;

	iov[1].iov_len = 4 * 512;

	iov[2].iov_base = (void *)0x30000;

	iov[2].iov_len = 6 * 512;



	expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_WRITE, 14, 2, 1);

	ut_expected_io_set_iov(expected_io, 0, iov[0].iov_base, 512 * 2);

	TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



	/* Split iov[1].size to 2 iov entries then split the segments */

	expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_WRITE, 16, 2, 1);

	ut_expected_io_set_iov(expected_io, 0, iov[1].iov_base, 512 * 2);

	TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



	expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_WRITE, 18, 2, 1);

	ut_expected_io_set_iov(expected_io, 0, iov[1].iov_base + 512 * 2, 512 * 2);

	TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



	/* Split iov[2].size to 3 iov entries then split the segments */

	expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_WRITE, 20, 2, 1);

	ut_expected_io_set_iov(expected_io, 0, iov[2].iov_base, 512 * 2);

	TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



	expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_WRITE, 22, 2, 1);

	ut_expected_io_set_iov(expected_io, 0, iov[2].iov_base + 512 * 2, 512 * 2);

	TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



	expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_WRITE, 24, 2, 1);

	ut_expected_io_set_iov(expected_io, 0, iov[2].iov_base + 512 * 4, 512 * 2);

	TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



	rc = spdk_bdev_writev_blocks(desc, io_ch, iov, 3, 14, 12, io_done, NULL);

	CU_ASSERT(rc == 0);

	CU_ASSERT(g_io_done == false);



	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == 6);

	stub_complete_io(6);

	CU_ASSERT(g_io_done == true);

	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == 0);



	/* Test multi vector command that needs to be split by strip and then needs to be

	 * split further due to the capacity of parent IO child iovs.

	 */

	bdev->max_segment_size = 512;

	bdev->max_num_segments = 1;

	g_io_done = false;



	for (i = 0; i < BDEV_IO_NUM_CHILD_IOV; i++) {

		iov[i].iov_base = (void *)((i + 1) * 0x10000);

		iov[i].iov_len = 512 * 2;

	}



	/* Each input iov.size is split into 2 iovs,

	 * half of the input iov can fill all child iov entries of a single IO.

	 */

	for (i = 0; i < BDEV_IO_NUM_CHILD_IOV / 2; i++) {

		expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, 2 * i, 1, 1);

		ut_expected_io_set_iov(expected_io, 0, iov[i].iov_base, 512);

		TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



		expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, 2 * i + 1, 1, 1);

		ut_expected_io_set_iov(expected_io, 0, iov[i].iov_base + 512, 512);

		TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);

	}



	/* The remaining iov is split in the second round */

	for (i = BDEV_IO_NUM_CHILD_IOV / 2; i < BDEV_IO_NUM_CHILD_IOV; i++) {

		expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, i * 2, 1, 1);

		ut_expected_io_set_iov(expected_io, 0, iov[i].iov_base, 512);

		TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



		expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, i * 2 + 1, 1, 1);

		ut_expected_io_set_iov(expected_io, 0, iov[i].iov_base + 512, 512);

		TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);

	}



	rc = spdk_bdev_readv_blocks(desc, io_ch, iov, BDEV_IO_NUM_CHILD_IOV, 0,

				    BDEV_IO_NUM_CHILD_IOV * 2, io_done, NULL);

	CU_ASSERT(rc == 0);

	CU_ASSERT(g_io_done == false);



	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == BDEV_IO_NUM_CHILD_IOV);

	stub_complete_io(BDEV_IO_NUM_CHILD_IOV);

	CU_ASSERT(g_io_done == false);



	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == BDEV_IO_NUM_CHILD_IOV);

	stub_complete_io(BDEV_IO_NUM_CHILD_IOV);

	CU_ASSERT(g_io_done == true);

	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == 0);



	/* A wrong case, a child IO that is divided does

	 * not meet the principle of multiples of block size,

	 * and exits with error

	 */

	bdev->max_segment_size = 512;

	bdev->max_num_segments = 1;

	g_io_done = false;



	iov[0].iov_base = (void *)0x10000;

	iov[0].iov_len = 512 + 256;

	iov[1].iov_base = (void *)0x20000;

	iov[1].iov_len = 256;



	/* iov[0] is split to 512 and 256.

	 * 256 is less than a block size, and it is found

	 * in the next round of split that it is the first child IO smaller than

	 * the block size, so the error exit

	 */

	expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, 0, 1, 1);

	ut_expected_io_set_iov(expected_io, 0, iov[0].iov_base, 512);

	TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



	rc = spdk_bdev_readv_blocks(desc, io_ch, iov, 2, 0, 2, io_done, NULL);

	CU_ASSERT(rc == 0);

	CU_ASSERT(g_io_done == false);



	/* First child IO is OK */

	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == 1);

	stub_complete_io(1);

	CU_ASSERT(g_io_done == true);

	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == 0);



	/* error exit */

	stub_complete_io(1);

	CU_ASSERT(g_io_done == true);

	CU_ASSERT(g_io_status == SPDK_BDEV_IO_STATUS_FAILED);

	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == 0);



	/* Test multi vector command that needs to be split by strip and then needs to be

	 * split further due to the capacity of child iovs.

	 *

	 * In this case, the last two iovs need to be split, but it will exceed the capacity

	 * of child iovs, so it needs to wait until the first batch completed.

	 */

	bdev->max_segment_size = 512;

	bdev->max_num_segments = BDEV_IO_NUM_CHILD_IOV;

	g_io_done = false;



	for (i = 0; i < BDEV_IO_NUM_CHILD_IOV - 2; i++) {

		iov[i].iov_base = (void *)((i + 1) * 0x10000);

		iov[i].iov_len = 512;

	}

	for (i = BDEV_IO_NUM_CHILD_IOV - 2; i < BDEV_IO_NUM_CHILD_IOV; i++) {

		iov[i].iov_base = (void *)((i + 1) * 0x10000);

		iov[i].iov_len = 512 * 2;

	}



	expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, 0,

					   BDEV_IO_NUM_CHILD_IOV, BDEV_IO_NUM_CHILD_IOV);

	/* 0 ~ (BDEV_IO_NUM_CHILD_IOV - 2) Will not be split */

	for (i = 0; i < BDEV_IO_NUM_CHILD_IOV - 2; i++) {

		ut_expected_io_set_iov(expected_io, i, iov[i].iov_base, iov[i].iov_len);

	}

	/* (BDEV_IO_NUM_CHILD_IOV - 2) is split */

	ut_expected_io_set_iov(expected_io, i, iov[i].iov_base, 512);

	ut_expected_io_set_iov(expected_io, i + 1, iov[i].iov_base + 512, 512);

	TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



	/* Child iov entries exceed the max num of parent IO so split it in next round */

	expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, BDEV_IO_NUM_CHILD_IOV, 2, 2);

	ut_expected_io_set_iov(expected_io, 0, iov[i + 1].iov_base, 512);

	ut_expected_io_set_iov(expected_io, 1, iov[i + 1].iov_base + 512, 512);

	TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



	rc = spdk_bdev_readv_blocks(desc, io_ch, iov, BDEV_IO_NUM_CHILD_IOV, 0,

				    BDEV_IO_NUM_CHILD_IOV + 2, io_done, NULL);

	CU_ASSERT(rc == 0);

	CU_ASSERT(g_io_done == false);



	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == 1);

	stub_complete_io(1);

	CU_ASSERT(g_io_done == false);



	/* Next round */

	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == 1);

	stub_complete_io(1);

	CU_ASSERT(g_io_done == true);

	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == 0);



	/* This case is similar to the previous one, but the io composed of

	 * the last few entries of child iov is not enough for a blocklen, so they

	 * cannot be put into this IO, but wait until the next time.

	 */

	bdev->max_segment_size = 512;

	bdev->max_num_segments = BDEV_IO_NUM_CHILD_IOV;

	g_io_done = false;



	for (i = 0; i < BDEV_IO_NUM_CHILD_IOV - 2; i++) {

		iov[i].iov_base = (void *)((i + 1) * 0x10000);

		iov[i].iov_len = 512;

	}



	for (i = BDEV_IO_NUM_CHILD_IOV - 2; i < BDEV_IO_NUM_CHILD_IOV + 2; i++) {

		iov[i].iov_base = (void *)((i + 1) * 0x10000);

		iov[i].iov_len = 128;

	}



	/* First child iovcnt is't BDEV_IO_NUM_CHILD_IOV but BDEV_IO_NUM_CHILD_IOV - 2.

	 * Because the left 2 iov is not enough for a blocklen.

	 */

	expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, 0,

					   BDEV_IO_NUM_CHILD_IOV - 2, BDEV_IO_NUM_CHILD_IOV - 2);

	for (i = 0; i < BDEV_IO_NUM_CHILD_IOV - 2; i++) {

		ut_expected_io_set_iov(expected_io, i, iov[i].iov_base, iov[i].iov_len);

	}

	TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



	/* The second child io waits until the end of the first child io before executing.

	 * Because the iovcnt of the two IOs exceeds the child iovcnt of the parent IO.

	 * BDEV_IO_NUM_CHILD_IOV - 2 to BDEV_IO_NUM_CHILD_IOV + 2

	 */

	expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, BDEV_IO_NUM_CHILD_IOV - 2,

					   1, 4);

	ut_expected_io_set_iov(expected_io, 0, iov[i].iov_base, iov[i].iov_len);

	ut_expected_io_set_iov(expected_io, 1, iov[i + 1].iov_base, iov[i + 1].iov_len);

	ut_expected_io_set_iov(expected_io, 2, iov[i + 2].iov_base, iov[i + 2].iov_len);

	ut_expected_io_set_iov(expected_io, 3, iov[i + 3].iov_base, iov[i + 3].iov_len);

	TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



	rc = spdk_bdev_readv_blocks(desc, io_ch, iov, BDEV_IO_NUM_CHILD_IOV + 2, 0,

				    BDEV_IO_NUM_CHILD_IOV - 1, io_done, NULL);

	CU_ASSERT(rc == 0);

	CU_ASSERT(g_io_done == false);



	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == 1);

	stub_complete_io(1);

	CU_ASSERT(g_io_done == false);



	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == 1);

	stub_complete_io(1);

	CU_ASSERT(g_io_done == true);

	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == 0);



	/* A very complicated case. Each sg entry exceeds max_segment_size and

	 * needs to be split. At the same time, child io must be a multiple of blocklen.

	 * At the same time, child iovcnt exceeds parent iovcnt.

	 */

	bdev->max_segment_size = 512 + 128;

	bdev->max_num_segments = 3;

	g_io_done = false;



	for (i = 0; i < BDEV_IO_NUM_CHILD_IOV - 2; i++) {

		iov[i].iov_base = (void *)((i + 1) * 0x10000);

		iov[i].iov_len = 512 + 256;

	}



	for (i = BDEV_IO_NUM_CHILD_IOV - 2; i < BDEV_IO_NUM_CHILD_IOV + 2; i++) {

		iov[i].iov_base = (void *)((i + 1) * 0x10000);

		iov[i].iov_len = 512 + 128;

	}



	/* Child IOs use 9 entries per for() round and 3 * 9 = 27 child iov entries.

	 * Consume 4 parent IO iov entries per for() round and 6 block size.

	 * Generate 9 child IOs.

	 */

	for (i = 0; i < 3; i++) {

		uint32_t j = i * 4;

		expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, i * 6, 2, 3);

		ut_expected_io_set_iov(expected_io, 0, iov[j].iov_base, 640);

		ut_expected_io_set_iov(expected_io, 1, iov[j].iov_base + 640, 128);

		ut_expected_io_set_iov(expected_io, 2, iov[j + 1].iov_base, 256);

		TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



		/* Child io must be a multiple of blocklen

		 * iov[j + 2] must be split. If the third entry is also added,

		 * the multiple of blocklen cannot be guaranteed. But it still

		 * occupies one iov entry of the parent child iov.

		 */

		expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, i * 6 + 2, 2, 2);

		ut_expected_io_set_iov(expected_io, 0, iov[j + 1].iov_base + 256, 512);

		ut_expected_io_set_iov(expected_io, 1, iov[j + 2].iov_base, 512);

		TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



		expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, i * 6 + 4, 2, 3);

		ut_expected_io_set_iov(expected_io, 0, iov[j + 2].iov_base + 512, 256);

		ut_expected_io_set_iov(expected_io, 1, iov[j + 3].iov_base, 640);

		ut_expected_io_set_iov(expected_io, 2, iov[j + 3].iov_base + 640, 128);

		TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);

	}



	/* Child iov position at 27, the 10th child IO

	 * iov entry index is 3 * 4 and offset is 3 * 6

	 */

	expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, 18, 2, 3);

	ut_expected_io_set_iov(expected_io, 0, iov[12].iov_base, 640);

	ut_expected_io_set_iov(expected_io, 1, iov[12].iov_base + 640, 128);

	ut_expected_io_set_iov(expected_io, 2, iov[13].iov_base, 256);

	TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



	/* Child iov position at 30, the 11th child IO */

	expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, 20, 2, 2);

	ut_expected_io_set_iov(expected_io, 0, iov[13].iov_base + 256, 512);

	ut_expected_io_set_iov(expected_io, 1, iov[14].iov_base, 512);

	TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



	/* The 2nd split round and iovpos is 0, the 12th child IO */

	expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, 22, 2, 3);

	ut_expected_io_set_iov(expected_io, 0, iov[14].iov_base + 512, 256);

	ut_expected_io_set_iov(expected_io, 1, iov[15].iov_base, 640);

	ut_expected_io_set_iov(expected_io, 2, iov[15].iov_base + 640, 128);

	TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



	/* Consume 9 child IOs and 27 child iov entries.

	 * Consume 4 parent IO iov entries per for() round and 6 block size.

	 * Parent IO iov index start from 16 and block offset start from 24

	 */

	for (i = 0; i < 3; i++) {

		uint32_t j = i * 4 + 16;

		uint32_t offset = i * 6 + 24;

		expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, offset, 2, 3);

		ut_expected_io_set_iov(expected_io, 0, iov[j].iov_base, 640);

		ut_expected_io_set_iov(expected_io, 1, iov[j].iov_base + 640, 128);

		ut_expected_io_set_iov(expected_io, 2, iov[j + 1].iov_base, 256);

		TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



		/* Child io must be a multiple of blocklen

		 * iov[j + 2] must be split. If the third entry is also added,

		 * the multiple of blocklen cannot be guaranteed. But it still

		 * occupies one iov entry of the parent child iov.

		 */

		expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, offset + 2, 2, 2);

		ut_expected_io_set_iov(expected_io, 0, iov[j + 1].iov_base + 256, 512);

		ut_expected_io_set_iov(expected_io, 1, iov[j + 2].iov_base, 512);

		TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



		expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, offset + 4, 2, 3);

		ut_expected_io_set_iov(expected_io, 0, iov[j + 2].iov_base + 512, 256);

		ut_expected_io_set_iov(expected_io, 1, iov[j + 3].iov_base, 640);

		ut_expected_io_set_iov(expected_io, 2, iov[j + 3].iov_base + 640, 128);

		TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);

	}



	/* The 22th child IO, child iov position at 30 */

	expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, 42, 1, 1);

	ut_expected_io_set_iov(expected_io, 0, iov[28].iov_base, 512);

	TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



	/* The third round */

	/* Here is the 23nd child IO and child iovpos is 0 */

	expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, 43, 2, 3);

	ut_expected_io_set_iov(expected_io, 0, iov[28].iov_base + 512, 256);

	ut_expected_io_set_iov(expected_io, 1, iov[29].iov_base, 640);

	ut_expected_io_set_iov(expected_io, 2, iov[29].iov_base + 640, 128);

	TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



	/* The 24th child IO */

	expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, 45, 3, 3);

	ut_expected_io_set_iov(expected_io, 0, iov[30].iov_base, 640);

	ut_expected_io_set_iov(expected_io, 1, iov[31].iov_base, 640);

	ut_expected_io_set_iov(expected_io, 2, iov[32].iov_base, 256);

	TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



	/* The 25th child IO */

	expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_READ, 48, 2, 2);

	ut_expected_io_set_iov(expected_io, 0, iov[32].iov_base + 256, 384);

	ut_expected_io_set_iov(expected_io, 1, iov[33].iov_base, 640);

	TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



	rc = spdk_bdev_readv_blocks(desc, io_ch, iov, BDEV_IO_NUM_CHILD_IOV + 2, 0,

				    50, io_done, NULL);

	CU_ASSERT(rc == 0);

	CU_ASSERT(g_io_done == false);



	/* Parent IO supports up to 32 child iovs, so it is calculated that

	 * a maximum of 11 IOs can be split at a time, and the

	 * splitting will continue after the first batch is over.

	 */

	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == 11);

	stub_complete_io(11);

	CU_ASSERT(g_io_done == false);



	/* The 2nd round */

	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == 11);

	stub_complete_io(11);

	CU_ASSERT(g_io_done == false);



	/* The last round */

	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == 3);

	stub_complete_io(3);

	CU_ASSERT(g_io_done == true);

	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == 0);



	/* Test an WRITE_ZEROES.  This should also not be split. */

	bdev->max_segment_size = 512;

	bdev->max_num_segments = 1;

	g_io_done = false;



	expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_WRITE_ZEROES, 9, 36, 0);

	TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



	rc = spdk_bdev_write_zeroes_blocks(desc, io_ch, 9, 36, io_done, NULL);

	CU_ASSERT(rc == 0);

	CU_ASSERT(g_io_done == false);

	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == 1);

	stub_complete_io(1);

	CU_ASSERT(g_io_done == true);



	/* Test an UNMAP.  This should also not be split. */

	g_io_done = false;



	expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_UNMAP, 15, 4, 0);

	TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



	rc = spdk_bdev_unmap_blocks(desc, io_ch, 15, 4, io_done, NULL);

	CU_ASSERT(rc == 0);

	CU_ASSERT(g_io_done == false);

	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == 1);

	stub_complete_io(1);

	CU_ASSERT(g_io_done == true);



	/* Test a FLUSH.  This should also not be split. */

	g_io_done = false;



	expected_io = ut_alloc_expected_io(SPDK_BDEV_IO_TYPE_FLUSH, 15, 4, 0);

	TAILQ_INSERT_TAIL(&g_bdev_ut_channel->expected_io, expected_io, link);



	rc = spdk_bdev_flush_blocks(desc, io_ch, 15, 2, io_done, NULL);

	CU_ASSERT(rc == 0);

	CU_ASSERT(g_io_done == false);

	CU_ASSERT(g_bdev_ut_channel->outstanding_io_count == 1);

	stub_complete_io(1);

	CU_ASSERT(g_io_done == true);



	spdk_put_io_channel(io_ch);

	spdk_bdev_close(desc);

	free_bdev(bdev);

	spdk_bdev_finish(bdev_fini_cb, NULL);

	poll_threads();

}



static void

bdev_io_split_with_io_wait(void)

{
@@ -3460,7 +4006,8 @@ main(int argc, char **argv) 
	CU_ADD_TEST(suite, bdev_io_types_test);

	CU_ADD_TEST(suite, bdev_io_wait_test);

	CU_ADD_TEST(suite, bdev_io_spans_split_test);

	CU_ADD_TEST(suite, bdev_io_split_test);

	CU_ADD_TEST(suite, bdev_io_boundary_split_test);

	CU_ADD_TEST(suite, bdev_io_max_size_and_segment_split_test);

	CU_ADD_TEST(suite, bdev_io_split_with_io_wait);

	CU_ADD_TEST(suite, bdev_io_alignment_with_boundary);

	CU_ADD_TEST(suite, bdev_io_alignment);