Commit a63a45fc authored by Slawomir Ptak's avatar Slawomir Ptak Committed by Konrad Sztyber
Browse files

test/accel/dif: add DIX Verify/Generate suites 



Add DIX Verify and Generate test suites to dif test application.
Additionally, add DIF/DIX strings to test descriptions.

Change-Id: I69989c7cfebc20836de889f978ebfcdc3754d9ab
Signed-off-by: default avatarKrzysztof Karas <krzysztof.karas@intel.com>
Signed-off-by: default avatarSlawomir Ptak <slawomir.ptak@intel.com>
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/24056


Reviewed-by: default avatarShuhei Matsumoto <smatsumoto@nvidia.com>
Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: default avatarKonrad Sztyber <konrad.sztyber@intel.com>
parent 8d52c4c2

test/accel/dif/dif.c

+604 −14
Original line number Diff line number Diff line
@@ -37,6 +37,7 @@ struct dif_task { 
	uint32_t		src_iovcnt;

	struct iovec		*aux_iovs;

	uint32_t		aux_iovcnt;

	struct iovec		md_iov;

	uint32_t		num_blocks; /* used for the DIF related operations */

	struct spdk_dif_ctx	dif_ctx;

	struct spdk_dif_error	dif_err;
@@ -83,6 +84,7 @@ struct accel_dif_request { 
	size_t src_iovcnt;

	struct iovec *aux_iovs;

	size_t aux_iovcnt;

	struct iovec *md_iov;

	uint32_t num_blocks;

	const struct spdk_dif_ctx *ctx;

	struct spdk_dif_error *err;
@@ -103,16 +105,15 @@ static bool 
accel_dif_error_validate(const uint32_t dif_flags,

			 const struct spdk_dif_error *err)

{

	switch (dif_flags) {

	case SPDK_DIF_FLAGS_GUARD_CHECK:

	if (dif_flags & SPDK_DIF_FLAGS_GUARD_CHECK) {

		return err->err_type == SPDK_DIF_GUARD_ERROR;

	case SPDK_DIF_FLAGS_APPTAG_CHECK:

	} else if (dif_flags & SPDK_DIF_FLAGS_APPTAG_CHECK) {

		return err->err_type == SPDK_DIF_APPTAG_ERROR;

	case SPDK_DIF_FLAGS_REFTAG_CHECK:

	} else if (dif_flags & SPDK_DIF_FLAGS_REFTAG_CHECK) {

		return err->err_type == SPDK_DIF_REFTAG_ERROR;

	default:

		return false;

	}



	return false;

}



static int
@@ -145,6 +146,42 @@ alloc_dif_verify_bufs(struct dif_task *task, uint32_t chained_count) 
	return 0;

}



static int

alloc_dix_bufs(struct dif_task *task, uint32_t chained_count)

{

	int src_buff_len = g_xfer_size_bytes, md_buff_len;

	uint32_t i = 0;



	assert(chained_count > 0);

	task->src_iovcnt = chained_count;

	task->src_iovs = calloc(task->src_iovcnt, sizeof(struct iovec));

	if (spdk_unlikely(task->src_iovs == NULL)) {

		return -ENOMEM;

	}



	md_buff_len = (g_xfer_size_bytes / g_block_size_bytes) * g_md_size_bytes * chained_count;



	for (i = 0; i < task->src_iovcnt; i++) {

		task->src_iovs[i].iov_base = spdk_dma_zmalloc(src_buff_len, 0, NULL);

		if (spdk_unlikely(task->src_iovs[i].iov_base == NULL)) {

			return -ENOMEM;

		}



		memset(task->src_iovs[i].iov_base, DATA_PATTERN, src_buff_len);

		task->src_iovs[i].iov_len = src_buff_len;

	}



	task->md_iov.iov_base = spdk_dma_zmalloc(md_buff_len, 0, NULL);

	if (spdk_unlikely(task->md_iov.iov_base == NULL)) {

		return -ENOMEM;

	}



	task->md_iov.iov_len = md_buff_len;

	task->num_blocks = (g_xfer_size_bytes * chained_count) / g_block_size_bytes;



	return 0;

}



static void

free_dif_verify_bufs(struct dif_task *task)

{
@@ -160,6 +197,25 @@ free_dif_verify_bufs(struct dif_task *task) 
	}

}



static void

free_dix_bufs(struct dif_task *task)

{

	uint32_t i = 0;



	if (task->src_iovs != NULL) {

		for (i = 0; i < task->src_iovcnt; i++) {

			if (task->src_iovs[i].iov_base != NULL) {

				spdk_dma_free(task->src_iovs[i].iov_base);

			}

		}

		free(task->src_iovs);

	}



	if (task->md_iov.iov_base != NULL) {

		spdk_dma_free(task->md_iov.iov_base);

	}

}



static int

alloc_dif_verify_copy_bufs(struct dif_task *task, uint32_t chained_count)

{
@@ -420,6 +476,35 @@ accel_dif_verify_test(void *arg) 
	}

}



