Commit f62ac001 authored by Krzysztof Sprzaczkowski's avatar Krzysztof Sprzaczkowski Committed by Tomasz Zawadzki
Browse files

test/accel: DIF generate-copy accel functional tests 



Extend the Accel test application with DIF Generate-copy operation
functional tests.

Change-Id: Ieede33af582c81cb68cc2acb69f8e0bb86f24c06
Signed-off-by: default avatarKrzysztof Sprzaczkowski <krzysztof.sprzaczkowski@intel.com>
Signed-off-by: default avatarSlawomir Ptak <slawomir.ptak@intel.com>
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/20283


Reviewed-by: default avatarShuhei Matsumoto <smatsumoto@nvidia.com>
Reviewed-by: default avatarSebastian Brzezinka <sebastian.brzezinka@intel.com>
Reviewed-by: default avatarTomasz Zawadzki <tomasz.zawadzki@intel.com>
Reviewed-by: default avatarAleksey Marchuk <alexeymar@nvidia.com>
Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
parent fbe2860e

test/accel/dif/dif.c

+412 −1
Original line number Diff line number Diff line
@@ -31,6 +31,8 @@ static bool g_completion_success; 
struct spdk_io_channel	*g_channel = NULL;



struct dif_task {

	struct iovec		*dst_iovs;

	uint32_t		dst_iovcnt;

	struct iovec		*src_iovs;

	uint32_t		src_iovcnt;

	uint32_t		num_blocks; /* used for the DIF related operations */
@@ -72,6 +74,8 @@ struct dif_task g_dif_task; 


struct accel_dif_request {

	struct spdk_io_channel *channel;

	struct iovec *dst_iovs;

	size_t dst_iovcnt;

	struct iovec *src_iovs;

	size_t src_iovcnt;

	uint32_t num_blocks;
@@ -131,6 +135,68 @@ get_dif_verify_free_bufs(struct dif_task *task) 
	return 0;

}



static int

get_dif_generate_copy_alloc_bufs(struct dif_task *task, uint32_t chained_count)

{

	int src_buff_len = g_xfer_size_bytes;

	uint32_t transfer_size_with_md;

	uint32_t i = 0;



	assert(chained_count > 0);

	task->dst_iovcnt = chained_count;

	task->dst_iovs = calloc(task->dst_iovcnt, sizeof(struct iovec));

	SPDK_CU_ASSERT_FATAL(task->dst_iovs != NULL);



	task->num_blocks = g_xfer_size_bytes / g_block_size_bytes;



	/* Add bytes for each block for metadata */

	transfer_size_with_md = g_xfer_size_bytes + (task->num_blocks * g_md_size_bytes);



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

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

		SPDK_CU_ASSERT_FATAL(task->dst_iovs[i].iov_base != NULL);



		memset(task->dst_iovs[i].iov_base, 0, transfer_size_with_md);

		task->dst_iovs[i].iov_len = transfer_size_with_md;

	}



	task->src_iovcnt = chained_count;

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

	SPDK_CU_ASSERT_FATAL(task->src_iovs != NULL);



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

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

		SPDK_CU_ASSERT_FATAL(task->src_iovs[i].iov_base != NULL);



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

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

	}



	return 0;

}



static int

get_dif_generate_copy_free_bufs(struct dif_task *task)

{

	uint32_t i = 0;



	SPDK_CU_ASSERT_FATAL(task->dst_iovs != NULL);

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

		SPDK_CU_ASSERT_FATAL(task->dst_iovs[i].iov_base != NULL);

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

	}

	free(task->dst_iovs);



	SPDK_CU_ASSERT_FATAL(task->src_iovs != NULL);

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

		SPDK_CU_ASSERT_FATAL(task->src_iovs[i].iov_base != NULL);

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

	}

	free(task->src_iovs);



	return 0;

}



static void

accel_dif_verify_test(void *arg)

{
@@ -146,6 +212,20 @@ accel_dif_verify_test(void *arg) 
	}

}



static void

accel_dif_generate_copy_test(void *arg)

{

	int rc;

	struct accel_dif_request *req = arg;



	g_completion_success = false;

	rc = spdk_accel_submit_dif_generate_copy(req->channel, req->dst_iovs, req->dst_iovcnt,

			req->src_iovs, req->src_iovcnt, req->num_blocks, req->ctx,

			req->cb_fn, req->cb_arg);

	if (rc) {

		wake_ut_thread();

	}

}



static void

