Commit 2de3092a authored by Shuhei Matsumoto's avatar Shuhei Matsumoto Committed by Konrad Sztyber
Browse files

dif: Remove alignment requirement from spdk_dif_verify_copy() 



As mentioned in the last patch in the patch series,
spdk_dif_verify_copy() required each iovec of bounce buffer to be
multiple of block size length. This was too strong.

The last patch removed the limitation for spdk_dif_generate_copy().
This patch removes the limitation for spdk_dif_verify_copy().

Add unit test cases for verification.

Signed-off-by: default avatarShuhei Matsumoto <smatsumoto@nvidia.com>
Change-Id: Ib32e9f4b3ca27e4ed7d9c95626aec562b9384198
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/23683


Community-CI: Mellanox Build Bot
Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: default avatarAleksey Marchuk <alexeymar@nvidia.com>
Reviewed-by: default avatarJim Harris <jim.harris@samsung.com>
parent d3032139

lib/util/dif.c

+13 −71
Original line number Diff line number Diff line
@@ -148,22 +148,6 @@ _dif_sgl_is_bytes_multiple(struct _dif_sgl *s, uint32_t bytes) 
	return true;

}



static bool

_dif_sgl_is_valid_block_aligned(struct _dif_sgl *s, uint32_t num_blocks, uint32_t block_size)

{

	uint32_t count = 0;

	int i;



	for (i = 0; i < s->iovcnt; i++) {

		if (s->iov[i].iov_len % block_size) {

			return false;

		}

		count += s->iov[i].iov_len / block_size;

	}



	return count >= num_blocks;

}



/* This function must be used before starting iteration. */

static bool

_dif_sgl_is_valid(struct _dif_sgl *s, uint32_t bytes)
@@ -368,27 +352,6 @@ _dif_generate_guard_copy_split(uint64_t guard, struct _dif_sgl *dst_sgl, 
	return guard;

}



static uint64_t

_dif_generate_guard_copy_split_dst(uint64_t guard, uint8_t *src,

				   struct _dif_sgl *dst_sgl, uint32_t data_len,

				   enum spdk_dif_pi_format dif_pi_format)

{

	uint32_t offset = 0, dst_len;

	uint8_t *dst;



	while (offset < data_len) {

		_dif_sgl_get_buf(dst_sgl, &dst, &dst_len);

		dst_len = spdk_min(dst_len, data_len - offset);



		guard = _dif_generate_guard_copy(guard, dst, src + offset, dst_len, dif_pi_format);



		_dif_sgl_advance(dst_sgl, dst_len);

		offset += dst_len;

	}



	return guard;

}



static void

_data_copy_split(struct _dif_sgl *dst_sgl, struct _dif_sgl *src_sgl, uint32_t data_len)

{
@@ -409,23 +372,6 @@ _data_copy_split(struct _dif_sgl *dst_sgl, struct _dif_sgl *src_sgl, uint32_t da 
	}

}



static void

_data_copy_split_dst(uint8_t *src, struct _dif_sgl *dst_sgl, uint32_t data_len)

{

	uint32_t offset = 0, dst_len;

	uint8_t *dst;



	while (offset < data_len) {

		_dif_sgl_get_buf(dst_sgl, &dst, &dst_len);

		dst_len = spdk_min(dst_len, data_len - offset);



		memcpy(dst, src + offset, dst_len);



		_dif_sgl_advance(dst_sgl, dst_len);

		offset += dst_len;

	}

}



static inline uint8_t

_dif_apptag_offset(enum spdk_dif_pi_format dif_pi_format)