static void

accel_dix_verify_test(void *arg)

{

	int rc;

	struct accel_dif_request *req = arg;



	g_completion_success = false;

	rc = spdk_accel_submit_dix_verify(req->channel, req->src_iovs, req->src_iovcnt, req->md_iov,

					  req->num_blocks, req->ctx, req->err, req->cb_fn,

					  req->cb_arg);

	if (rc) {

		wake_ut_thread();

	}

}



static void

accel_dix_generate_test(void *arg)

{

	int rc;

	struct accel_dif_request *req = arg;



	g_completion_success = false;

	rc = spdk_accel_submit_dix_generate(req->channel, req->src_iovs, req->src_iovcnt,

					    req->md_iov, req->num_blocks, req->ctx, req->cb_fn, req->cb_arg);

	if (rc) {

		wake_ut_thread();

	}

}



static void

accel_dif_verify_copy_test(void *arg)

{
@@ -565,6 +650,55 @@ accel_dif_verify_op_dif_generated_do_check(uint32_t dif_flags) 
	free_dif_verify_bufs(task);

}



static void

accel_dix_generate_verify(struct accel_dif_request *req,

			  uint32_t dif_flags_generate, uint32_t dif_flags_verify)

{

	struct spdk_dif_ctx_init_ext_opts dif_opts;

	struct dif_task *task = &g_dif_task;

	int rc;



	rc = alloc_dix_bufs(task, 1);

	SPDK_CU_ASSERT_FATAL(rc == 0);



	dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);

	dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;



	rc = spdk_dif_ctx_init(&task->dif_ctx,

			       g_block_size_bytes,

			       g_md_size_bytes, false, true,

			       SPDK_DIF_TYPE1,

			       dif_flags_generate,

			       10, 0xFFFF, 20, 0, 0, &dif_opts);

	SPDK_CU_ASSERT_FATAL(rc == 0);



	rc = spdk_dix_generate(task->src_iovs, task->src_iovcnt, &task->md_iov, task->num_blocks,

			       &task->dif_ctx);

	SPDK_CU_ASSERT_FATAL(rc == 0);



	rc = spdk_dif_ctx_init(&task->dif_ctx,

			       g_block_size_bytes,

			       g_md_size_bytes, false, true,

			       SPDK_DIF_TYPE1,

			       dif_flags_verify,

			       10, 0xFFFF, 20, 0, 0, &dif_opts);

	SPDK_CU_ASSERT_FATAL(rc == 0);



	req->channel = g_channel;

	req->src_iovs = task->src_iovs;

	req->src_iovcnt = task->src_iovcnt;

	req->md_iov = &task->md_iov;

	req->num_blocks = task->num_blocks;

	req->ctx = &task->dif_ctx;

	req->err = &task->dif_err;

	req->cb_fn = accel_dif_oper_done;

	req->cb_arg = task;



	execute_spdk_function(accel_dix_verify_test, req);



	free_dix_bufs(task);

}



static void

accel_dif_verify_op_dif_generated_guard_check(void)

{
@@ -583,6 +717,65 @@ accel_dif_verify_op_dif_generated_reftag_check(void) 
	accel_dif_verify_op_dif_generated_do_check(SPDK_DIF_FLAGS_REFTAG_CHECK);

}



static void

accel_dix_verify_op_dix_generated_guard_check(void)

{

	struct accel_dif_request req;

	accel_dix_generate_verify(&req, SPDK_DIF_FLAGS_GUARD_CHECK |

				  SPDK_DIF_FLAGS_APPTAG_CHECK |

				  SPDK_DIF_FLAGS_REFTAG_CHECK, SPDK_DIF_FLAGS_GUARD_CHECK);



	CU_ASSERT_EQUAL(g_completion_success, true);

}



static void

accel_dix_verify_op_dix_generated_apptag_check(void)

