libwd/0047-uadk_tool-Optimize-sec-s-sva-benchmark-code.patch

From 44077a50fb4f259c59f86331e9ccd4a386e4b81f Mon Sep 17 00:00:00 2001
From: Longfang Liu <liulongfang@huawei.com>
Date: Fri, 10 Nov 2023 11:52:16 +0800
Subject: [PATCH 47/85] uadk_tool: Optimize sec's sva benchmark code

Update the performance test code of sec's sva mode, and optimize the
performance test code of sec's sva mode by splitting sub-functions.

Signed-off-by: Longfang Liu <liulongfang@huawei.com>
---
 uadk_tool/benchmark/sec_uadk_benchmark.c | 705 ++++++++++++++---------
 1 file changed, 443 insertions(+), 262 deletions(-)

diff --git a/uadk_tool/benchmark/sec_uadk_benchmark.c b/uadk_tool/benchmark/sec_uadk_benchmark.c
index 09cd8f4..1ea57ee 100644
--- a/uadk_tool/benchmark/sec_uadk_benchmark.c
+++ b/uadk_tool/benchmark/sec_uadk_benchmark.c
@@ -27,6 +27,7 @@ struct thread_pool {
 	u8 *iv;
 	u8 *key;
 	u8 *mac;
+	u8 *hash;
 } g_uadk_pool;
 
 typedef struct uadk_thread_res {
@@ -37,6 +38,9 @@ typedef struct uadk_thread_res {
 	u32 ivsize;
 	u32 optype;
 	u32 td_id;
+	bool is_union;
+	u32 dalg;
+	u32 dmode;
 } thread_data;
 
 static struct wd_ctx_config g_ctx_cfg;
@@ -66,8 +70,11 @@ static int sec_uadk_param_parse(thread_data *tddata, struct acc_option *options)
 {
 	u32 algtype = options->algtype;
 	u32 optype = options->optype;
+	bool is_union = false;
 	u8 keysize = 0;
 	u8 ivsize = 0;
+	u8 dmode;
+	u8 dalg;
 	u8 mode;
 	u8 alg;
 
@@ -270,6 +277,33 @@ static int sec_uadk_param_parse(thread_data *tddata, struct acc_option *options)
 		mode = WD_CIPHER_GCM;
 		alg = WD_CIPHER_AES;
 		break;
+	case AES_128_CBC_SHA256_HMAC:
+		keysize = 16;
+		ivsize = 16;
+		mode = WD_CIPHER_CBC;
+		alg = WD_CIPHER_AES;
+		is_union = true;
+		dalg = WD_DIGEST_SHA256;
+		dmode = WD_DIGEST_HMAC;
+		break;
+	case AES_192_CBC_SHA256_HMAC:
+		keysize = 24;
+		ivsize = 16;
+		mode = WD_CIPHER_CBC;
+		alg = WD_CIPHER_AES;
+		is_union = true;
+		dalg = WD_DIGEST_SHA256;
+		dmode = WD_DIGEST_HMAC;
+		break;
+	case AES_256_CBC_SHA256_HMAC:
+		keysize = 32;
+		ivsize = 16;
+		mode = WD_CIPHER_CBC;
+		alg = WD_CIPHER_AES;
+		is_union = true;
+		dalg = WD_DIGEST_SHA256;
+		dmode = WD_DIGEST_HMAC;
+		break;
 	case SM4_128_CCM:
 		keysize = 16;
 		ivsize = 16;
@@ -334,8 +368,11 @@ static int sec_uadk_param_parse(thread_data *tddata, struct acc_option *options)
 
 	tddata->alg = alg;
 	tddata->mode = mode;
+	tddata->dalg = dalg;
+	tddata->dmode = dmode;
 	tddata->ivsize = ivsize;
 	tddata->keysize = keysize;
+	tddata->is_union = is_union;
 	tddata->optype = options->optype;
 	tddata->subtype = options->subtype;
 
@@ -382,7 +419,7 @@ static int init_ctx_config(char *alg, int subtype, int mode)
 		break;
 	default:
 		SEC_TST_PRT("Fail to parse alg subtype!\n");
-		goto out;
+		return -EINVAL;
 	}
 	if (!g_sched) {
 		SEC_TST_PRT("Fail to alloc sched!\n");
@@ -416,8 +453,6 @@ static int init_ctx_config(char *alg, int subtype, int mode)
 	case DIGEST_TYPE:
 		ret = wd_digest_init(&g_ctx_cfg, g_sched);
 		break;
-	default:
-		goto out;
 	}
 	if (ret) {
 		SEC_TST_PRT("Fail to cipher ctx!\n");
@@ -471,6 +506,7 @@ static int init_uadk_bd_pool(void)
 	g_uadk_pool.iv = malloc(g_thread_num * MAX_IVK_LENTH * sizeof(char));
 	g_uadk_pool.key = malloc(g_thread_num * MAX_IVK_LENTH * sizeof(char));
 	g_uadk_pool.mac = malloc(g_thread_num * MAX_IVK_LENTH * sizeof(char));
+	g_uadk_pool.hash = malloc(g_thread_num * MAX_IVK_LENTH * sizeof(char));
 
 	g_uadk_pool.pool = malloc(g_thread_num * sizeof(struct bd_pool));
 	if (!g_uadk_pool.pool) {
@@ -523,6 +559,7 @@ malloc_error1:
 	free(g_uadk_pool.iv);
 	free(g_uadk_pool.key);
 	free(g_uadk_pool.mac);
+	free(g_uadk_pool.hash);
 
 	SEC_TST_PRT("init uadk bd pool alloc failed!\n");
 	return -ENOMEM;
@@ -601,20 +638,15 @@ recv_error:
 	return NULL;
 }
 
-static void *sec_uadk_async_run(void *arg)
+static void *sec_uadk_cipher_async(void *arg)
 {
 	thread_data *pdata = (thread_data *)arg;
 	struct wd_cipher_sess_setup cipher_setup = {0};
-	struct wd_aead_sess_setup aead_setup = {0};
-	struct wd_digest_sess_setup digest_setup = {0};
 	struct wd_cipher_req creq;
-	struct wd_aead_req areq;
-	struct wd_digest_req dreq;
 	struct bd_pool *uadk_pool;
-	u8 *priv_iv, *priv_key, *priv_mac;
+	u8 *priv_iv, *priv_key;
 	int try_cnt = 0;
 	handle_t h_sess;
-	u32 auth_size = 16;
 	u32 count = 0;
 	int ret, i = 0;
 
@@ -624,176 +656,296 @@ static void *sec_uadk_async_run(void *arg)
 	uadk_pool = &g_uadk_pool.pool[pdata->td_id];
 	priv_iv = &g_uadk_pool.iv[pdata->td_id];
 	priv_key = &g_uadk_pool.key[pdata->td_id];
-	priv_mac = &g_uadk_pool.mac[pdata->td_id];
 
 	memset(priv_iv, DEF_IVK_DATA, MAX_IVK_LENTH);
 	memset(priv_key, DEF_IVK_DATA, MAX_IVK_LENTH);
 
-	switch(pdata->subtype) {
-	case CIPHER_TYPE:
-		cipher_setup.alg = pdata->alg;
-		cipher_setup.mode = pdata->mode;
-		h_sess = wd_cipher_alloc_sess(&cipher_setup);
-		if (!h_sess)
-			return NULL;
-		ret = wd_cipher_set_key(h_sess, (const __u8*)priv_key, pdata->keysize);
-		if (ret) {
-			SEC_TST_PRT("test sec cipher set key is failed!\n");
-			wd_cipher_free_sess(h_sess);
-			return NULL;
-		}
+	cipher_setup.alg = pdata->alg;
+	cipher_setup.mode = pdata->mode;
+	h_sess = wd_cipher_alloc_sess(&cipher_setup);
+	if (!h_sess)
+		return NULL;
+	ret = wd_cipher_set_key(h_sess, (const __u8*)priv_key, pdata->keysize);
+	if (ret) {
+		SEC_TST_PRT("test sec cipher set key is failed!\n");
+		wd_cipher_free_sess(h_sess);
+		return NULL;
+	}
 
-		creq.op_type = pdata->optype;
-		creq.iv = priv_iv;
-		creq.iv_bytes = pdata->ivsize;
-		creq.in_bytes = g_pktlen;
-		creq.out_bytes = g_pktlen;
-		creq.out_buf_bytes = g_pktlen;
-		creq.data_fmt = 0;
-		creq.state = 0;
-		creq.cb = cipher_async_cb;
-
-		while(1) {
-			if (get_run_state() == 0)
-				break;
-			try_cnt = 0;
-			i = count % MAX_POOL_LENTH;
-			creq.src = uadk_pool->bds[i].src;
-			creq.dst = uadk_pool->bds[i].dst;
-
-			ret = wd_do_cipher_async(h_sess, &creq);
-			if (ret < 0) {
-				usleep(SEND_USLEEP * try_cnt);
-				try_cnt++;
-				if (try_cnt > MAX_TRY_CNT) {
-					SEC_TST_PRT("Test cipher send fail %d times!\n", MAX_TRY_CNT);
-					try_cnt = 0;
-				}
-				continue;
+	creq.op_type = pdata->optype;
+	creq.iv = priv_iv;
+	creq.iv_bytes = pdata->ivsize;
+	creq.in_bytes = g_pktlen;
+	creq.out_bytes = g_pktlen;
+	creq.out_buf_bytes = g_pktlen;
+	creq.data_fmt = 0;
+	creq.state = 0;
+	creq.cb = cipher_async_cb;
+
+	while(1) {
+		if (get_run_state() == 0)
+			break;
+		try_cnt = 0;
+		i = count % MAX_POOL_LENTH;
+		creq.src = uadk_pool->bds[i].src;
+		creq.dst = uadk_pool->bds[i].dst;
+
+		ret = wd_do_cipher_async(h_sess, &creq);
+		if (ret < 0) {
+			usleep(SEND_USLEEP * try_cnt);
+			try_cnt++;
+			if (try_cnt > MAX_TRY_CNT) {
+				SEC_TST_PRT("Test cipher send fail %d times!\n", MAX_TRY_CNT);
+				try_cnt = 0;
 			}
-			count++;
+			continue;
 		}
-		wd_cipher_free_sess(h_sess);
-		break;
-	case AEAD_TYPE: // just ccm and gcm
-		aead_setup.calg = pdata->alg;
-		aead_setup.cmode = pdata->mode;
-		h_sess = wd_aead_alloc_sess(&aead_setup);
-		if (!h_sess)
-			return NULL;
-		ret = wd_aead_set_ckey(h_sess, (const __u8*)priv_key, pdata->keysize);
-		if (ret) {
-			SEC_TST_PRT("test sec cipher set key is failed!\n");
-			wd_aead_free_sess(h_sess);
-			return NULL;
-		}
-		ret = wd_aead_set_authsize(h_sess, auth_size);
+		count++;
+	}
+	wd_cipher_free_sess(h_sess);
+
+	add_send_complete();
+
+	return NULL;
+}
+
+static void *sec_uadk_aead_async(void *arg)
+{
+	thread_data *pdata = (thread_data *)arg;
+	struct wd_aead_sess_setup aead_setup = {0};
+	u8 *priv_iv, *priv_key, *priv_mac, *priv_hash;
+	struct wd_aead_req areq;
+	struct bd_pool *uadk_pool;
+	int try_cnt = 0;
+	handle_t h_sess;
+	u32 auth_size = 16;
+	u32 count = 0;
+	int ret, i = 0;
+
+	if (pdata->td_id > g_thread_num)
+		return NULL;
+
+	uadk_pool = &g_uadk_pool.pool[pdata->td_id];
+	priv_iv = &g_uadk_pool.iv[pdata->td_id];
+	priv_key = &g_uadk_pool.key[pdata->td_id];
+	priv_mac = &g_uadk_pool.mac[pdata->td_id];
+	priv_hash = &g_uadk_pool.hash[pdata->td_id];
+
+	memset(priv_iv, DEF_IVK_DATA, MAX_IVK_LENTH);
+	memset(priv_key, DEF_IVK_DATA, MAX_IVK_LENTH);
+
+	aead_setup.calg = pdata->alg;
+	aead_setup.cmode = pdata->mode;
+	if (pdata->is_union) {
+		aead_setup.dalg = pdata->dalg;
+		aead_setup.dmode = pdata->dmode;
+	}
+	h_sess = wd_aead_alloc_sess(&aead_setup);
+	if (!h_sess)
+		return NULL;
+	ret = wd_aead_set_ckey(h_sess, (const __u8*)priv_key, pdata->keysize);
+	if (ret) {
+		SEC_TST_PRT("test sec cipher set key is failed!\n");
+		wd_aead_free_sess(h_sess);
+		return NULL;
+	}
+	if (pdata->is_union) {
+		ret = wd_aead_set_akey(h_sess, (const __u8*)priv_hash, HASH_ZISE);
 		if (ret) {
-			SEC_TST_PRT("set auth size fail, authsize: 16\n");
+			SEC_TST_PRT("test sec aead set akey is failed!\n");
 			wd_aead_free_sess(h_sess);
 			return NULL;
 		}
+	}
+	ret = wd_aead_set_authsize(h_sess, auth_size);
+	if (ret) {
+		SEC_TST_PRT("set auth size fail, authsize: 16\n");
+		wd_aead_free_sess(h_sess);
+		return NULL;
+	}
+
+	areq.op_type = pdata->optype;
+	areq.iv = priv_iv; // aead IV need update with param
+	areq.mac = priv_mac;
+	areq.iv_bytes = pdata->ivsize;
+	areq.mac_bytes = auth_size;
+	areq.assoc_bytes = 16;
+	areq.in_bytes = g_pktlen;
+	if (pdata->is_union)
+		areq.mac_bytes = 32;
+	if (areq.op_type) // decrypto
+		areq.out_bytes = g_pktlen + 16; // aadsize = 16;
+	else
+		areq.out_bytes = g_pktlen + 32; // aadsize + authsize = 32;
+
+	areq.data_fmt = 0;
+	areq.state = 0;
+	areq.cb = aead_async_cb;
 
-		areq.op_type = pdata->optype;
-		areq.iv = priv_iv; // aead IV need update with param
-		areq.mac = priv_mac;
-		areq.iv_bytes = pdata->ivsize;
-		areq.mac_bytes = auth_size;
-		areq.assoc_bytes = 16;
-		areq.in_bytes = g_pktlen;
-		if (areq.op_type)// decrypto
-			areq.out_bytes = g_pktlen + 16; // aadsize = 16;
-		else
-			areq.out_bytes = g_pktlen + 32; // aadsize + authsize = 32;
-
-		areq.data_fmt = 0;
-		areq.state = 0;
-		areq.cb = aead_async_cb;
-
-		while(1) {
-			if (get_run_state() == 0)
-				break;
-			try_cnt = 0;
-			i = count % MAX_POOL_LENTH;
-			areq.src = uadk_pool->bds[i].src;
-			areq.dst = uadk_pool->bds[i].dst;
-
-			ret = wd_do_aead_async(h_sess, &areq);
-			if (ret < 0) {
-				usleep(SEND_USLEEP * try_cnt);
-				try_cnt++;
-				if (try_cnt > MAX_TRY_CNT) {
-					SEC_TST_PRT("Test aead send fail %d times!\n", MAX_TRY_CNT);
-					try_cnt = 0;
-				}
-				continue;
+	while(1) {
+		if (get_run_state() == 0)
+			break;
+		try_cnt = 0;
+		i = count % MAX_POOL_LENTH;
+		areq.src = uadk_pool->bds[i].src;
+		areq.dst = uadk_pool->bds[i].dst;
+
+		ret = wd_do_aead_async(h_sess, &areq);
+		if (ret < 0) {
+			usleep(SEND_USLEEP * try_cnt);
+			try_cnt++;
+			if (try_cnt > MAX_TRY_CNT) {
+				SEC_TST_PRT("Test aead send fail %d times!\n", MAX_TRY_CNT);
+				try_cnt = 0;
 			}
-			count++;
+			continue;
 		}
-		wd_aead_free_sess(h_sess);
-		break;
-	case DIGEST_TYPE:
-		digest_setup.alg = pdata->alg;
-		digest_setup.mode = pdata->mode; // digest mode is optype
-		h_sess = wd_digest_alloc_sess(&digest_setup);
-		if (!h_sess)
+		count++;
+	}
+	wd_aead_free_sess(h_sess);
+
+	add_send_complete();
+
+	return NULL;
+}
+
+static void *sec_uadk_digest_async(void *arg)
+{
+	thread_data *pdata = (thread_data *)arg;
+	struct wd_digest_sess_setup digest_setup = {0};
+	struct wd_digest_req dreq;
+	struct bd_pool *uadk_pool;
+	u8 *priv_iv, *priv_key;
+	int try_cnt = 0;
+	handle_t h_sess;
+	u32 count = 0;
+	int ret, i = 0;
+
+	if (pdata->td_id > g_thread_num)
+		return NULL;
+
+	uadk_pool = &g_uadk_pool.pool[pdata->td_id];
+	priv_iv = &g_uadk_pool.iv[pdata->td_id];
+	priv_key = &g_uadk_pool.key[pdata->td_id];
+
+	memset(priv_iv, DEF_IVK_DATA, MAX_IVK_LENTH);
+	memset(priv_key, DEF_IVK_DATA, MAX_IVK_LENTH);
+
+	digest_setup.alg = pdata->alg;
+	digest_setup.mode = pdata->mode; // digest mode is optype
+	h_sess = wd_digest_alloc_sess(&digest_setup);
+	if (!h_sess)
+		return NULL;
+	if (digest_setup.mode == WD_DIGEST_HMAC) {
+		ret = wd_digest_set_key(h_sess, (const __u8*)priv_key, 4);
+		if (ret) {
+			SEC_TST_PRT("test sec digest set key is failed!\n");
+			wd_digest_free_sess(h_sess);
 			return NULL;
-		if (digest_setup.mode == WD_DIGEST_HMAC) {
-			ret = wd_digest_set_key(h_sess, (const __u8*)priv_key, 4);
-			if (ret) {
-				SEC_TST_PRT("test sec digest set key is failed!\n");
-				wd_digest_free_sess(h_sess);
-				return NULL;
-			}
 		}
-		dreq.in_bytes = g_pktlen;
-		dreq.out_bytes = 16;
-		dreq.out_buf_bytes = 16;
-		dreq.data_fmt = 0;
-		dreq.state = 0;
-		dreq.has_next = 0;
-		dreq.cb = digest_async_cb;
-
-		while(1) {
-			if (get_run_state() == 0)
-				break;
-			try_cnt = 0;
-			i = count % MAX_POOL_LENTH;
-			dreq.in = uadk_pool->bds[i].src;
-			dreq.out = uadk_pool->bds[i].dst;
-
-			ret = wd_do_digest_async(h_sess, &dreq);
-			if (ret < 0) {
-				usleep(SEND_USLEEP * try_cnt);
-				try_cnt++;
-				if (try_cnt > MAX_TRY_CNT) {
-					SEC_TST_PRT("Test digest send fail %d times!\n", MAX_TRY_CNT);
-					try_cnt = 0;
-				}
-				continue;
+	}
+	dreq.in_bytes = g_pktlen;
+	dreq.out_bytes = 16;
+	dreq.out_buf_bytes = 16;
+	dreq.data_fmt = 0;
+	dreq.state = 0;
+	dreq.has_next = 0;
+	dreq.cb = digest_async_cb;
+
+	while(1) {
+		if (get_run_state() == 0)
+			break;
+		try_cnt = 0;
+		i = count % MAX_POOL_LENTH;
+		dreq.in = uadk_pool->bds[i].src;
+		dreq.out = uadk_pool->bds[i].dst;
+
+		ret = wd_do_digest_async(h_sess, &dreq);
+		if (ret < 0) {
+			usleep(SEND_USLEEP * try_cnt);
+			try_cnt++;
+			if (try_cnt > MAX_TRY_CNT) {
+				SEC_TST_PRT("Test digest send fail %d times!\n", MAX_TRY_CNT);
+				try_cnt = 0;
 			}
-			count++;
+			continue;
 		}
-		wd_digest_free_sess(h_sess);
-		break;
+		count++;
 	}
+	wd_digest_free_sess(h_sess);
 
 	add_send_complete();
 
 	return NULL;
 }
 
-static void *sec_uadk_sync_run(void *arg)
+static void *sec_uadk_cipher_sync(void *arg)
 {
 	thread_data *pdata = (thread_data *)arg;
 	struct wd_cipher_sess_setup cipher_setup = {0};
-	struct wd_aead_sess_setup aead_setup = {0};
-	struct wd_digest_sess_setup digest_setup = {0};
 	struct wd_cipher_req creq;
+	struct bd_pool *uadk_pool;
+	u8 *priv_iv, *priv_key;
+	handle_t h_sess;
+	u32 count = 0;
+	int ret, i = 0;
+
+	if (pdata->td_id > g_thread_num)
+		return NULL;
+
+	uadk_pool = &g_uadk_pool.pool[pdata->td_id];
+	priv_iv = &g_uadk_pool.iv[pdata->td_id];
+	priv_key = &g_uadk_pool.key[pdata->td_id];
+
+	memset(priv_iv, DEF_IVK_DATA, MAX_IVK_LENTH);
+	memset(priv_key, DEF_IVK_DATA, MAX_IVK_LENTH);
+
+	cipher_setup.alg = pdata->alg;
+	cipher_setup.mode = pdata->mode;
+	h_sess = wd_cipher_alloc_sess(&cipher_setup);
+	if (!h_sess)
+		return NULL;
+	ret = wd_cipher_set_key(h_sess, (const __u8*)priv_key, pdata->keysize);
+	if (ret) {
+		SEC_TST_PRT("test sec cipher set key is failed!\n");
+		wd_cipher_free_sess(h_sess);
+		return NULL;
+	}
+
+	creq.op_type = pdata->optype;
+	creq.iv = priv_iv;
+	creq.iv_bytes = pdata->ivsize;
+	creq.in_bytes = g_pktlen;
+	creq.out_bytes = g_pktlen;
+	creq.out_buf_bytes = g_pktlen;
+	creq.data_fmt = 0;
+	creq.state = 0;
+
+	while(1) {
+		i = count % MAX_POOL_LENTH;
+		creq.src = uadk_pool->bds[i].src;
+		creq.dst = uadk_pool->bds[i].dst;
+		ret = wd_do_cipher_sync(h_sess, &creq);
+		if ((ret < 0 && ret != -WD_EBUSY) || creq.state)
+			break;
+		count++;
+		if (get_run_state() == 0)
+			break;
+	}
+	wd_cipher_free_sess(h_sess);
+
+	add_recv_data(count, g_pktlen);
+
+	return NULL;
+}
+
+static void *sec_uadk_aead_sync(void *arg)
+{
+	thread_data *pdata = (thread_data *)arg;
+	struct wd_aead_sess_setup aead_setup = {0};
+	u8 *priv_iv, *priv_key, *priv_mac, *priv_hash;
 	struct wd_aead_req areq;
-	struct wd_digest_req dreq;
 	struct bd_pool *uadk_pool;
-	u8 *priv_iv, *priv_key, *priv_mac;
 	handle_t h_sess;
 	u32 auth_size = 16;
 	u32 count = 0;
@@ -806,129 +958,130 @@ static void *sec_uadk_sync_run(void *arg)
 	priv_iv = &g_uadk_pool.iv[pdata->td_id];
 	priv_key = &g_uadk_pool.key[pdata->td_id];
 	priv_mac = &g_uadk_pool.mac[pdata->td_id];
+	priv_hash = &g_uadk_pool.hash[pdata->td_id];
 
 	memset(priv_iv, DEF_IVK_DATA, MAX_IVK_LENTH);
 	memset(priv_key, DEF_IVK_DATA, MAX_IVK_LENTH);
 
-	switch(pdata->subtype) {
-	case CIPHER_TYPE:
-		cipher_setup.alg = pdata->alg;
-		cipher_setup.mode = pdata->mode;
-		h_sess = wd_cipher_alloc_sess(&cipher_setup);
-		if (!h_sess)
-			return NULL;
-		ret = wd_cipher_set_key(h_sess, (const __u8*)priv_key, pdata->keysize);
-		if (ret) {
-			SEC_TST_PRT("test sec cipher set key is failed!\n");
-			wd_cipher_free_sess(h_sess);
-			return NULL;
-		}
-
-		creq.op_type = pdata->optype;
-		creq.iv = priv_iv;
-		creq.iv_bytes = pdata->ivsize;
-		creq.in_bytes = g_pktlen;
-		creq.out_bytes = g_pktlen;
-		creq.out_buf_bytes = g_pktlen;
-		creq.data_fmt = 0;
-		creq.state = 0;
-
-		while(1) {
-			i = count % MAX_POOL_LENTH;
-			creq.src = uadk_pool->bds[i].src;
-			creq.dst = uadk_pool->bds[i].dst;
-			ret = wd_do_cipher_sync(h_sess, &creq);
-			if ((ret < 0 && ret != -WD_EBUSY) || creq.state)
-				break;
-			count++;
-			if (get_run_state() == 0)
-				break;
-		}
-		wd_cipher_free_sess(h_sess);
-		break;
-	case AEAD_TYPE: // just ccm and gcm
-		aead_setup.calg = pdata->alg;
-		aead_setup.cmode = pdata->mode;
-		h_sess = wd_aead_alloc_sess(&aead_setup);
-		if (!h_sess)
-			return NULL;
-		ret = wd_aead_set_ckey(h_sess, (const __u8*)priv_key, pdata->keysize);
-		if (ret) {
-			SEC_TST_PRT("test sec cipher set key is failed!\n");
-			wd_aead_free_sess(h_sess);
-			return NULL;
-		}
-		ret = wd_aead_set_authsize(h_sess, auth_size);
+	aead_setup.calg = pdata->alg;
+	aead_setup.cmode = pdata->mode;
+	if (pdata->is_union) {
+		aead_setup.dalg = WD_DIGEST_SHA256;
+		aead_setup.dmode = WD_DIGEST_HMAC;
+	}
+	h_sess = wd_aead_alloc_sess(&aead_setup);
+	if (!h_sess)
+		return NULL;
+	ret = wd_aead_set_ckey(h_sess, (const __u8*)priv_key, pdata->keysize);
+	if (ret) {
+		SEC_TST_PRT("test sec cipher set key is failed!\n");
+		wd_aead_free_sess(h_sess);
+		return NULL;
+	}
+	if (pdata->is_union) {
+		ret = wd_aead_set_akey(h_sess, (const __u8*)priv_hash, HASH_ZISE);
 		if (ret) {
-			SEC_TST_PRT("set auth size fail, authsize: 16\n");
+			SEC_TST_PRT("test sec aead set akey is failed!\n");
 			wd_aead_free_sess(h_sess);
 			return NULL;
 		}
-
-		areq.op_type = pdata->optype;
-		areq.iv = priv_iv; // aead IV need update with param
-		areq.mac = priv_mac;
-		areq.mac_bytes = 16;
-		areq.iv_bytes = pdata->ivsize;
-		areq.assoc_bytes = 16;
-		areq.in_bytes = g_pktlen;
-		areq.mac_bytes = auth_size;
-		if (areq.op_type)// decrypto
-			areq.out_bytes = g_pktlen + 16; // aadsize = 16;
-		else
-			areq.out_bytes = g_pktlen + 32; // aadsize + authsize = 32;
-
-		areq.data_fmt = 0;
-		areq.state = 0;
-
-		while(1) {
-			i = count % MAX_POOL_LENTH;
-			areq.src = uadk_pool->bds[i].src;
-			areq.dst = uadk_pool->bds[i].dst;
-			count++;
-			ret = wd_do_aead_sync(h_sess, &areq);
-			if (ret || areq.state)
-				break;
-			if (get_run_state() == 0)
-				break;
-		}
+	}
+	ret = wd_aead_set_authsize(h_sess, auth_size);
+	if (ret) {
+		SEC_TST_PRT("set auth size fail, authsize: 16\n");
 		wd_aead_free_sess(h_sess);
-		break;
-	case DIGEST_TYPE:
-		digest_setup.alg = pdata->alg;
-		digest_setup.mode = pdata->mode; // digest mode is optype
-		h_sess = wd_digest_alloc_sess(&digest_setup);
-		if (!h_sess)
+		return NULL;
+	}
+
+	areq.op_type = pdata->optype;
+	areq.iv = priv_iv; // aead IV need update with param
+	areq.mac = priv_mac;
+	areq.mac_bytes = 16;
+	areq.iv_bytes = pdata->ivsize;
+	areq.assoc_bytes = 16;
+	areq.in_bytes = g_pktlen;
+	areq.mac_bytes = auth_size;
+	if (pdata->is_union)
+		areq.mac_bytes = 32;
+	if (areq.op_type) // decrypto
+		areq.out_bytes = g_pktlen + 16; // aadsize = 16;
+	else
+		areq.out_bytes = g_pktlen + 32; // aadsize + authsize = 32;
+
+	areq.data_fmt = 0;
+	areq.state = 0;
+
+	while(1) {
+		i = count % MAX_POOL_LENTH;
+		areq.src = uadk_pool->bds[i].src;
+		areq.dst = uadk_pool->bds[i].dst;
+		count++;
+		ret = wd_do_aead_sync(h_sess, &areq);
+		if (ret || areq.state)
+			break;
+		if (get_run_state() == 0)
+			break;
+	}
+	wd_aead_free_sess(h_sess);
+
+	add_recv_data(count, g_pktlen);
+
+	return NULL;
+}
+
+static void *sec_uadk_digest_sync(void *arg)
+{
+	thread_data *pdata = (thread_data *)arg;
+	struct wd_digest_sess_setup digest_setup = {0};
+	struct wd_digest_req dreq;
+	struct bd_pool *uadk_pool;
+	u8 *priv_iv, *priv_key;
+	handle_t h_sess;
+	u32 count = 0;
+	int ret, i = 0;
+
+	if (pdata->td_id > g_thread_num)
+		return NULL;
+
+	uadk_pool = &g_uadk_pool.pool[pdata->td_id];
+	priv_iv = &g_uadk_pool.iv[pdata->td_id];
+	priv_key = &g_uadk_pool.key[pdata->td_id];
+
+	memset(priv_iv, DEF_IVK_DATA, MAX_IVK_LENTH);
+	memset(priv_key, DEF_IVK_DATA, MAX_IVK_LENTH);
+
+	digest_setup.alg = pdata->alg;
+	digest_setup.mode = pdata->mode; // digest mode is optype
+	h_sess = wd_digest_alloc_sess(&digest_setup);
+	if (!h_sess)
+		return NULL;
+	if (digest_setup.mode == WD_DIGEST_HMAC) {
+		ret = wd_digest_set_key(h_sess, (const __u8*)priv_key, 4);
+		if (ret) {
+			SEC_TST_PRT("test sec digest set key is failed!\n");
+			wd_digest_free_sess(h_sess);
 			return NULL;
-		if (digest_setup.mode == WD_DIGEST_HMAC) {
-			ret = wd_digest_set_key(h_sess, (const __u8*)priv_key, 4);
-			if (ret) {
-				SEC_TST_PRT("test sec digest set key is failed!\n");
-				wd_digest_free_sess(h_sess);
-				return NULL;
-			}
 		}
-		dreq.in_bytes = g_pktlen;
-		dreq.out_bytes = 16;
-		dreq.out_buf_bytes = 16;
-		dreq.data_fmt = 0;
-		dreq.state = 0;
-		dreq.has_next = 0;
-
-		while(1) {
-			i = count % MAX_POOL_LENTH;
-			dreq.in = uadk_pool->bds[i].src;
-			dreq.out = uadk_pool->bds[i].dst;
-			ret = wd_do_digest_sync(h_sess, &dreq);
-			if (ret || dreq.state)
-				break;
-			count++;
-			if (get_run_state() == 0)
-				break;
-		}
-		wd_digest_free_sess(h_sess);
-		break;
 	}
+	dreq.in_bytes = g_pktlen;
+	dreq.out_bytes = 16;
+	dreq.out_buf_bytes = 16;
+	dreq.data_fmt = 0;
+	dreq.state = 0;
+	dreq.has_next = 0;
+
+	while(1) {
+		i = count % MAX_POOL_LENTH;
+		dreq.in = uadk_pool->bds[i].src;
+		dreq.out = uadk_pool->bds[i].dst;
+		ret = wd_do_digest_sync(h_sess, &dreq);
+		if (ret || dreq.state)
+			break;
+		count++;
+		if (get_run_state() == 0)
+			break;
+	}
+	wd_digest_free_sess(h_sess);
 
 	add_recv_data(count, g_pktlen);
 
@@ -937,6 +1090,8 @@ static void *sec_uadk_sync_run(void *arg)
 
 int sec_uadk_sync_threads(struct acc_option *options)
 {
+	typedef void *(*sec_sync_run)(void *arg);
+	sec_sync_run uadk_sec_sync_run = NULL;
 	thread_data threads_args[THREADS_NUM];
 	thread_data threads_option;
 	pthread_t tdid[THREADS_NUM];
@@ -947,6 +1102,18 @@ int sec_uadk_sync_threads(struct acc_option *options)
 	if (ret)
 		return ret;
 
+	switch (options->subtype) {
+	case CIPHER_TYPE:
+		uadk_sec_sync_run = sec_uadk_cipher_sync;
+		break;
+	case AEAD_TYPE:
+		uadk_sec_sync_run = sec_uadk_aead_sync;
+		break;
+	case DIGEST_TYPE:
+		uadk_sec_sync_run = sec_uadk_digest_sync;
+		break;
+	}
+
 	for (i = 0; i < g_thread_num; i++) {
 		threads_args[i].subtype = threads_option.subtype;
 		threads_args[i].alg = threads_option.alg;
@@ -955,7 +1122,7 @@ int sec_uadk_sync_threads(struct acc_option *options)
 		threads_args[i].ivsize = threads_option.ivsize;
 		threads_args[i].optype = threads_option.optype;
 		threads_args[i].td_id = i;
-		ret = pthread_create(&tdid[i], NULL, sec_uadk_sync_run, &threads_args[i]);
+		ret = pthread_create(&tdid[i], NULL, uadk_sec_sync_run, &threads_args[i]);
 		if (ret) {
 			SEC_TST_PRT("Create sync thread fail!\n");
 			goto sync_error;
@@ -977,6 +1144,8 @@ sync_error:
 
 int sec_uadk_async_threads(struct acc_option *options)
 {
+	typedef void *(*sec_async_run)(void *arg);
+	sec_async_run uadk_sec_async_run = NULL;
 	thread_data threads_args[THREADS_NUM];
 	thread_data threads_option;
 	pthread_t tdid[THREADS_NUM];
@@ -988,6 +1157,18 @@ int sec_uadk_async_threads(struct acc_option *options)
 	if (ret)
 		return ret;
 
+	switch (options->subtype) {
+	case CIPHER_TYPE:
+		uadk_sec_async_run = sec_uadk_cipher_async;
+		break;
+	case AEAD_TYPE:
+		uadk_sec_async_run = sec_uadk_aead_async;
+		break;
+	case DIGEST_TYPE:
+		uadk_sec_async_run = sec_uadk_digest_async;
+		break;
+	}
+
 	for (i = 0; i < g_ctxnum; i++) {
 		threads_args[i].subtype = threads_option.subtype;
 		threads_args[i].td_id = i;
@@ -1007,7 +1188,7 @@ int sec_uadk_async_threads(struct acc_option *options)
 		threads_args[i].ivsize = threads_option.ivsize;
 		threads_args[i].optype = threads_option.optype;
 		threads_args[i].td_id = i;
-		ret = pthread_create(&tdid[i], NULL, sec_uadk_async_run, &threads_args[i]);
+		ret = pthread_create(&tdid[i], NULL, uadk_sec_async_run, &threads_args[i]);
 		if (ret) {
 			SEC_TST_PRT("Create async thread fail!\n");
 			goto async_error;
-- 
2.25.1