{
@@ -1376,25 +1322,24 @@ _dif_verify_copy_split(struct _dif_sgl *src_sgl, struct _dif_sgl *dst_sgl, 
		       struct spdk_dif_error *err_blk)

{

	uint32_t data_block_size;

	uint8_t *src;

	uint64_t guard = 0;



	_dif_sgl_get_buf(src_sgl, &src, NULL);

	struct spdk_dif dif = {};



	data_block_size = ctx->block_size - ctx->md_size;



	if (ctx->dif_flags & SPDK_DIF_FLAGS_GUARD_CHECK) {

		guard = _dif_generate_guard_copy_split_dst(ctx->guard_seed, src, dst_sgl,

		guard = _dif_generate_guard_copy_split(ctx->guard_seed, dst_sgl, src_sgl,

						       data_block_size, ctx->dif_pi_format);

		guard = _dif_generate_guard(guard, src + data_block_size,

					    ctx->guard_interval - data_block_size, ctx->dif_pi_format);

		guard = dif_generate_guard_split(guard, src_sgl, data_block_size,

						 ctx->guard_interval - data_block_size, ctx);

	} else {

		_data_copy_split_dst(src, dst_sgl, data_block_size);

		_data_copy_split(dst_sgl, src_sgl, data_block_size);

		_dif_sgl_advance(src_sgl, ctx->guard_interval - data_block_size);

	}



	_dif_sgl_advance(src_sgl, ctx->block_size);

	dif_load_split(src_sgl, &dif, ctx);



	return _dif_verify(src + ctx->guard_interval, guard, offset_blocks, ctx, err_blk);

	return _dif_verify(&dif, guard, offset_blocks, ctx, err_blk);

}



static int
@@ -1429,21 +1374,18 @@ spdk_dif_verify_copy(struct iovec *iovs, int iovcnt, struct iovec *bounce_iovs, 


	data_block_size = ctx->block_size - ctx->md_size;



	if (!_dif_sgl_is_valid(&dst_sgl, data_block_size * num_blocks)) {

	if (!_dif_sgl_is_valid(&dst_sgl, data_block_size * num_blocks) ||

	    !_dif_sgl_is_valid(&src_sgl, ctx->block_size * num_blocks)) {

		SPDK_ERRLOG("Size of iovec arrays are not valid\n");

		return -EINVAL;

	}



	if (!_dif_sgl_is_valid_block_aligned(&src_sgl, num_blocks, ctx->block_size)) {

		SPDK_ERRLOG("Size of bounce_iovs arrays are not valid or misaligned with block_size.\n");

		return -EINVAL;

	}



	if (_dif_is_disabled(ctx->dif_type)) {

		return 0;

	}



	if (_dif_sgl_is_bytes_multiple(&dst_sgl, data_block_size)) {

	if (_dif_sgl_is_bytes_multiple(&dst_sgl, data_block_size) &&

	    _dif_sgl_is_bytes_multiple(&src_sgl, ctx->block_size)) {

		return dif_verify_copy(&src_sgl, &dst_sgl, num_blocks, ctx, err_blk);

	} else {

		return dif_verify_copy_split(&src_sgl, &dst_sgl, num_blocks, ctx, err_blk);

test/unit/lib/util/dif.c/dif_ut.c

+143 −27
Original line number Diff line number Diff line
@@ -1576,7 +1576,8 @@ dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_reftag_test(void) 
}



static void

dif_copy_gen_and_verify(struct iovec *iovs, int iovcnt, struct iovec *bounce_iov,

dif_copy_gen_and_verify(struct iovec *iovs, int iovcnt,

			struct iovec *bounce_iovs, int bounce_iovcnt,

			uint32_t block_size, uint32_t md_size, uint32_t num_blocks,

			bool dif_loc, enum spdk_dif_type dif_type, uint32_t dif_flags,

			uint32_t init_ref_tag, uint16_t apptag_mask, uint16_t app_tag,
@@ -1595,10 +1596,10 @@ dif_copy_gen_and_verify(struct iovec *iovs, int iovcnt, struct iovec *bounce_iov 
			       init_ref_tag, apptag_mask, app_tag, 0, GUARD_SEED, &dif_opts);

	CU_ASSERT(rc == 0);



	rc = spdk_dif_generate_copy(iovs, iovcnt, bounce_iov, 1, num_blocks, &ctx);

	rc = spdk_dif_generate_copy(iovs, iovcnt, bounce_iovs, bounce_iovcnt, num_blocks, &ctx);

	CU_ASSERT(rc == 0);



	rc = spdk_dif_verify_copy(iovs, iovcnt, bounce_iov, 1, num_blocks, &ctx, NULL);

	rc = spdk_dif_verify_copy(iovs, iovcnt, bounce_iovs, bounce_iovcnt, num_blocks, &ctx, NULL);

	CU_ASSERT(rc == 0);



	rc = ut_data_pattern_verify(iovs, iovcnt, block_size - md_size, 0, num_blocks);
@@ -1613,9 +1614,9 @@ dif_copy_sec_512_md_8_prchk_0_single_iov(void) 
	_iov_alloc_buf(&iov, 512 * 4);

	_iov_alloc_buf(&bounce_iov, (512 + 8) * 4);



	dif_copy_gen_and_verify(&iov, 1, &bounce_iov, 512 + 8, 8, 4,

	dif_copy_gen_and_verify(&iov, 1, &bounce_iov, 1, 512 + 8, 8, 4,

				false, SPDK_DIF_TYPE1, 0, 0, 0, 0, SPDK_DIF_PI_FORMAT_16);

	dif_copy_gen_and_verify(&iov, 1, &bounce_iov, 512 + 8, 8, 4,

	dif_copy_gen_and_verify(&iov, 1, &bounce_iov, 1, 512 + 8, 8, 4,

				true, SPDK_DIF_TYPE1, 0, 0, 0, 0, SPDK_DIF_PI_FORMAT_16);



	_iov_free_buf(&iov);
@@ -1631,9 +1632,9 @@ _dif_copy_sec_4096_md_128_prchk_0_single_iov_test( 
	_iov_alloc_buf(&iov, 4096 * 4);

	_iov_alloc_buf(&bounce_iov, (4096 + 128) * 4);



	dif_copy_gen_and_verify(&iov, 1, &bounce_iov, 4096 + 128, 128, 4,

	dif_copy_gen_and_verify(&iov, 1, &bounce_iov, 1, 4096 + 128, 128, 4,

				false, SPDK_DIF_TYPE1, 0, 0, 0, 0, dif_pi_format);

	dif_copy_gen_and_verify(&iov, 1, &bounce_iov, 4096 + 128, 128, 4,

	dif_copy_gen_and_verify(&iov, 1, &bounce_iov, 1, 4096 + 128, 128, 4,

				true, SPDK_DIF_TYPE1, 0, 0, 0, 0, dif_pi_format);



	_iov_free_buf(&iov);
@@ -1662,18 +1663,18 @@ dif_copy_sec_512_md_8_prchk_0_1_2_4_multi_iovs(void) 


	_iov_alloc_buf(&bounce_iov, (512 + 8) * num_blocks);



	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 512 + 8, 8, num_blocks,

	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 1, 512 + 8, 8, num_blocks,

				false, SPDK_DIF_TYPE1, 0, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_16);



	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 512 + 8, 8, num_blocks,

	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 1, 512 + 8, 8, num_blocks,

				false, SPDK_DIF_TYPE1, SPDK_DIF_FLAGS_GUARD_CHECK, 22, 0xFFFF, 0x22,

				SPDK_DIF_PI_FORMAT_16);



	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 512 + 8, 8, num_blocks,

	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 1, 512 + 8, 8, num_blocks,

				false, SPDK_DIF_TYPE1, SPDK_DIF_FLAGS_APPTAG_CHECK, 22, 0xFFFF, 0x22,

				SPDK_DIF_PI_FORMAT_16);



	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 512 + 8, 8, num_blocks,

	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 1, 512 + 8, 8, num_blocks,

				false, SPDK_DIF_TYPE1, SPDK_DIF_FLAGS_REFTAG_CHECK, 22, 0xFFFF, 0x22,

				SPDK_DIF_PI_FORMAT_16);
@@ -1699,18 +1700,18 @@ _dif_copy_sec_4096_md_128_prchk_0_1_2_4_multi_iovs_test( 


	_iov_alloc_buf(&bounce_iov, (4096 + 128) * num_blocks);



	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128, num_blocks,

	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 1, 4096 + 128, 128, num_blocks,

				false, SPDK_DIF_TYPE1, 0, 22, 0xFFFF, 0x22, dif_pi_format);



	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128, num_blocks,

	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 1, 4096 + 128, 128, num_blocks,

				false, SPDK_DIF_TYPE1, SPDK_DIF_FLAGS_GUARD_CHECK, 22, 0xFFFF, 0x22,

				dif_pi_format);



	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128, num_blocks,

	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 1, 4096 + 128, 128, num_blocks,

				false, SPDK_DIF_TYPE1, SPDK_DIF_FLAGS_APPTAG_CHECK, 22, 0xFFFF, 0x22,

				dif_pi_format);



	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128, num_blocks,

	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 1, 4096 + 128, 128, num_blocks,

				false, SPDK_DIF_TYPE1, SPDK_DIF_FLAGS_REFTAG_CHECK, 22, 0xFFFF, 0x22,

				dif_pi_format);
@@ -1727,6 +1728,58 @@ dif_copy_sec_4096_md_128_prchk_0_1_2_4_multi_iovs_test(void) 
	_dif_copy_sec_4096_md_128_prchk_0_1_2_4_multi_iovs_test(SPDK_DIF_PI_FORMAT_64);

}



static void

_dif_copy_sec_4096_md_128_prchk_0_1_2_4_multi_bounce_iovs_test(

	enum spdk_dif_pi_format dif_pi_format)

{

	struct iovec iovs[4], bounce_iovs[2];

	int i, num_blocks;



	num_blocks = 0;



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

		_iov_alloc_buf(&iovs[i], 4096 * (i + 1));

		num_blocks += i + 1;

	}



	num_blocks = 0;



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

		_iov_alloc_buf(&bounce_iovs[i], (4096 + 128) * 2 * (i + 1));

		num_blocks += 2 * (i + 1);

	}



	dif_copy_gen_and_verify(iovs, 4, bounce_iovs, 2, 4096 + 128, 128, num_blocks,

				false, SPDK_DIF_TYPE1, 0, 22, 0xFFFF, 0x22, dif_pi_format);



	dif_copy_gen_and_verify(iovs, 4, bounce_iovs, 2, 4096 + 128, 128, num_blocks,

				false, SPDK_DIF_TYPE1, SPDK_DIF_FLAGS_GUARD_CHECK, 22, 0xFFFF, 0x22,

				dif_pi_format);



	dif_copy_gen_and_verify(iovs, 4, bounce_iovs, 2, 4096 + 128, 128, num_blocks,

				false, SPDK_DIF_TYPE1, SPDK_DIF_FLAGS_APPTAG_CHECK, 22, 0xFFFF, 0x22,

				dif_pi_format);



	dif_copy_gen_and_verify(iovs, 4, bounce_iovs, 2, 4096 + 128, 128, num_blocks,

				false, SPDK_DIF_TYPE1, SPDK_DIF_FLAGS_REFTAG_CHECK, 22, 0xFFFF, 0x22,

				dif_pi_format);



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

		_iov_free_buf(&iovs[i]);

	}



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

		_iov_free_buf(&bounce_iovs[i]);

	}

}