{

	struct accel_dif_request req;

	accel_dix_generate_verify(&req, SPDK_DIF_FLAGS_GUARD_CHECK |

				  SPDK_DIF_FLAGS_APPTAG_CHECK |

				  SPDK_DIF_FLAGS_REFTAG_CHECK, SPDK_DIF_FLAGS_APPTAG_CHECK);



	CU_ASSERT_EQUAL(g_completion_success, true);

}



static void

accel_dix_verify_op_dix_generated_reftag_check(void)

{

	struct accel_dif_request req;

	accel_dix_generate_verify(&req, SPDK_DIF_FLAGS_GUARD_CHECK |

				  SPDK_DIF_FLAGS_APPTAG_CHECK |

				  SPDK_DIF_FLAGS_REFTAG_CHECK, SPDK_DIF_FLAGS_REFTAG_CHECK);



	CU_ASSERT_EQUAL(g_completion_success, true);

}



static void

accel_dix_verify_op_dix_generated_all_flags_check(void)

{

	struct accel_dif_request req;

	accel_dix_generate_verify(&req, SPDK_DIF_FLAGS_GUARD_CHECK |

				  SPDK_DIF_FLAGS_APPTAG_CHECK |

				  SPDK_DIF_FLAGS_REFTAG_CHECK,

				  SPDK_DIF_FLAGS_GUARD_CHECK |

				  SPDK_DIF_FLAGS_APPTAG_CHECK |

				  SPDK_DIF_FLAGS_REFTAG_CHECK);



	CU_ASSERT_EQUAL(g_completion_success, true);

}



static void

accel_dix_verify_op_dix_not_generated_all_flags_check(void)

{

	struct accel_dif_request req;

	accel_dix_generate_verify(&req, 0,

				  SPDK_DIF_FLAGS_GUARD_CHECK |

				  SPDK_DIF_FLAGS_APPTAG_CHECK |

				  SPDK_DIF_FLAGS_REFTAG_CHECK);



	CU_ASSERT_EQUAL(g_completion_success, false);

}



static void

accel_dif_verify_op_dif_not_generated_do_check(uint32_t dif_flags)

{
@@ -627,18 +820,54 @@ accel_dif_verify_op_dif_not_generated_guard_check(void) 
	accel_dif_verify_op_dif_not_generated_do_check(SPDK_DIF_FLAGS_GUARD_CHECK);

}



static void

accel_dix_verify_op_dix_not_generated_guard_check(void)

{

	uint32_t dif_flags_verify = SPDK_DIF_FLAGS_GUARD_CHECK;

	struct accel_dif_request req;



	accel_dix_generate_verify(&req, 0, dif_flags_verify);



	CU_ASSERT_EQUAL(g_completion_success, false);

	CU_ASSERT_EQUAL(accel_dif_error_validate(dif_flags_verify, req.err), true);

}



static void

accel_dif_verify_op_dif_not_generated_apptag_check(void)

{

	accel_dif_verify_op_dif_not_generated_do_check(SPDK_DIF_FLAGS_APPTAG_CHECK);

}



static void

accel_dix_verify_op_dix_not_generated_apptag_check(void)

{

	uint32_t dif_flags_verify = SPDK_DIF_FLAGS_APPTAG_CHECK;

	struct accel_dif_request req;



	accel_dix_generate_verify(&req, 0, dif_flags_verify);



	CU_ASSERT_EQUAL(g_completion_success, false);

	CU_ASSERT_EQUAL(accel_dif_error_validate(dif_flags_verify, req.err), true);

}



static void

accel_dif_verify_op_dif_not_generated_reftag_check(void)

{

	accel_dif_verify_op_dif_not_generated_do_check(SPDK_DIF_FLAGS_REFTAG_CHECK);

}



static void

accel_dix_verify_op_dix_not_generated_reftag_check(void)

{

	uint32_t dif_flags_verify = SPDK_DIF_FLAGS_REFTAG_CHECK;

	struct accel_dif_request req;



	accel_dix_generate_verify(&req, 0, dif_flags_verify);



	CU_ASSERT_EQUAL(g_completion_success, false);

	CU_ASSERT_EQUAL(accel_dif_error_validate(dif_flags_verify, req.err), true);

}



static void

accel_dif_verify_op_apptag_correct_apptag_check(void)

{
@@ -679,6 +908,49 @@ accel_dif_verify_op_apptag_correct_apptag_check(void) 
	free_dif_verify_bufs(task);

}



static void