accel_dif_verify_op_dif_generated_do_check(uint32_t dif_flags)
@@ -517,6 +597,318 @@ accel_dif_verify_op_reftag_init_incorrect_reftag_check(void) 
	get_dif_verify_free_bufs(task);

}



static void

accel_dif_generate_copy_op_dif_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 = get_dif_generate_copy_alloc_bufs(task, 1);

	CU_ASSERT(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,

			       g_md_size_bytes, true, true,

			       SPDK_DIF_TYPE1,

			       SPDK_DIF_FLAGS_GUARD_CHECK |

			       SPDK_DIF_FLAGS_APPTAG_CHECK |

			       SPDK_DIF_FLAGS_REFTAG_CHECK,

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

	CU_ASSERT(rc == 0);



	req.channel = g_channel;

	req.dst_iovs = task->dst_iovs;

	req.dst_iovcnt = task->dst_iovcnt;

	req.src_iovs = task->src_iovs;

	req.src_iovcnt = task->src_iovcnt;

	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_dif_generate_copy_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,

			       g_md_size_bytes, true, true,

			       SPDK_DIF_TYPE1,

			       dif_flags,

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

	CU_ASSERT(rc == 0);



	rc = spdk_dif_verify(req.dst_iovs, req.dst_iovcnt, req.num_blocks,

			     &task->dif_ctx, &err_blk);

	CU_ASSERT(rc == 0);



	get_dif_generate_copy_free_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_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_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_dif_generate_copy_op_dif_generated_no_guard_check_flag_set(void)

{

	const char *module_name = NULL;

	struct spdk_dif_ctx_init_ext_opts dif_opts;

	struct accel_dif_request req;

	struct dif_task *task = &g_dif_task;

	int rc;



	rc = spdk_accel_get_opc_module_name(SPDK_ACCEL_OPC_DIF_GENERATE_COPY, &module_name);

	CU_ASSERT(rc == 0);



	rc = get_dif_generate_copy_alloc_bufs(task, 1);

	CU_ASSERT(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,

			       g_md_size_bytes, true, true,

			       SPDK_DIF_TYPE1,

			       SPDK_DIF_FLAGS_APPTAG_CHECK |

			       SPDK_DIF_FLAGS_REFTAG_CHECK,

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

	CU_ASSERT(rc == 0);



	req.channel = g_channel;

	req.dst_iovs = task->dst_iovs;

	req.dst_iovcnt = task->dst_iovcnt;

	req.src_iovs = task->src_iovs;

	req.src_iovcnt = task->src_iovcnt;

	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_dif_generate_copy_test, &req);



	/* Intel DSA does not allow for selective DIF fields generation */

	if (!strcmp(module_name, "dsa")) {

		CU_ASSERT_EQUAL(g_completion_success, false);

	} else if (!strcmp(module_name, "software")) {

		CU_ASSERT_EQUAL(g_completion_success, true);

	} else {

		CU_ASSERT(false);

	}



	get_dif_generate_copy_free_bufs(task);

}



static void

accel_dif_generate_copy_op_dif_generated_no_apptag_check_flag_set(void)

{

	const char *module_name = NULL;

	struct spdk_dif_ctx_init_ext_opts dif_opts;

	struct accel_dif_request req;

	struct dif_task *task = &g_dif_task;

	int rc;



	rc = spdk_accel_get_opc_module_name(SPDK_ACCEL_OPC_DIF_GENERATE_COPY, &module_name);

	CU_ASSERT(rc == 0);



	rc = get_dif_generate_copy_alloc_bufs(task, 1);

	CU_ASSERT(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,

			       g_md_size_bytes, true, true,

			       SPDK_DIF_TYPE1,

			       SPDK_DIF_FLAGS_GUARD_CHECK |

			       SPDK_DIF_FLAGS_REFTAG_CHECK,

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

	CU_ASSERT(rc == 0);



	req.channel = g_channel;

	req.dst_iovs = task->dst_iovs;

	req.dst_iovcnt = task->dst_iovcnt;

	req.src_iovs = task->src_iovs;

	req.src_iovcnt = task->src_iovcnt;

	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_dif_generate_copy_test, &req);



	/* Intel DSA does not allow for selective DIF fields generation */

	if (!strcmp(module_name, "dsa")) {

		CU_ASSERT_EQUAL(g_completion_success, false);

	} else if (!strcmp(module_name, "software")) {

		CU_ASSERT_EQUAL(g_completion_success, true);

	} else {

		CU_ASSERT(false);

	}



	get_dif_generate_copy_free_bufs(task);

}



static void

accel_dif_generate_copy_op_dif_generated_no_reftag_check_flag_set(void)

{

	const char *module_name = NULL;

	struct spdk_dif_ctx_init_ext_opts dif_opts;

	struct accel_dif_request req;

	struct dif_task *task = &g_dif_task;

	int rc;



	rc = spdk_accel_get_opc_module_name(SPDK_ACCEL_OPC_DIF_GENERATE_COPY, &module_name);

	CU_ASSERT(rc == 0);



	rc = get_dif_generate_copy_alloc_bufs(task, 1);

	CU_ASSERT(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,

			       g_md_size_bytes, true, true,

			       SPDK_DIF_TYPE1,

			       SPDK_DIF_FLAGS_GUARD_CHECK |

			       SPDK_DIF_FLAGS_APPTAG_CHECK,

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

	CU_ASSERT(rc == 0);



	req.channel = g_channel;

	req.dst_iovs = task->dst_iovs;

	req.dst_iovcnt = task->dst_iovcnt;

	req.src_iovs = task->src_iovs;

	req.src_iovcnt = task->src_iovcnt;

	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_dif_generate_copy_test, &req);



	/* Intel DSA does not allow for selective DIF fields generation */

	if (!strcmp(module_name, "dsa")) {

		CU_ASSERT_EQUAL(g_completion_success, false);

	} else if (!strcmp(module_name, "software")) {

		CU_ASSERT_EQUAL(g_completion_success, true);

	} else {

		CU_ASSERT(false);

	}



	get_dif_generate_copy_free_bufs(task);

}



static void

accel_dif_generate_copy_op_iovecs_len_validate(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 = get_dif_generate_copy_alloc_bufs(task, 1);

	CU_ASSERT(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,

			       g_md_size_bytes, true, true,

			       SPDK_DIF_TYPE1,

			       SPDK_DIF_FLAGS_GUARD_CHECK |

			       SPDK_DIF_FLAGS_APPTAG_CHECK |

			       SPDK_DIF_FLAGS_REFTAG_CHECK,

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

	CU_ASSERT(rc == 0);



	req.channel = g_channel;

	req.dst_iovs = task->dst_iovs;

	/* Make iov_len param incorrect */

	req.dst_iovs->iov_len += 16;

	req.dst_iovcnt = task->dst_iovcnt;

	req.src_iovs = task->src_iovs;

	req.src_iovcnt = task->src_iovcnt;

	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_dif_generate_copy_test, &req);

	CU_ASSERT_EQUAL(g_completion_success, false);



	get_dif_generate_copy_free_bufs(task);

}



static void

accel_dif_generate_copy_op_buf_align_validate(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 = get_dif_generate_copy_alloc_bufs(task, 1);

	CU_ASSERT(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,

			       g_md_size_bytes, true, true,

			       SPDK_DIF_TYPE1,

			       SPDK_DIF_FLAGS_GUARD_CHECK |

			       SPDK_DIF_FLAGS_APPTAG_CHECK |

			       SPDK_DIF_FLAGS_REFTAG_CHECK,

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

	CU_ASSERT(rc == 0);



	req.channel = g_channel;

	req.dst_iovs = task->dst_iovs;

	req.dst_iovcnt = task->dst_iovcnt;

	req.src_iovs = task->src_iovs;

	req.src_iovcnt = task->src_iovcnt;

	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_dif_generate_copy_test, &req);

	CU_ASSERT_EQUAL(g_completion_success, true);



	get_dif_generate_copy_free_bufs(task);

}



static void

_stop_init_thread(void *arg)

{
@@ -577,7 +969,26 @@ setup_accel_tests(void) 
	    CU_add_test(suite, "verify: 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",

			accel_dif_verify_op_reftag_init_incorrect_reftag_check) == NULL) {

			accel_dif_verify_op_reftag_init_incorrect_reftag_check) == NULL ||



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

			accel_dif_generate_copy_op_dif_generated_guard_check) == NULL ||

	    CU_add_test(suite, "generate copy: DIF generated, APTTAG check",

			accel_dif_generate_copy_op_dif_generated_apptag_check) == NULL ||

	    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 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",

			accel_dif_generate_copy_op_dif_generated_no_apptag_check_flag_set) == NULL ||

	    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",

			accel_dif_generate_copy_op_iovecs_len_validate) == NULL ||

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

			accel_dif_generate_copy_op_buf_align_validate) == NULL) {

		CU_cleanup_registry();

		rc = CU_get_error();

		return -rc;