static void

dif_copy_sec_4096_md_128_prchk_0_1_2_4_multi_bounce_iovs_test(void)

{

	_dif_copy_sec_4096_md_128_prchk_0_1_2_4_multi_bounce_iovs_test(SPDK_DIF_PI_FORMAT_32);

	_dif_copy_sec_4096_md_128_prchk_0_1_2_4_multi_bounce_iovs_test(SPDK_DIF_PI_FORMAT_64);

}



static void

dif_copy_sec_4096_md_128_prchk_7_multi_iovs(void)

{
@@ -1746,17 +1799,17 @@ dif_copy_sec_4096_md_128_prchk_7_multi_iovs(void) 


	_iov_alloc_buf(&bounce_iov, (4096 + 128) * num_blocks);



	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128, num_blocks,

	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 1, 4096 + 128, 128, num_blocks,

				false, SPDK_DIF_TYPE1, dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_16);

	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128, num_blocks,

	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 1, 4096 + 128, 128, num_blocks,

				true, SPDK_DIF_TYPE1, dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_16);

	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128, num_blocks,

	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 1, 4096 + 128, 128, num_blocks,

				false, SPDK_DIF_TYPE1, dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_32);

	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128, num_blocks,

	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 1, 4096 + 128, 128, num_blocks,

				true, SPDK_DIF_TYPE1, dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_32);

	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128, num_blocks,

	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 1, 4096 + 128, 128, num_blocks,

				false, SPDK_DIF_TYPE1, dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_64);

	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128, num_blocks,

	dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 1, 4096 + 128, 128, num_blocks,

				true, SPDK_DIF_TYPE1, dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_64);



	for (i = 0; i < 4; i++) {
@@ -1779,7 +1832,7 @@ dif_copy_sec_512_md_8_prchk_7_multi_iovs_split_data(void) 


	_iov_alloc_buf(&bounce_iov, 512 + 8);



	dif_copy_gen_and_verify(iovs, 2, &bounce_iov, 512 + 8, 8, 1,

	dif_copy_gen_and_verify(iovs, 2, &bounce_iov, 1, 512 + 8, 8, 1,

				false, SPDK_DIF_TYPE1, dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_16);



	_iov_free_buf(&iovs[0]);
@@ -1801,9 +1854,9 @@ dif_copy_sec_4096_md_128_prchk_7_multi_iovs_split_data_test(void) 


	_iov_alloc_buf(&bounce_iov, 4096 + 128);



	dif_copy_gen_and_verify(iovs, 2, &bounce_iov, 4096 + 128, 128, 1,

	dif_copy_gen_and_verify(iovs, 2, &bounce_iov, 1, 4096 + 128, 128, 1,

				false, SPDK_DIF_TYPE1, dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_32);

	dif_copy_gen_and_verify(iovs, 2, &bounce_iov, 4096 + 128, 128, 1,

	dif_copy_gen_and_verify(iovs, 2, &bounce_iov, 1, 4096 + 128, 128, 1,

				false, SPDK_DIF_TYPE1, dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_64);



	_iov_free_buf(&iovs[0]);
@@ -1841,7 +1894,7 @@ dif_copy_sec_512_md_8_prchk_7_multi_iovs_complex_splits(void) 


	_iov_alloc_buf(&bounce_iov, (512 + 8) * 4);



	dif_copy_gen_and_verify(iovs, 6, &bounce_iov, 512 + 8, 8, 4,

	dif_copy_gen_and_verify(iovs, 6, &bounce_iov, 1, 512 + 8, 8, 4,

				true, SPDK_DIF_TYPE1, dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_16);



	for (i = 0; i < 6; i++) {
@@ -1850,6 +1903,67 @@ dif_copy_sec_512_md_8_prchk_7_multi_iovs_complex_splits(void) 
	_iov_free_buf(&bounce_iov);

}



static void

dif_copy_sec_512_md_8_prchk_7_multi_bounce_iovs_complex_splits(void)

{

	struct iovec iovs[6], bounce_iovs[7];

	uint32_t dif_flags;

	int i;



	dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |

		    SPDK_DIF_FLAGS_REFTAG_CHECK;



	/* src_data[0][255:0] */

	_iov_alloc_buf(&iovs[0], 256);



	/* src_data[0][511:256], src_data[1][255:0] */

	_iov_alloc_buf(&iovs[1], 256 + 256);



	/* src_data[1][382:256] */

	_iov_alloc_buf(&iovs[2], 128);



	/* src_data[1][383] */

	_iov_alloc_buf(&iovs[3], 1);



	/* src_data[1][510:384] */

	_iov_alloc_buf(&iovs[4], 126);



	/* src_data[1][511], src_data[2][511:0], src_data[3][511:0] */

	_iov_alloc_buf(&iovs[5], 1 + 512 * 2);



	/* dst_data[0][516:0] */

	_iov_alloc_buf(&bounce_iovs[0], 517);



	/* dst_data[0][519:517], dst_data[1][260:0] */

	_iov_alloc_buf(&bounce_iovs[1], 3 + 261);



	/* dst_data[1][399:261] */

	_iov_alloc_buf(&bounce_iovs[2], 139);



	/* dst_data[1][511:400] */

	_iov_alloc_buf(&bounce_iovs[3], 112);



	/* dst_data[1][515:512] */

	_iov_alloc_buf(&bounce_iovs[4], 4);



	/* dst_data[1][519:516], dst_data[2][11:0] */

	_iov_alloc_buf(&bounce_iovs[5], 21);



	/* dst_data[1][519:12], dst_data[2][519:0], dst_data[3][519:0] */

	_iov_alloc_buf(&bounce_iovs[6], 507 + 520 + 520);



	dif_copy_gen_and_verify(iovs, 6, bounce_iovs, 7, 512 + 8, 8, 4,

				true, SPDK_DIF_TYPE1, dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_16);



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

		_iov_free_buf(&iovs[i]);

	}



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

		_iov_free_buf(&bounce_iovs[i]);

	}

}



static void

dif_copy_sec_4096_md_128_prchk_7_multi_iovs_complex_splits_test(void)

{
@@ -1880,9 +1994,9 @@ dif_copy_sec_4096_md_128_prchk_7_multi_iovs_complex_splits_test(void) 


	_iov_alloc_buf(&bounce_iov, (4096 + 128) * 4);



	dif_copy_gen_and_verify(iovs, 6, &bounce_iov, 4096 + 128, 128, 4,

	dif_copy_gen_and_verify(iovs, 6, &bounce_iov, 1, 4096 + 128, 128, 4,

				true, SPDK_DIF_TYPE1, dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_32);

	dif_copy_gen_and_verify(iovs, 6, &bounce_iov, 4096 + 128, 128, 4,

	dif_copy_gen_and_verify(iovs, 6, &bounce_iov, 1, 4096 + 128, 128, 4,

				true, SPDK_DIF_TYPE1, dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_64);



	for (i = 0; i < 6; i++) {
@@ -4262,10 +4376,12 @@ main(int argc, char **argv) 
	CU_ADD_TEST(suite, dif_copy_sec_4096_md_128_prchk_0_single_iov_test);

	CU_ADD_TEST(suite, dif_copy_sec_512_md_8_prchk_0_1_2_4_multi_iovs);

	CU_ADD_TEST(suite, dif_copy_sec_4096_md_128_prchk_0_1_2_4_multi_iovs_test);

	CU_ADD_TEST(suite, dif_copy_sec_4096_md_128_prchk_0_1_2_4_multi_bounce_iovs_test);

	CU_ADD_TEST(suite, dif_copy_sec_4096_md_128_prchk_7_multi_iovs);

	CU_ADD_TEST(suite, dif_copy_sec_512_md_8_prchk_7_multi_iovs_split_data);

	CU_ADD_TEST(suite, dif_copy_sec_4096_md_128_prchk_7_multi_iovs_split_data_test);

	CU_ADD_TEST(suite, dif_copy_sec_512_md_8_prchk_7_multi_iovs_complex_splits);

	CU_ADD_TEST(suite, dif_copy_sec_512_md_8_prchk_7_multi_bounce_iovs_complex_splits);

	CU_ADD_TEST(suite, dif_copy_sec_4096_md_128_prchk_7_multi_iovs_complex_splits_test);

	CU_ADD_TEST(suite, dif_copy_sec_4096_md_128_inject_1_2_4_8_multi_iovs_test);

	CU_ADD_TEST(suite, dif_copy_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_test);