accel_dix_verify_op_apptag_correct_apptag_check(void)

{

	struct spdk_dif_ctx_init_ext_opts dif_opts;

	struct accel_dif_request req;

	struct dif_task *task = &g_dif_task;

	int rc;



	rc = alloc_dix_bufs(task, 1);

	SPDK_CU_ASSERT_FATAL(rc == 0);



	dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);

	dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;



	rc = spdk_dif_ctx_init(&task->dif_ctx,

			       g_block_size_bytes,

			       g_md_size_bytes, false, true,

			       SPDK_DIF_TYPE1,

			       SPDK_DIF_FLAGS_APPTAG_CHECK,

			       10, 0xFFFF, 20, 0, 0, &dif_opts);

	SPDK_CU_ASSERT_FATAL(rc == 0);



	rc = spdk_dix_generate(task->src_iovs, task->src_iovcnt, &task->md_iov, task->num_blocks,

			       &task->dif_ctx);

	SPDK_CU_ASSERT_FATAL(rc == 0);



	req.channel = g_channel;

	req.src_iovs = task->src_iovs;

	req.src_iovcnt = task->src_iovcnt;

	req.md_iov = &task->md_iov;

	req.num_blocks = task->num_blocks;

	req.ctx = &task->dif_ctx;

	req.err = &task->dif_err;

	req.cb_fn = accel_dif_oper_done;

	req.cb_arg = task;



	execute_spdk_function(accel_dix_verify_test, &req);



	CU_ASSERT_EQUAL(g_completion_success, true);



	free_dix_bufs(task);

}



static void

accel_dif_verify_op_apptag_incorrect_apptag_check(void)

{
@@ -727,6 +999,56 @@ accel_dif_verify_op_apptag_incorrect_apptag_check(void) 
	free_dif_verify_bufs(task);

}



static void

accel_dix_verify_op_apptag_incorrect_apptag_check(void)

{

	struct spdk_dif_ctx_init_ext_opts dif_opts;

	struct accel_dif_request req;

	struct dif_task *task = &g_dif_task;

	int rc;



	rc = alloc_dix_bufs(task, 1);

	SPDK_CU_ASSERT_FATAL(rc == 0);



	dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);

	dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;



	rc = spdk_dif_ctx_init(&task->dif_ctx,

			       g_block_size_bytes,

			       g_md_size_bytes, false, true,

			       SPDK_DIF_TYPE1,

			       SPDK_DIF_FLAGS_APPTAG_CHECK,

			       10, 0xFFFF, 20, 0, 0, &dif_opts);

	SPDK_CU_ASSERT_FATAL(rc == 0);



	rc = spdk_dix_generate(task->src_iovs, task->src_iovcnt, &task->md_iov, task->num_blocks,

			       &task->dif_ctx);

	SPDK_CU_ASSERT_FATAL(rc == 0);



	rc = spdk_dif_ctx_init(&task->dif_ctx,

			       g_block_size_bytes,

			       g_md_size_bytes, false, true,

			       SPDK_DIF_TYPE1,

			       SPDK_DIF_FLAGS_APPTAG_CHECK,

			       30, 0xFFFF, 40, 0, 0, &dif_opts);

	SPDK_CU_ASSERT_FATAL(rc == 0);



	req.channel = g_channel;

	req.src_iovs = task->src_iovs;

	req.src_iovcnt = task->src_iovcnt;

	req.md_iov = &task->md_iov;

	req.num_blocks = task->num_blocks;

	req.ctx = &task->dif_ctx;

	req.err = &task->dif_err;

	req.cb_fn = accel_dif_oper_done;

	req.cb_arg = task;



	execute_spdk_function(accel_dix_verify_test, &req);

	CU_ASSERT_EQUAL(g_completion_success, false);



	free_dix_bufs(task);

}



static void

accel_dif_verify_op_tag_incorrect_no_check_or_ignore(uint32_t dif_flags)

{
@@ -781,18 +1103,87 @@ accel_dif_verify_op_tag_incorrect_no_check_or_ignore(uint32_t dif_flags) 
	free_dif_verify_bufs(task);

}



static void

accel_dix_verify_op_tag_incorrect_no_check_or_ignore(uint32_t dif_flags)

{

	struct spdk_dif_ctx_init_ext_opts dif_opts;

	struct accel_dif_request req;

	struct dif_task *task = &g_dif_task;

	int rc;



	rc = alloc_dix_bufs(task, 1);

	SPDK_CU_ASSERT_FATAL(rc == 0);



	dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);

	dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;



	/* For set 'Application Tag F Detect' (Source DIF Flags)

	 * When all bits of the Application Tag field of the source Data Integrity Field

	 * are equal to 1, the Application Tag check is not done and the Guard field and

	 * Reference Tag field are ignored. */

	rc = spdk_dif_ctx_init(&task->dif_ctx,

			       g_block_size_bytes,

			       g_md_size_bytes, false, true,

			       SPDK_DIF_TYPE1,

			       SPDK_DIF_FLAGS_GUARD_CHECK |

			       SPDK_DIF_FLAGS_APPTAG_CHECK |

			       SPDK_DIF_FLAGS_REFTAG_CHECK,

			       10, 0xFFFF, 0xFFFF, 0, 0, &dif_opts);

	SPDK_CU_ASSERT_FATAL(rc == 0);



	rc = spdk_dix_generate(task->src_iovs, task->src_iovcnt, &task->md_iov, task->num_blocks,

			       &task->dif_ctx);

	SPDK_CU_ASSERT_FATAL(rc == 0);



	rc = spdk_dif_ctx_init(&task->dif_ctx,

			       g_block_size_bytes,

			       g_md_size_bytes, false, true,

			       SPDK_DIF_TYPE1,

			       dif_flags,

			       30, 0xFFFF, 40, 0, 0, &dif_opts);

	SPDK_CU_ASSERT_FATAL(rc == 0);



	req.channel = g_channel;

	req.src_iovs = task->src_iovs;

	req.src_iovcnt = task->src_iovcnt;

	req.md_iov = &task->md_iov;

	req.num_blocks = task->num_blocks;

	req.ctx = &task->dif_ctx;

	req.err = &task->dif_err;

	req.cb_fn = accel_dif_oper_done;

	req.cb_arg = task;



	execute_spdk_function(accel_dix_verify_test, &req);



	CU_ASSERT_EQUAL(g_completion_success, true);



	free_dix_bufs(task);

}



static void

accel_dif_verify_op_apptag_incorrect_no_apptag_check(void)

{

	accel_dif_verify_op_tag_incorrect_no_check_or_ignore(SPDK_DIF_FLAGS_APPTAG_CHECK);

}



static void

accel_dix_verify_op_apptag_incorrect_no_apptag_check(void)

{

	accel_dix_verify_op_tag_incorrect_no_check_or_ignore(SPDK_DIF_FLAGS_APPTAG_CHECK);

}



static void

accel_dif_verify_op_reftag_incorrect_reftag_ignore(void)

{

	accel_dif_verify_op_tag_incorrect_no_check_or_ignore(SPDK_DIF_FLAGS_REFTAG_CHECK);

}



static void

accel_dix_verify_op_reftag_incorrect_reftag_ignore(void)

{

	accel_dix_verify_op_tag_incorrect_no_check_or_ignore(SPDK_DIF_FLAGS_REFTAG_CHECK);

}



static void

accel_dif_verify_op_reftag_init_correct_reftag_check(void)

{
@@ -833,6 +1224,49 @@ accel_dif_verify_op_reftag_init_correct_reftag_check(void) 
	free_dif_verify_bufs(task);

}



static void

accel_dix_verify_op_reftag_init_correct_reftag_check(void)

{

	struct spdk_dif_ctx_init_ext_opts dif_opts;

	struct accel_dif_request req;

	struct dif_task *task = &g_dif_task;

	int rc;



	rc = alloc_dix_bufs(task, 2);

	SPDK_CU_ASSERT_FATAL(rc == 0);



	dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);

	dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;



	rc = spdk_dif_ctx_init(&task->dif_ctx,

			       g_block_size_bytes,

			       g_md_size_bytes, false, true,

			       SPDK_DIF_TYPE1,

			       SPDK_DIF_FLAGS_REFTAG_CHECK,

			       10, 0xFFFF, 20, 0, 0, &dif_opts);

	SPDK_CU_ASSERT_FATAL(rc == 0);



	rc = spdk_dix_generate(task->src_iovs, task->src_iovcnt, &task->md_iov, task->num_blocks,

			       &task->dif_ctx);

	SPDK_CU_ASSERT_FATAL(rc == 0);



	req.channel = g_channel;

	req.src_iovs = task->src_iovs;

	req.src_iovcnt = task->src_iovcnt;

	req.md_iov = &task->md_iov;

	req.num_blocks = task->num_blocks;

	req.ctx = &task->dif_ctx;

	req.err = &task->dif_err;

	req.cb_fn = accel_dif_oper_done;

	req.cb_arg = task;



	execute_spdk_function(accel_dix_verify_test, &req);



	CU_ASSERT_EQUAL(g_completion_success, true);



	free_dix_bufs(task);

}



static void

accel_dif_verify_op_reftag_init_incorrect_reftag_check(void)

{
@@ -881,6 +1315,56 @@ accel_dif_verify_op_reftag_init_incorrect_reftag_check(void) 
	free_dif_verify_bufs(task);

}



static void

accel_dix_verify_op_reftag_init_incorrect_reftag_check(void)

{

	struct spdk_dif_ctx_init_ext_opts dif_opts;

	struct accel_dif_request req;

	struct dif_task *task = &g_dif_task;

	int rc;



	rc = alloc_dix_bufs(task, 2);

	SPDK_CU_ASSERT_FATAL(rc == 0);



	dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);

	dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;



	rc = spdk_dif_ctx_init(&task->dif_ctx,

			       g_block_size_bytes,

			       g_md_size_bytes, false, true,

			       SPDK_DIF_TYPE1,

			       SPDK_DIF_FLAGS_REFTAG_CHECK,

			       16, 0xFFFF, 20, 0, 0, &dif_opts);

	SPDK_CU_ASSERT_FATAL(rc == 0);



	rc = spdk_dix_generate(task->src_iovs, task->src_iovcnt, &task->md_iov, task->num_blocks,

			       &task->dif_ctx);

	SPDK_CU_ASSERT_FATAL(rc == 0);



	rc = spdk_dif_ctx_init(&task->dif_ctx,

			       g_block_size_bytes,

			       g_md_size_bytes, false, true,

			       SPDK_DIF_TYPE1,

			       SPDK_DIF_FLAGS_REFTAG_CHECK,

			       10, 0xFFFF, 20, 0, 0, &dif_opts);

	SPDK_CU_ASSERT_FATAL(rc == 0);



	req.channel = g_channel;

	req.src_iovs = task->src_iovs;

	req.src_iovcnt = task->src_iovcnt;

	req.md_iov = &task->md_iov;

	req.num_blocks = task->num_blocks;

	req.ctx = &task->dif_ctx;

	req.err = &task->dif_err;

	req.cb_fn = accel_dif_oper_done;

	req.cb_arg = task;



	execute_spdk_function(accel_dix_verify_test, &req);

	CU_ASSERT_EQUAL(g_completion_success, false);



	free_dix_bufs(task);

}



static void

accel_dif_verify_copy_op_dif_generated_do_check(uint32_t dif_flags)

{
@@ -1063,24 +1547,95 @@ accel_dif_generate_copy_op_dif_generated_do_check(uint32_t dif_flags) 
	free_dif_generate_copy_bufs(task);

}



static void

accel_dix_generate_op_dix_generated_do_check(uint32_t dif_flags)

{

	struct spdk_dif_ctx_init_ext_opts dif_opts;

	struct accel_dif_request req;

	struct dif_task *task = &g_dif_task;

	struct spdk_dif_error err_blk;

	int rc;



	rc = alloc_dix_bufs(task, 3);

	SPDK_CU_ASSERT_FATAL(rc == 0);



	dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);

	dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;



	rc = spdk_dif_ctx_init(&task->dif_ctx,

			       g_block_size_bytes,

			       g_md_size_bytes, false, true,

			       SPDK_DIF_TYPE1,

			       SPDK_DIF_FLAGS_GUARD_CHECK |

			       SPDK_DIF_FLAGS_APPTAG_CHECK |

			       SPDK_DIF_FLAGS_REFTAG_CHECK,

			       10, 0xFFFF, 20, 0, 0, &dif_opts);

	SPDK_CU_ASSERT_FATAL(rc == 0);



	req.channel = g_channel;

	req.src_iovs = task->src_iovs;

	req.src_iovcnt = task->src_iovcnt;

	req.md_iov = &task->md_iov;

	req.num_blocks = task->num_blocks;

	req.ctx = &task->dif_ctx;

	req.err = &task->dif_err;

	req.cb_fn = accel_dif_oper_done;

	req.cb_arg = task;



	execute_spdk_function(accel_dix_generate_test, &req);

	CU_ASSERT_EQUAL(g_completion_success, true);



	rc = spdk_dif_ctx_init(&task->dif_ctx,

			       g_block_size_bytes,

			       g_md_size_bytes, false, true,

			       SPDK_DIF_TYPE1,

			       dif_flags,

			       10, 0xFFFF, 20, 0, 0, &dif_opts);

	SPDK_CU_ASSERT_FATAL(rc == 0);



	rc = spdk_dix_verify(req.src_iovs, req.src_iovcnt, req.md_iov, req.num_blocks,

			     &task->dif_ctx, &err_blk);

	CU_ASSERT_EQUAL(rc, 0);



	free_dix_bufs(task);

}



static void

accel_dif_generate_copy_op_dif_generated_guard_check(void)

{

	accel_dif_generate_copy_op_dif_generated_do_check(SPDK_DIF_FLAGS_GUARD_CHECK);

}



static void

accel_dix_generate_op_dix_generated_guard_check(void)

{

	accel_dix_generate_op_dix_generated_do_check(SPDK_DIF_FLAGS_GUARD_CHECK);

}



static void

accel_dif_generate_copy_op_dif_generated_apptag_check(void)

{

	accel_dif_generate_copy_op_dif_generated_do_check(SPDK_DIF_FLAGS_APPTAG_CHECK);

}



static void

accel_dix_generate_op_dix_generated_apptag_check(void)

{

	accel_dix_generate_op_dix_generated_do_check(SPDK_DIF_FLAGS_APPTAG_CHECK);

}



static void

accel_dif_generate_copy_op_dif_generated_reftag_check(void)

{

	accel_dif_generate_copy_op_dif_generated_do_check(SPDK_DIF_FLAGS_REFTAG_CHECK);

}



static void

accel_dix_generate_op_dix_generated_reftag_check(void)

{

	accel_dix_generate_op_dix_generated_do_check(SPDK_DIF_FLAGS_REFTAG_CHECK);

}



static void

accel_dif_generate_copy_op_dif_generated_no_guard_check_flag_set(void)

{
@@ -1501,31 +2056,59 @@ setup_accel_tests(void) 


	if (CU_add_test(suite, "verify: DIF generated, GUARD check",

			accel_dif_verify_op_dif_generated_guard_check) == NULL ||

	    CU_add_test(suite, "verify: DIX generated, GUARD check",

			accel_dix_verify_op_dix_generated_guard_check) == NULL ||

	    CU_add_test(suite, "verify: DIF generated, APPTAG check",

			accel_dif_verify_op_dif_generated_apptag_check) == NULL ||

	    CU_add_test(suite, "verify: DIX generated, APPTAG check",

			accel_dix_verify_op_dix_generated_apptag_check) == NULL ||

	    CU_add_test(suite, "verify: DIF generated, REFTAG check",

			accel_dif_verify_op_dif_generated_reftag_check) == NULL ||

	    CU_add_test(suite, "verify: DIX generated, REFTAG check",

			accel_dix_verify_op_dix_generated_reftag_check) == NULL ||

	    CU_add_test(suite, "verify: DIX generated, all flags check",

			accel_dix_verify_op_dix_generated_all_flags_check) == NULL ||



	    CU_add_test(suite, "verify: DIF not generated, GUARD check",

			accel_dif_verify_op_dif_not_generated_guard_check) == NULL ||

	    CU_add_test(suite, "verify: DIX not generated, GUARD check",

			accel_dix_verify_op_dix_not_generated_guard_check) == NULL ||

	    CU_add_test(suite, "verify: DIF not generated, APPTAG check",

			accel_dif_verify_op_dif_not_generated_apptag_check) == NULL ||

	    CU_add_test(suite, "verify: DIX not generated, APPTAG check",

			accel_dix_verify_op_dix_not_generated_apptag_check) == NULL ||

	    CU_add_test(suite, "verify: DIF not generated, REFTAG check",

			accel_dif_verify_op_dif_not_generated_reftag_check) == NULL ||

	    CU_add_test(suite, "verify: DIX not generated, REFTAG check",

			accel_dix_verify_op_dix_not_generated_reftag_check) == NULL ||

	    CU_add_test(suite, "verify: DIX not generated, all flags check",

			accel_dix_verify_op_dix_not_generated_all_flags_check) == NULL ||



	    CU_add_test(suite, "verify: APPTAG correct, APPTAG check",

	    CU_add_test(suite, "verify: DIF APPTAG correct, APPTAG check",

			accel_dif_verify_op_apptag_correct_apptag_check) == NULL ||

	    CU_add_test(suite, "verify: APPTAG incorrect, APPTAG check",

	    CU_add_test(suite, "verify: DIX APPTAG correct, APPTAG check",

			accel_dix_verify_op_apptag_correct_apptag_check) == NULL ||

	    CU_add_test(suite, "verify: DIF APPTAG incorrect, APPTAG check",

			accel_dif_verify_op_apptag_incorrect_apptag_check) == NULL ||

	    CU_add_test(suite, "verify: APPTAG incorrect, no APPTAG check",

	    CU_add_test(suite, "verify: DIX APPTAG incorrect, APPTAG check",

			accel_dix_verify_op_apptag_incorrect_apptag_check) == NULL ||

	    CU_add_test(suite, "verify: DIF APPTAG incorrect, no APPTAG check",

			accel_dif_verify_op_apptag_incorrect_no_apptag_check) == NULL ||

	    CU_add_test(suite, "verify: REFTAG incorrect, REFTAG ignore",

	    CU_add_test(suite, "verify: DIX APPTAG incorrect, no APPTAG check",

			accel_dix_verify_op_apptag_incorrect_no_apptag_check) == NULL ||

	    CU_add_test(suite, "verify: DIF REFTAG incorrect, REFTAG ignore",

			accel_dif_verify_op_reftag_incorrect_reftag_ignore) == NULL ||

	    CU_add_test(suite, "verify: DIX REFTAG incorrect, REFTAG ignore",

			accel_dix_verify_op_reftag_incorrect_reftag_ignore) == NULL ||



	    CU_add_test(suite, "verify: REFTAG_INIT correct, REFTAG check",

	    CU_add_test(suite, "verify: DIF REFTAG_INIT correct, REFTAG check",

			accel_dif_verify_op_reftag_init_correct_reftag_check) == NULL ||

	    CU_add_test(suite, "verify: REFTAG_INIT incorrect, REFTAG check",

	    CU_add_test(suite, "verify: DIX REFTAG_INIT correct, REFTAG check",

			accel_dix_verify_op_reftag_init_correct_reftag_check) == NULL ||

	    CU_add_test(suite, "verify: DIF REFTAG_INIT incorrect, REFTAG check",

			accel_dif_verify_op_reftag_init_incorrect_reftag_check) == NULL ||

	    CU_add_test(suite, "verify: DIX REFTAG_INIT incorrect, REFTAG check",

			accel_dix_verify_op_reftag_init_incorrect_reftag_check) == NULL ||



	    CU_add_test(suite, "verify copy: DIF generated, GUARD check",

			accel_dif_verify_copy_op_dif_generated_guard_check) == NULL ||
@@ -1548,6 +2131,13 @@ setup_accel_tests(void) 
	    CU_add_test(suite, "generate copy: DIF generated, REFTAG check",

			accel_dif_generate_copy_op_dif_generated_reftag_check) == NULL ||



	    CU_add_test(suite, "generate: DIX generated, GUARD check",

			accel_dix_generate_op_dix_generated_guard_check) == NULL ||

	    CU_add_test(suite, "generate: DIX generated, APTTAG check",

			accel_dix_generate_op_dix_generated_apptag_check) == NULL ||

	    CU_add_test(suite, "generate: DIX generated, REFTAG check",

			accel_dix_generate_op_dix_generated_reftag_check) == NULL ||



	    CU_add_test(suite, "generate copy: DIF generated, no GUARD check flag set",

			accel_dif_generate_copy_op_dif_generated_no_guard_check_flag_set) == NULL ||

	    CU_add_test(suite, "generate copy: DIF generated, no APPTAG check flag set",
@@ -1555,9 +2145,9 @@ setup_accel_tests(void) 
	    CU_add_test(suite, "generate copy: DIF generated, no REFTAG check flag set",

			accel_dif_generate_copy_op_dif_generated_no_reftag_check_flag_set) == NULL ||



	    CU_add_test(suite, "generate copy: iovecs-len validate",

	    CU_add_test(suite, "generate copy: DIF iovecs-len validate",

			accel_dif_generate_copy_op_iovecs_len_validate) == NULL ||

	    CU_add_test(suite, "generate copy: buffer alignment validate",

	    CU_add_test(suite, "generate copy: DIF buffer alignment validate",

			accel_dif_generate_copy_op_buf_align_validate) == NULL ||



	    CU_add_test(suite, "generate copy sequence: DIF generated, GUARD check",