From: Weili Qian qianweili@huawei.com

wd_rsa_del_kg_out() clears the data before freeing the memory. Therefore, no additional memset zero is required before calling wd_rsa_del_kg_out().

Signed-off-by: Weili Qian qianweili@huawei.com --- uadk_tool/benchmark/hpre_uadk_benchmark.c | 10 ---------- 1 file changed, 10 deletions(-)

diff --git a/uadk_tool/benchmark/hpre_uadk_benchmark.c b/uadk_tool/benchmark/hpre_uadk_benchmark.c index e722c36..eaa8408 100644 --- a/uadk_tool/benchmark/hpre_uadk_benchmark.c +++ b/uadk_tool/benchmark/hpre_uadk_benchmark.c @@ -1316,16 +1316,6 @@ static void *rsa_uadk_async_run(void *arg)

/* clean output buffer remainings in the last time operation */ if (req.op_type == WD_RSA_GENKEY) { - char *data; - int len; - - len = wd_rsa_kg_out_data((void *)req.dst, &data); - if (len < 0) { - HPRE_TST_PRT("failed to wd rsa get key gen out data!\n"); - goto tag_release; - } - memset(data, 0, len); - wd_rsa_del_kg_in(h_sess, req.src); req.src = NULL; wd_rsa_del_kg_out(h_sess, req.dst);

From: Weili Qian qianweili@huawei.com

In asynchronous scenarios, call wd_do_rsa_async() instead of wd_do_rsa_sync().

Signed-off-by: Weili Qian qianweili@huawei.com --- uadk_tool/benchmark/hpre_uadk_benchmark.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/uadk_tool/benchmark/hpre_uadk_benchmark.c b/uadk_tool/benchmark/hpre_uadk_benchmark.c index 9d89f7e..653232f 100644 --- a/uadk_tool/benchmark/hpre_uadk_benchmark.c +++ b/uadk_tool/benchmark/hpre_uadk_benchmark.c @@ -2211,7 +2211,7 @@ static void *ecc_uadk_async_run(void *arg) tag[i].sess = h_sess; req.cb_param = &tag[i];

- ret = wd_do_ecc_sync(h_sess, &req); + ret = wd_do_ecc_async(h_sess, &req); if (ret == -WD_EBUSY) { usleep(SEND_USLEEP * try_cnt); try_cnt++;

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;

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

Signed-off-by: Longfang Liu liulongfang@huawei.com --- uadk_tool/benchmark/sec_soft_benchmark.c | 876 +++++++++++++++-------- 1 file changed, 590 insertions(+), 286 deletions(-)

diff --git a/uadk_tool/benchmark/sec_soft_benchmark.c b/uadk_tool/benchmark/sec_soft_benchmark.c index a622329..ea84393 100644 --- a/uadk_tool/benchmark/sec_soft_benchmark.c +++ b/uadk_tool/benchmark/sec_soft_benchmark.c @@ -1,7 +1,6 @@ /* SPDX-License-Identifier: Apache-2.0 */

-#include "sec_soft_benchmark.h" - +#define _GNU_SOURCE #include <openssl/async.h> #include <openssl/bn.h> #include <openssl/crypto.h> @@ -15,8 +14,10 @@

#include "include/wd_cipher.h" #include "include/wd_digest.h" +#include "sec_soft_benchmark.h"

#define SSL_TST_PRT printf +#define ENV_STRING_LEN 256

struct soft_bd { u8 *src; @@ -36,31 +37,40 @@ struct thread_pool { typedef struct soft_thread_res { const EVP_CIPHER *evp_cipher; const EVP_MD *evp_md; + ENGINE *engine; u32 subtype; u32 mode; u32 keysize; u32 optype; u32 td_id; u32 engine_flag; + u32 sync_mode; } soft_thread;

typedef struct soft_jobs_res { const EVP_CIPHER *evp_cipher; const EVP_MD *evp_md; + ENGINE *engine; u32 subtype; u32 mode; u32 keysize; u32 optype; u32 td_id; u32 jobid; - u32 use_engine; } jobs_data;

+typedef struct soft_loop_args { + ASYNC_JOB *in_job; + ASYNC_WAIT_CTX *wait_ctx; + bool job_valid; +} jobs_args; + #define MAX_IVK_LENTH 64 #define DEF_IVK_DATA 0xAA +#define MAX_JOBS_NUM MAX_CTX_NUM

static unsigned int g_thread_num; -static unsigned int g_ctxnum; +static unsigned int g_jobsnum; static unsigned int g_pktlen;

static int init_soft_bd_pool(void) @@ -100,7 +110,6 @@ static int init_soft_bd_pool(void) goto malloc_error3;

get_rand_data(g_soft_pool.pool[i].bds[j].src, fill_size); - //get_rand_data(g_soft_pool.pool[i].bds[j].dst, 16); } } } @@ -330,6 +339,21 @@ static int sec_soft_param_parse(soft_thread *tddata, struct acc_option *options) mode = WD_CIPHER_GCM; tddata->evp_cipher = EVP_aes_256_gcm(); break; + case AES_128_CBC_SHA256_HMAC: + keysize = 16; + mode = WD_CIPHER_CBC; + tddata->evp_cipher = EVP_aes_128_cbc(); + break; + case AES_192_CBC_SHA256_HMAC: + keysize = 24; + mode = WD_CIPHER_CBC; + tddata->evp_cipher = EVP_aes_192_cbc(); + break; + case AES_256_CBC_SHA256_HMAC: + keysize = 32; + mode = WD_CIPHER_CBC; + tddata->evp_cipher = EVP_aes_256_cbc(); + break; case SM4_128_CCM: keysize = 16; mode = WD_CIPHER_CCM; @@ -396,25 +420,18 @@ static int sec_soft_param_parse(soft_thread *tddata, struct acc_option *options) return 0; }

-static int sec_soft_jobfunc(void *args) +static int sec_soft_cipher_jobfunc(void *args) { jobs_data *jdata = (jobs_data *)args; const EVP_CIPHER *evp_cipher = jdata->evp_cipher; - const EVP_MD *evp_md = jdata->evp_md; u32 optype = jdata->optype; u32 jid = jdata->jobid; struct bd_pool *soft_pool; u8 *priv_iv, *priv_key; int ret, outl, i = 0; EVP_CIPHER_CTX *ctx; - EVP_MD_CTX *md_ctx; - HMAC_CTX *hm_ctx; ASYNC_JOB *currjob; - u8 faketag[16] = {0xcc}; - u8 aad[13] = {0xcc}; - u8 tag[12] = {0}; - u8 mac[EVP_MAX_MD_SIZE] = {0x00}; - u32 ssl_size = 0; + u32 count = 0; u8 *src, *dst;

currjob = ASYNC_get_current_job(); @@ -423,7 +440,7 @@ static int sec_soft_jobfunc(void *args) return 0; }

- if (!evp_cipher && !evp_md) { + if (!evp_cipher) { SSL_TST_PRT("Error: openssl not support!\n"); return 0; } @@ -438,50 +455,103 @@ static int sec_soft_jobfunc(void *args) memset(priv_iv, DEF_IVK_DATA, MAX_IVK_LENTH); memset(priv_key, DEF_IVK_DATA, MAX_IVK_LENTH);

- switch(jdata->subtype) { - case CIPHER_TYPE: - ctx = EVP_CIPHER_CTX_new(); - if (!ctx) - return 0; + ctx = EVP_CIPHER_CTX_new(); + if (!ctx) + return 0;

- EVP_CIPHER_CTX_set_padding(ctx, 0); - - ret = EVP_CipherInit_ex(ctx, evp_cipher, NULL, priv_key, priv_iv, optype); - if (ret != 1) { - SSL_TST_PRT("Error: EVP_CipherInit_ex fail ret: %d\n", ret); - break; - } + EVP_CIPHER_CTX_init(ctx);

+ while (1) { i = jid % MAX_POOL_LENTH; src = soft_pool->bds[i].src; dst = soft_pool->bds[i].dst; - if (optype) - ret = EVP_DecryptUpdate(ctx, dst, &outl, src, g_pktlen); - else - ret = EVP_EncryptUpdate(ctx, dst, &outl, src, g_pktlen); - if (ret != 1) - EVP_CipherInit_ex(ctx, NULL, NULL, NULL, priv_iv, -1);

- if (optype) + if (optype) { + ret = EVP_DecryptInit_ex(ctx, evp_cipher, jdata->engine, priv_key, priv_iv); + if (ret != 1) + break; + + ret = EVP_DecryptUpdate(ctx, dst, &outl, src, g_pktlen); + if (ret != 1) + break; + EVP_CIPHER_CTX_set_padding(ctx, EVP_PADDING_ZERO); EVP_DecryptFinal_ex(ctx, dst, &outl); - else + } else { + ret = EVP_EncryptInit_ex(ctx, evp_cipher, jdata->engine, priv_key, priv_iv); + if (ret != 1) + break; + + ret = EVP_EncryptUpdate(ctx, dst, &outl, src, g_pktlen); + if (ret != 1) + break; + EVP_CIPHER_CTX_set_padding(ctx, EVP_PADDING_ZERO); EVP_EncryptFinal_ex(ctx, dst, &outl); + }

- EVP_CIPHER_CTX_free(ctx); - break; - case AEAD_TYPE: - ctx = EVP_CIPHER_CTX_new(); - if (!ctx) - return 0; + count++; + if (get_run_state() == 0) + break; + }

- EVP_CIPHER_CTX_set_padding(ctx, 0); + EVP_CIPHER_CTX_cleanup(ctx); + EVP_CIPHER_CTX_free(ctx);

- ret = EVP_CipherInit_ex(ctx, evp_cipher, NULL, priv_key, priv_iv, optype); - if (ret != 1) { - SSL_TST_PRT("Error: AEAD EVP_CipherInit_ex fail ret: %d\n", ret); - break; - } + add_recv_data(count, g_pktlen);

+ return 0; +} + +static int sec_soft_aead_jobfunc(void *args) +{ + jobs_data *jdata = (jobs_data *)args; + const EVP_CIPHER *evp_cipher = jdata->evp_cipher; + u32 optype = jdata->optype; + u32 jid = jdata->jobid; + struct bd_pool *soft_pool; + u8 *priv_iv, *priv_key; + int ret, outl, i = 0; + EVP_CIPHER_CTX *ctx; + ASYNC_JOB *currjob; + u8 faketag[16] = {0xcc}; + u8 aad[13] = {0xcc}; + u8 tag[12] = {0}; + u32 count = 0; + u8 *src, *dst; + + currjob = ASYNC_get_current_job(); + if (!currjob) { + SSL_TST_PRT("Error: not executing within a job\n"); + return 0; + } + + if (!evp_cipher) { + SSL_TST_PRT("Error: openssl not support!\n"); + return 0; + } + + if (jdata->td_id > g_thread_num) + return 0; + + soft_pool = &g_soft_pool.pool[jdata->td_id]; + priv_iv = &g_soft_pool.iv[jdata->td_id]; + priv_key = &g_soft_pool.key[jdata->td_id]; + + memset(priv_iv, DEF_IVK_DATA, MAX_IVK_LENTH); + memset(priv_key, DEF_IVK_DATA, MAX_IVK_LENTH); + + ctx = EVP_CIPHER_CTX_new(); + if (!ctx) + return 0; + + EVP_CIPHER_CTX_set_padding(ctx, 0); + + ret = EVP_CipherInit_ex(ctx, evp_cipher, NULL, priv_key, priv_iv, optype); + if (ret != 1) { + SSL_TST_PRT("Error: AEAD EVP_CipherInit_ex fail ret: %d\n", ret); + return 0; + } + + while (1) { if (jdata->mode == WD_CIPHER_CCM) { i = jid % MAX_POOL_LENTH; src = soft_pool->bds[i].src; @@ -520,53 +590,109 @@ static int sec_soft_jobfunc(void *args) EVP_DecryptFinal_ex(ctx, dst + outl, &outl); } } - EVP_CIPHER_CTX_free(ctx); + count++; + if (get_run_state() == 0) + break; + } + EVP_CIPHER_CTX_free(ctx);

- break; - case DIGEST_TYPE: - if (!optype) { //normal mode - md_ctx = EVP_MD_CTX_new(); - if (!md_ctx) - return 0; + add_recv_data(count, g_pktlen); + + return 0; +} + +static int sec_soft_digest_jobfunc(void *args) +{ + jobs_data *jdata = (jobs_data *)args; + const EVP_MD *evp_md = jdata->evp_md; + u32 optype = jdata->optype; + u32 jid = jdata->jobid; + struct bd_pool *soft_pool; + u8 mac[EVP_MAX_MD_SIZE] = {0x00}; + EVP_MD_CTX *md_ctx; + HMAC_CTX *hm_ctx; + ASYNC_JOB *currjob; + u32 ssl_size = 0; + u8 *priv_key, *src; + u32 count = 0; + int i = 0; + + currjob = ASYNC_get_current_job(); + if (!currjob) { + SSL_TST_PRT("Error: not executing within a job\n"); + return 0; + } + + if (!evp_md) { + SSL_TST_PRT("Error: openssl not support!\n"); + return 0; + }

+ if (jdata->td_id > g_thread_num) + return 0; + + soft_pool = &g_soft_pool.pool[jdata->td_id]; + priv_key = &g_soft_pool.key[jdata->td_id]; + + memset(priv_key, DEF_IVK_DATA, MAX_IVK_LENTH); + + if (!optype) { //normal mode + md_ctx = EVP_MD_CTX_new(); + if (!md_ctx) + return 0; + + while (1) { i = jid % MAX_POOL_LENTH; src = soft_pool->bds[i].src;

- EVP_DigestInit_ex(md_ctx, evp_md, NULL); + EVP_DigestInit_ex(md_ctx, evp_md, jdata->engine); EVP_DigestUpdate(md_ctx, src, g_pktlen); EVP_DigestFinal_ex(md_ctx, mac, &ssl_size); - // EVP_Digest(src, g_pktlen, mac, &ssl_size, evp_md, NULL);

- EVP_MD_CTX_free(md_ctx); - } else { //hmac mode - hm_ctx = HMAC_CTX_new(); - if (!hm_ctx) - return 0; + count++; + if (get_run_state() == 0) + break; + } + EVP_MD_CTX_free(md_ctx); + } else { //hmac mode + hm_ctx = HMAC_CTX_new(); + if (!hm_ctx) + return 0;

+ while (1) { i = jid % MAX_POOL_LENTH; src = soft_pool->bds[i].src;

- HMAC_Init_ex(hm_ctx, priv_key, jdata->keysize, evp_md, NULL); + HMAC_Init_ex(hm_ctx, priv_key, jdata->keysize, evp_md, jdata->engine); HMAC_Update(hm_ctx, src, g_pktlen); HMAC_Final(hm_ctx, mac, &ssl_size); - // HMAC(evp_md, priv_key, jdata->keysize, src, g_pktlen, mac, &ssl_size);

- HMAC_CTX_free(hm_ctx); + count++; + if (get_run_state() == 0) + break; } - break; + HMAC_CTX_free(hm_ctx); }

+ add_recv_data(count, g_pktlen); + return 0; }

static void *sec_soft_async_run(void *arg) { + typedef int (*sec_soft_run)(void *arg); + sec_soft_run sec_soft_jobfunc = NULL; soft_thread *pdata = (soft_thread *)arg; - ASYNC_WAIT_CTX *waitctx = NULL; - ASYNC_JOB *job = NULL; - int ret, jobret = 0; + jobs_args loop_jobs[MAX_JOBS_NUM]; + OSSL_ASYNC_FD waitfd = 0; jobs_data jobdata; - u32 count = 0; + fd_set waitfdset; + size_t numfds = 0; + int i, j, k, ret; + int jobret = 0; + u32 valid_jobs = 0; + u32 jobs_num;

jobdata.evp_cipher = pdata->evp_cipher; jobdata.evp_md = pdata->evp_md; @@ -575,31 +701,177 @@ static void *sec_soft_async_run(void *arg) jobdata.optype = pdata->optype; jobdata.subtype = pdata->subtype; jobdata.td_id = pdata->td_id; + jobdata.engine = pdata->engine;

- waitctx = ASYNC_WAIT_CTX_new(); - if (!waitctx) { - SSL_TST_PRT("Error: create ASYNC_WAIT_CTX failed\n"); + jobs_num = g_jobsnum; + if (jobs_num > MAX_JOBS_NUM) { + SSL_TST_PRT("Error: check async jobs num failed.\n"); return NULL; } + memset(loop_jobs, 0x0, sizeof(jobs_args) * MAX_JOBS_NUM);

- while (1) { - jobdata.jobid = count; - ret = ASYNC_start_job(&job, waitctx, &jobret, sec_soft_jobfunc, - (void *)&jobdata, sizeof(jobs_data)); + switch (pdata->subtype) { + case CIPHER_TYPE: + sec_soft_jobfunc = sec_soft_cipher_jobfunc; + break; + case AEAD_TYPE: + sec_soft_jobfunc = sec_soft_aead_jobfunc; + break; + case DIGEST_TYPE: + sec_soft_jobfunc = sec_soft_digest_jobfunc; + break; + } + + /* one thread for one job */ + for (i = 0; i < jobs_num; i++) { + loop_jobs[i].wait_ctx = ASYNC_WAIT_CTX_new(); + if (!loop_jobs[i].wait_ctx) { + SSL_TST_PRT("Error: create ASYNC_WAIT_CTX failed\n"); + goto async_error; + } + + jobdata.jobid = i; + ret = ASYNC_start_job(&loop_jobs[i].in_job, loop_jobs[i].wait_ctx, &jobret, + sec_soft_jobfunc, (void *)&jobdata, sizeof(jobs_data)); switch(ret) { case ASYNC_ERR: - SSL_TST_PRT("Error: start soft async job err. \n"); - goto exit_pause; + SSL_TST_PRT("Error: start soft async job err.\n"); + break; case ASYNC_NO_JOBS: - SSL_TST_PRT("Error: can't get soft async job from job pool. \n"); - goto exit_pause; + SSL_TST_PRT("Error: can't get soft async job from job pool.\n"); + break; case ASYNC_PAUSE: - SSL_TST_PRT("Info: job was paused \n"); + loop_jobs[i].job_valid = true; + valid_jobs++; break; case ASYNC_FINISH: break; default: - SSL_TST_PRT("Error: do soft async job err. \n"); + SSL_TST_PRT("Error: do soft async job err.\n"); + } + } + + j = valid_jobs; + while (j > 0) { + for (i = 0; i < jobs_num; i++) { + FD_ZERO(&waitfdset); + if (!loop_jobs[i].job_valid) + continue; + + /* Wait for the job to be woken */ + if (!ASYNC_WAIT_CTX_get_all_fds(loop_jobs[i].wait_ctx, NULL, &numfds) || + numfds > 1) { + SSL_TST_PRT("Error: unexpected number of fds.\n"); + continue; + } + ASYNC_WAIT_CTX_get_all_fds(loop_jobs[i].wait_ctx, &waitfd, &numfds); + + FD_SET(waitfd, &waitfdset); + ret = select(waitfd + 1, &waitfdset, NULL, NULL, NULL); + if (ret == -1) { + SSL_TST_PRT("Error: select soft async job error.\n"); + goto async_finish; + } else if (ret == 0 || (ret == -1 && errno == EINTR)) { + SSL_TST_PRT("Infor: select soft async job result continue.\n"); + continue; + } + + jobdata.jobid = i; + ret = ASYNC_start_job(&loop_jobs[i].in_job, loop_jobs[i].wait_ctx, &jobret, + sec_soft_jobfunc, (void *)&jobdata, sizeof(jobs_data)); + switch(ret) { + case ASYNC_ERR: + loop_jobs[i].job_valid = false; + j--; + SSL_TST_PRT("Error: restart soft async job err.\n"); + break; + case ASYNC_NO_JOBS: + SSL_TST_PRT("Error: can't get soft async job from job pool.\n"); + break; + case ASYNC_PAUSE: + break; + case ASYNC_FINISH: + loop_jobs[i].job_valid = false; + j--; + break; + default: + SSL_TST_PRT("Error: do soft async job err.\n"); + } + } + } + +async_finish: + i = jobs_num; +async_error: + for (k = 0; k < i; k++) + ASYNC_WAIT_CTX_free(loop_jobs[k].wait_ctx); + + add_send_complete(); + + return NULL; +} + +static void *sec_soft_cipher_sync(void *arg) +{ + soft_thread *pdata = (soft_thread *)arg; + const EVP_CIPHER *evp_cipher = pdata->evp_cipher; + u32 optype = pdata->optype; + struct bd_pool *soft_pool; + u8 *priv_iv, *priv_key; + EVP_CIPHER_CTX *ctx = NULL; + u32 count = 0; + u8 *src, *dst; + int ret, i = 0; + int outl = 0; + + if (!evp_cipher) { + SSL_TST_PRT("Error: openssl not support!\n"); + return NULL; + } + + if (pdata->td_id > g_thread_num) + return NULL; + + soft_pool = &g_soft_pool.pool[pdata->td_id]; + priv_iv = &g_soft_pool.iv[pdata->td_id]; + priv_key = &g_soft_pool.key[pdata->td_id]; + + memset(priv_iv, DEF_IVK_DATA, MAX_IVK_LENTH); + memset(priv_key, DEF_IVK_DATA, MAX_IVK_LENTH); + + ctx = EVP_CIPHER_CTX_new(); + if (!ctx) + return NULL; + + EVP_CIPHER_CTX_init(ctx); + + while (1) { + i = count % MAX_POOL_LENTH; + src = soft_pool->bds[i].src; + dst = soft_pool->bds[i].dst; + + if (optype) { + ret = EVP_DecryptInit_ex(ctx, evp_cipher, pdata->engine, priv_key, priv_iv); + if (ret != 1) + break; + + ret = EVP_DecryptUpdate(ctx, dst, &outl, src, g_pktlen); + if (ret != 1) + break; + + EVP_CIPHER_CTX_set_padding(ctx, EVP_PADDING_ZERO); + EVP_DecryptFinal_ex(ctx, dst, &outl); + } else { + ret = EVP_EncryptInit_ex(ctx, evp_cipher, pdata->engine, priv_key, priv_iv); + if (ret != 1) + break; + + ret = EVP_EncryptUpdate(ctx, dst, &outl, src, g_pktlen); + if (ret != 1) + break; + + EVP_CIPHER_CTX_set_padding(ctx, EVP_PADDING_ZERO); + EVP_EncryptFinal_ex(ctx, dst, &outl); }

count++; @@ -607,36 +879,31 @@ static void *sec_soft_async_run(void *arg) break; }

-exit_pause: - ASYNC_WAIT_CTX_free(waitctx); + EVP_CIPHER_CTX_cleanup(ctx); + EVP_CIPHER_CTX_free(ctx);

add_recv_data(count, g_pktlen);

return NULL; }

-static void *sec_soft_sync_run(void *arg) +static void *sec_soft_aead_sync(void *arg) { soft_thread *pdata = (soft_thread *)arg; const EVP_CIPHER *evp_cipher = pdata->evp_cipher; - const EVP_MD *evp_md = pdata->evp_md; u32 optype = pdata->optype; - u8 mac[EVP_MAX_MD_SIZE] = {0x00}; struct bd_pool *soft_pool; u8 *priv_iv, *priv_key; EVP_CIPHER_CTX *ctx = NULL; - EVP_MD_CTX *md_ctx = NULL; - HMAC_CTX *hm_ctx = NULL; u8 faketag[16] = {0xcc}; u8 aad[13] = {0xcc}; u8 tag[12] = {0}; - u32 ssl_size = 0; u32 count = 0; u8 *src, *dst; int ret, i = 0; int outl = 0;

- if (!evp_cipher && !evp_md) { + if (!evp_cipher) { SSL_TST_PRT("Error: openssl not support!\n"); return NULL; } @@ -651,27 +918,33 @@ static void *sec_soft_sync_run(void *arg) memset(priv_iv, DEF_IVK_DATA, MAX_IVK_LENTH); memset(priv_key, DEF_IVK_DATA, MAX_IVK_LENTH);

- switch(pdata->subtype) { - case CIPHER_TYPE: - ctx = EVP_CIPHER_CTX_new(); - if (!ctx) - return NULL; + ctx = EVP_CIPHER_CTX_new(); + if (!ctx) + return NULL;

- EVP_CIPHER_CTX_set_padding(ctx, 0); + EVP_CIPHER_CTX_set_padding(ctx, 0);

+ if (pdata->mode == WD_CIPHER_CCM) { while (1) { i = count % MAX_POOL_LENTH; src = soft_pool->bds[i].src; dst = soft_pool->bds[i].dst;

- (void)EVP_CipherInit_ex(ctx, evp_cipher, NULL, priv_key, priv_iv, optype); + (void)EVP_CipherInit_ex(ctx, evp_cipher, pdata->engine, priv_key, priv_iv, optype);

- if (optype) + if (optype) { + EVP_CIPHER_CTX_ctrl(ctx, 0x11, sizeof(tag), tag); + /* reset iv */ + EVP_DecryptInit_ex(ctx, NULL, pdata->engine, NULL, priv_iv); ret = EVP_DecryptUpdate(ctx, dst, &outl, src, g_pktlen); - else + } else { + /* restore iv length field */ + EVP_EncryptUpdate(ctx, NULL, &outl, NULL, g_pktlen); + /* counter is reset on every update */ ret = EVP_EncryptUpdate(ctx, dst, &outl, src, g_pktlen); + } if (ret != 1) - EVP_CipherInit_ex(ctx, evp_cipher, NULL, priv_key, priv_iv, optype); + EVP_CipherInit_ex(ctx, evp_cipher, pdata->engine, priv_key, priv_iv, optype);

if (optype) EVP_DecryptFinal_ex(ctx, dst, &outl); @@ -682,121 +955,105 @@ static void *sec_soft_sync_run(void *arg) if (get_run_state() == 0) break; } + } else { + while (1) { + i = count % MAX_POOL_LENTH; + src = soft_pool->bds[i].src; + dst = soft_pool->bds[i].dst;

- EVP_CIPHER_CTX_free(ctx); + (void)EVP_CipherInit_ex(ctx, evp_cipher, pdata->engine, priv_key, priv_iv, optype);

- break; - case AEAD_TYPE: - ctx = EVP_CIPHER_CTX_new(); - if (!ctx) + if (optype) { + EVP_DecryptInit_ex(ctx, NULL, pdata->engine, NULL, priv_iv); + EVP_CIPHER_CTX_ctrl(ctx, 0x11, + sizeof(faketag), tag); + EVP_DecryptUpdate(ctx, NULL, &outl, aad, sizeof(aad)); + EVP_DecryptUpdate(ctx, dst, &outl, src, g_pktlen); + ret = EVP_DecryptFinal_ex(ctx, dst + outl, &outl); + } else { + EVP_DecryptInit_ex(ctx, NULL, pdata->engine, NULL, priv_iv); + EVP_DecryptUpdate(ctx, NULL, &outl, aad, sizeof(aad)); + EVP_EncryptUpdate(ctx, NULL, &outl, NULL, g_pktlen); + ret = EVP_DecryptFinal_ex(ctx, dst + outl, &outl); + } + if (ret != 1) + EVP_CipherInit_ex(ctx, evp_cipher, pdata->engine, priv_key, priv_iv, optype); + + count++; + if (get_run_state() == 0) + break; + } + } + EVP_CIPHER_CTX_free(ctx); + + add_recv_data(count, g_pktlen); + + return NULL; +} + +static void *sec_soft_digest_sync(void *arg) +{ + soft_thread *pdata = (soft_thread *)arg; + const EVP_CIPHER *evp_cipher = pdata->evp_cipher; + const EVP_MD *evp_md = pdata->evp_md; + u32 optype = pdata->optype; + u8 mac[EVP_MAX_MD_SIZE] = {0x00}; + struct bd_pool *soft_pool; + EVP_MD_CTX *md_ctx = NULL; + HMAC_CTX *hm_ctx = NULL; + u8 *priv_key, *src; + u32 ssl_size = 0; + u32 count = 0; + int i = 0; + + if (!evp_cipher && !evp_md) { + SSL_TST_PRT("Error: openssl not support!\n"); + return NULL; + } + + if (pdata->td_id > g_thread_num) + return NULL; + + soft_pool = &g_soft_pool.pool[pdata->td_id]; + priv_key = &g_soft_pool.key[pdata->td_id]; + memset(priv_key, DEF_IVK_DATA, MAX_IVK_LENTH); + + if (!optype) { + md_ctx = EVP_MD_CTX_new(); + if (!md_ctx) return NULL;

- EVP_CIPHER_CTX_set_padding(ctx, 0); - - if (pdata->mode == WD_CIPHER_CCM) { - while (1) { - i = count % MAX_POOL_LENTH; - src = soft_pool->bds[i].src; - dst = soft_pool->bds[i].dst; - - (void)EVP_CipherInit_ex(ctx, evp_cipher, NULL, priv_key, priv_iv, optype); - - if (optype) { - EVP_CIPHER_CTX_ctrl(ctx, 0x11, sizeof(tag), tag); - /* reset iv */ - EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, priv_iv); - ret = EVP_DecryptUpdate(ctx, dst, &outl, src, g_pktlen); - } else { - /* restore iv length field */ - EVP_EncryptUpdate(ctx, NULL, &outl, NULL, g_pktlen); - /* counter is reset on every update */ - ret = EVP_EncryptUpdate(ctx, dst, &outl, src, g_pktlen); - } - if (ret != 1) - EVP_CipherInit_ex(ctx, evp_cipher, NULL, priv_key, priv_iv, optype); - - if (optype) - EVP_DecryptFinal_ex(ctx, dst, &outl); - else - EVP_EncryptFinal_ex(ctx, dst, &outl); - - count++; - if (get_run_state() == 0) - break; - } - } else { - while (1) { - i = count % MAX_POOL_LENTH; - src = soft_pool->bds[i].src; - dst = soft_pool->bds[i].dst; - - (void)EVP_CipherInit_ex(ctx, evp_cipher, NULL, priv_key, priv_iv, optype); - - if (optype) { - EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, priv_iv); - EVP_CIPHER_CTX_ctrl(ctx, 0x11, - sizeof(faketag), tag); - EVP_DecryptUpdate(ctx, NULL, &outl, aad, sizeof(aad)); - EVP_DecryptUpdate(ctx, dst, &outl, src, g_pktlen); - ret = EVP_DecryptFinal_ex(ctx, dst + outl, &outl); - } else { - EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, priv_iv); - EVP_DecryptUpdate(ctx, NULL, &outl, aad, sizeof(aad)); - EVP_EncryptUpdate(ctx, NULL, &outl, NULL, g_pktlen); - ret = EVP_DecryptFinal_ex(ctx, dst + outl, &outl); - } - if (ret != 1) - EVP_CipherInit_ex(ctx, evp_cipher, NULL, priv_key, priv_iv, optype); - - count++; - if (get_run_state() == 0) - break; - } + while (1) { + i = count % MAX_POOL_LENTH; + src = soft_pool->bds[i].src; + + EVP_DigestInit_ex(md_ctx, evp_md, pdata->engine); + EVP_DigestUpdate(md_ctx, src, g_pktlen); + EVP_DigestFinal_ex(md_ctx, mac, &ssl_size); + + count++; + if (get_run_state() == 0) + break; } - EVP_CIPHER_CTX_free(ctx); + EVP_MD_CTX_free(md_ctx); + } else { + hm_ctx = HMAC_CTX_new(); + if (!hm_ctx) + return NULL;

- break; - case DIGEST_TYPE: - if (!optype) { //normal mode - md_ctx = EVP_MD_CTX_new(); - if (!md_ctx) - return NULL; - - while (1) { - i = count % MAX_POOL_LENTH; - src = soft_pool->bds[i].src; - - EVP_DigestInit_ex(md_ctx, evp_md, NULL); - EVP_DigestUpdate(md_ctx, src, g_pktlen); - EVP_DigestFinal_ex(md_ctx, mac, &ssl_size); - // EVP_Digest(src, g_pktlen, mac, &ssl_size, evp_md, NULL); - - count++; - if (get_run_state() == 0) - break; - } - EVP_MD_CTX_free(md_ctx); - } else { //hmac mode - hm_ctx = HMAC_CTX_new(); - if (!hm_ctx) - return NULL; - - while (1) { - i = count % MAX_POOL_LENTH; - src = soft_pool->bds[i].src; - - HMAC_Init_ex(hm_ctx, priv_key, pdata->keysize, evp_md, NULL); - HMAC_Update(hm_ctx, src, g_pktlen); - HMAC_Final(hm_ctx, mac, &ssl_size); - // HMAC(evp_md, priv_key, pdata->keysize, src, g_pktlen, mac, &ssl_size); - - count++; - if (get_run_state() == 0) - break; - } - HMAC_CTX_free(hm_ctx); + while (1) { + i = count % MAX_POOL_LENTH; + src = soft_pool->bds[i].src; + + HMAC_Init_ex(hm_ctx, priv_key, pdata->keysize, evp_md, pdata->engine); + HMAC_Update(hm_ctx, src, g_pktlen); + HMAC_Final(hm_ctx, mac, &ssl_size); + + count++; + if (get_run_state() == 0) + break; } - break; + HMAC_CTX_free(hm_ctx); }

add_recv_data(count, g_pktlen); @@ -804,18 +1061,126 @@ static void *sec_soft_sync_run(void *arg) return NULL; }

+static void uadk_engine_set_env(soft_thread *options) +{ + char env_string[ENV_STRING_LEN] = {0}; + char *var_name = NULL; + + switch(options->subtype) { + case CIPHER_TYPE: + var_name = "WD_CIPHER_CTX_NUM"; + break; + case AEAD_TYPE: + var_name = "WD_CIPHER_CTX_NUM"; + break; + case DIGEST_TYPE: + var_name = "WD_DIGEST_CTX_NUM"; + break; + default: + return; + } + + unsetenv(var_name); + + /* uadk will request ctxs from env param */ + if (options->sync_mode) // async mode + (void)snprintf(env_string, ENV_STRING_LEN, "%s%d%s%d%s", + "async:", g_jobsnum,"@0,async:", g_jobsnum, "@2"); + else + (void)snprintf(env_string, ENV_STRING_LEN, "%s%d%s%d%s", + "sync:", g_jobsnum,"@0,sync:", g_jobsnum, "@2"); + (void)setenv(var_name, env_string, 1); +} + +static int uadk_engine_register(soft_thread *options, char *engine_name) +{ + if (!options->engine_flag) + return 0; + + /* Set env param for uadk engine */ + uadk_engine_set_env(options); + + ERR_load_ENGINE_strings(); + OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CONFIG, NULL); + + options->engine = ENGINE_by_id(engine_name); + if (!options->engine) { + SSL_TST_PRT("setup uadk engine failed!\n"); + return -EINVAL; + } + + ENGINE_init(options->engine); + switch(options->subtype) { + case CIPHER_TYPE: + ENGINE_register_ciphers(options->engine); + break; + case AEAD_TYPE: + ENGINE_register_ciphers(options->engine); + SSL_TST_PRT("Openssl just support CCM/GCM!\n"); + break; + case DIGEST_TYPE: + ENGINE_register_digests(options->engine); + break; + default: + return -EINVAL; + } + + return 0; +} + +static void uadk_engine_unregister(soft_thread *options) +{ + if (!options->engine_flag) + return; + + switch(options->subtype) { + case CIPHER_TYPE: + ENGINE_unregister_ciphers(options->engine); + break; + case AEAD_TYPE: + ENGINE_unregister_ciphers(options->engine); + break; + case DIGEST_TYPE: + ENGINE_unregister_digests(options->engine); + break; + default: + return; + } + ENGINE_free(options->engine); +} + int sec_soft_sync_threads(struct acc_option *options) { + typedef void *(*sec_sync_run)(void *arg); + sec_sync_run soft_sec_sync_run = NULL; soft_thread threads_args[THREADS_NUM]; soft_thread threads_option; pthread_t tdid[THREADS_NUM]; int i, ret;

- /* alg param parse and set to thread data */ + /* Alg param parse and set to thread data */ ret = sec_soft_param_parse(&threads_option, options); if (ret) return ret;

+ threads_option.engine_flag = options->engine_flag; + threads_option.sync_mode = options->syncmode; + ret = uadk_engine_register(&threads_option, options->engine); + if (ret) + return ret; + + switch (options->subtype) { + case CIPHER_TYPE: + soft_sec_sync_run = sec_soft_cipher_sync; + break; + case AEAD_TYPE: + soft_sec_sync_run = sec_soft_aead_sync; + break; + case DIGEST_TYPE: + soft_sec_sync_run = sec_soft_digest_sync; + break; + } + for (i = 0; i < g_thread_num; i++) { threads_args[i].evp_cipher = threads_option.evp_cipher; threads_args[i].evp_md = threads_option.evp_md; @@ -825,14 +1190,15 @@ int sec_soft_sync_threads(struct acc_option *options) threads_args[i].optype = threads_option.optype; threads_args[i].td_id = i; threads_args[i].engine_flag = options->engine_flag; - ret = pthread_create(&tdid[i], NULL, sec_soft_sync_run, &threads_args[i]); + threads_args[i].engine = threads_option.engine; + ret = pthread_create(&tdid[i], NULL, soft_sec_sync_run, &threads_args[i]); if (ret) { SSL_TST_PRT("Create sync thread fail!\n"); goto sync_error; } }

- /* join thread */ + /* Join thread */ for (i = 0; i < g_thread_num; i++) { ret = pthread_join(tdid[i], NULL); if (ret) { @@ -842,8 +1208,8 @@ int sec_soft_sync_threads(struct acc_option *options) }

sync_error: + uadk_engine_unregister(&threads_option); return ret; - }

int sec_soft_async_threads(struct acc_option *options) @@ -853,11 +1219,17 @@ int sec_soft_async_threads(struct acc_option *options) pthread_t tdid[THREADS_NUM]; int i, ret;

- /* alg param parse and set to thread data */ + /* Alg param parse and set to thread data */ ret = sec_soft_param_parse(&threads_option, options); if (ret) return ret;

+ threads_option.engine_flag = options->engine_flag; + threads_option.sync_mode = options->syncmode; + ret = uadk_engine_register(&threads_option, options->engine); + if (ret) + return ret; + for (i = 0; i < g_thread_num; i++) { threads_args[i].evp_cipher = threads_option.evp_cipher; threads_args[i].evp_md = threads_option.evp_md; @@ -867,6 +1239,7 @@ int sec_soft_async_threads(struct acc_option *options) threads_args[i].optype = threads_option.optype; threads_args[i].td_id = i; threads_args[i].engine_flag = options->engine_flag; + threads_args[i].engine = threads_option.engine; ret = pthread_create(&tdid[i], NULL, sec_soft_async_run, &threads_args[i]); if (ret) { SSL_TST_PRT("Create async thread fail!\n"); @@ -874,7 +1247,7 @@ int sec_soft_async_threads(struct acc_option *options) } }

- /* join thread */ + /* Join thread */ for (i = 0; i < g_thread_num; i++) { ret = pthread_join(tdid[i], NULL); if (ret) { @@ -884,74 +1257,10 @@ int sec_soft_async_threads(struct acc_option *options) }

async_error: + uadk_engine_unregister(&threads_option); return ret; }

-static int uadk_engine_register(struct acc_option *options) -{ - ENGINE *e = NULL; - - if (!options->engine_flag) - return 0; - - ERR_load_ENGINE_strings(); - OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_DYNAMIC, NULL); - - e = ENGINE_by_id(options->engine); - if (!e) { - SSL_TST_PRT("setup uadk engine failed!\n"); - return -EINVAL; - } - - ENGINE_init(e); - switch(options->subtype) { - case CIPHER_TYPE: - ENGINE_register_ciphers(e); - break; - case AEAD_TYPE: - SSL_TST_PRT("Openssl not support AEAD ALG!\n"); - return -EINVAL; - case DIGEST_TYPE: - ENGINE_register_digests(e); - break; - default: - return -EINVAL; - } - ENGINE_free(e); - - return 0; -} - -static void uadk_engine_unregister(struct acc_option *options) -{ - ENGINE *e = NULL; - - if (!options->engine_flag) - return; - - e = ENGINE_by_id(options->engine); - if (!e) { - SSL_TST_PRT("Error: not find uadk engine \n"); - return; - } - - ENGINE_init(e); - switch(options->subtype) { - case CIPHER_TYPE: - ENGINE_unregister_ciphers(e); - break; - case AEAD_TYPE: - // ENGINE_unregister_ciphers(e); //openssl not support aead - break; - case DIGEST_TYPE: - ENGINE_unregister_digests(e); - break; - default: - return; - } - ENGINE_free(e); -} - int sec_soft_benchmark(struct acc_option *options) { u32 ptime; @@ -959,7 +1268,7 @@ int sec_soft_benchmark(struct acc_option *options)

g_thread_num = options->threads; g_pktlen = options->pktlen; - g_ctxnum = options->ctxnums; + g_jobsnum = options->ctxnums; if (options->optype > WD_CIPHER_DECRYPTION) { SSL_TST_PRT("SEC optype error: %u\n", options->optype); return -EINVAL; @@ -969,10 +1278,6 @@ int sec_soft_benchmark(struct acc_option *options) if (ret) return ret;

- ret = uadk_engine_register(options); - if (ret) - return ret; - get_pid_cpu_time(&ptime); time_start(options->times); if (options->syncmode) @@ -983,7 +1288,6 @@ int sec_soft_benchmark(struct acc_option *options) if (ret) return ret;

- uadk_engine_unregister(options); free_soft_bd_pool();

return 0;

1. update the code editing method for random number acquisition. 2. remove some remaining asset operations 3. fix a memory leak issue

Signed-off-by: Longfang Liu liulongfang@huawei.com --- uadk_tool/benchmark/hpre_uadk_benchmark.c | 15 ---------- uadk_tool/benchmark/hpre_wd_benchmark.c | 15 ---------- uadk_tool/benchmark/sec_soft_benchmark.c | 16 ++++++---- uadk_tool/benchmark/sec_uadk_benchmark.c | 13 ++++---- uadk_tool/benchmark/sec_wd_benchmark.c | 36 ++++++++++++++--------- uadk_tool/benchmark/uadk_benchmark.c | 19 ++++++------ uadk_tool/benchmark/zip_uadk_benchmark.c | 12 ++++---- uadk_tool/benchmark/zip_wd_benchmark.c | 12 ++++---- 8 files changed, 59 insertions(+), 79 deletions(-)

diff --git a/uadk_tool/benchmark/hpre_uadk_benchmark.c b/uadk_tool/benchmark/hpre_uadk_benchmark.c index 13e24ca..e3372fb 100644 --- a/uadk_tool/benchmark/hpre_uadk_benchmark.c +++ b/uadk_tool/benchmark/hpre_uadk_benchmark.c @@ -1206,11 +1206,6 @@ key_release:

static void rsa_async_cb(void *req_t) { - //struct wd_rsa_req *req = req_t; - //struct rsa_async_tag *tag = req->cb_param; - //enum wd_rsa_op_type op_type = req->op_type; - //handle_t h_sess = tag->sess; - return; }

@@ -1517,11 +1512,6 @@ ag_error:

static void dh_async_cb(void *req_t) { - //struct wd_dh_req *req = req_t; - //struct rsa_async_tag *tag = req->cb_param; - //enum wd_rsa_op_type op_type = req->op_type; - //handle_t h_sess = tag->sess; - return; }

@@ -2112,11 +2102,6 @@ msg_release:

static void ecc_async_cb(void *req_t) { - //struct wd_ecc_req *req = req_t; - //struct rsa_async_tag *tag = req->cb_param; - //enum wd_rsa_op_type op_type = req->op_type; - //handle_t h_sess = tag->sess; - return; }

diff --git a/uadk_tool/benchmark/hpre_wd_benchmark.c b/uadk_tool/benchmark/hpre_wd_benchmark.c index 231b569..2e23c95 100644 --- a/uadk_tool/benchmark/hpre_wd_benchmark.c +++ b/uadk_tool/benchmark/hpre_wd_benchmark.c @@ -936,11 +936,6 @@ key_release:

static void rsa_async_cb(const void *msg, void *tag) { - //struct wcrypto_rsa_msg *massage = msg; - //struct rsa_async_tag *ptag = tag; - //u32 op_type = tag->op_type; - //void *ctx = tag->ctx; - return; }

@@ -1333,11 +1328,6 @@ ctx_release:

static void dh_async_cb(const void *msg, void *tag) { - //struct wcrypto_dh_msg *massage = msg; - //struct rsa_async_tag *ptag = tag; - //u32 op_type = tag->op_type; - //void *ctx = tag->ctx; - return; }

@@ -2203,11 +2193,6 @@ msg_release:

static void ecc_async_cb(const void *msg, void *tag) { - //struct wcrypto_ecc_msg *massage = msg; - //struct rsa_async_tag *ptag = tag; - //u32 op_type = tag->op_type; - //void *ctx = tag->ctx; - return; }

diff --git a/uadk_tool/benchmark/sec_soft_benchmark.c b/uadk_tool/benchmark/sec_soft_benchmark.c index f3510b1..3a38cbd 100644 --- a/uadk_tool/benchmark/sec_soft_benchmark.c +++ b/uadk_tool/benchmark/sec_soft_benchmark.c @@ -428,7 +428,7 @@ static int sec_soft_cipher_jobfunc(void *args) u32 jid = jdata->jobid; struct bd_pool *soft_pool; u8 *priv_iv, *priv_key; - int ret, outl, i = 0; + int ret, outl, i; EVP_CIPHER_CTX *ctx; ASYNC_JOB *currjob; u32 count = 0; @@ -509,9 +509,13 @@ static int sec_soft_aead_jobfunc(void *args) u32 jid = jdata->jobid; struct bd_pool *soft_pool; u8 *priv_iv, *priv_key; - int ret, outl, i = 0; + int ret, outl, i; EVP_CIPHER_CTX *ctx; ASYNC_JOB *currjob; + /* + * these length parameters specify the default + * length according to the GCM/CCM algorithm + */ u8 faketag[16] = {0xcc}; u8 aad[13] = {0xcc}; u8 tag[12] = {0}; @@ -615,7 +619,7 @@ static int sec_soft_digest_jobfunc(void *args) u32 ssl_size = 0; u8 *priv_key, *src; u32 count = 0; - int i = 0; + int i;

currjob = ASYNC_get_current_job(); if (!currjob) { @@ -821,7 +825,7 @@ static void *sec_soft_cipher_sync(void *arg) EVP_CIPHER_CTX *ctx = NULL; u32 count = 0; u8 *src, *dst; - int ret, i = 0; + int ret, i; int outl = 0;

if (!evp_cipher) { @@ -901,7 +905,7 @@ static void *sec_soft_aead_sync(void *arg) u8 tag[12] = {0}; u32 count = 0; u8 *src, *dst; - int ret, i = 0; + int ret, i; int outl = 0;

if (!evp_cipher) { @@ -1006,7 +1010,7 @@ static void *sec_soft_digest_sync(void *arg) u8 *priv_key, *src; u32 ssl_size = 0; u32 count = 0; - int i = 0; + int i;

if (!evp_cipher && !evp_md) { SSL_TST_PRT("Error: openssl not support!\n"); diff --git a/uadk_tool/benchmark/sec_uadk_benchmark.c b/uadk_tool/benchmark/sec_uadk_benchmark.c index ff83769..16f96a2 100644 --- a/uadk_tool/benchmark/sec_uadk_benchmark.c +++ b/uadk_tool/benchmark/sec_uadk_benchmark.c @@ -62,7 +62,6 @@ static void *aead_async_cb(struct wd_aead_req *req, void *data)

static void *digest_async_cb(void *data) { - // struct wd_digest_req *req = (struct wd_digest_req *)data; return NULL; }

@@ -648,7 +647,7 @@ static void *sec_uadk_cipher_async(void *arg) int try_cnt = 0; handle_t h_sess; u32 count = 0; - int ret, i = 0; + int ret, i;

if (pdata->td_id > g_thread_num) return NULL; @@ -720,7 +719,7 @@ static void *sec_uadk_aead_async(void *arg) handle_t h_sess; u32 auth_size = 16; u32 count = 0; - int ret, i = 0; + int ret, i;

if (pdata->td_id > g_thread_num) return NULL; @@ -819,7 +818,7 @@ static void *sec_uadk_digest_async(void *arg) int try_cnt = 0; handle_t h_sess; u32 count = 0; - int ret, i = 0; + int ret, i;

if (pdata->td_id > g_thread_num) return NULL; @@ -888,7 +887,7 @@ static void *sec_uadk_cipher_sync(void *arg) u8 *priv_iv, *priv_key; handle_t h_sess; u32 count = 0; - int ret, i = 0; + int ret, i;

if (pdata->td_id > g_thread_num) return NULL; @@ -950,7 +949,7 @@ static void *sec_uadk_aead_sync(void *arg) handle_t h_sess; u32 auth_size = 16; u32 count = 0; - int ret, i = 0; + int ret, i;

if (pdata->td_id > g_thread_num) return NULL; @@ -1040,7 +1039,7 @@ static void *sec_uadk_digest_sync(void *arg) u8 *priv_iv, *priv_key; handle_t h_sess; u32 count = 0; - int ret, i = 0; + int ret, i;

if (pdata->td_id > g_thread_num) return NULL; diff --git a/uadk_tool/benchmark/sec_wd_benchmark.c b/uadk_tool/benchmark/sec_wd_benchmark.c index 5dd1501..739c49e 100644 --- a/uadk_tool/benchmark/sec_wd_benchmark.c +++ b/uadk_tool/benchmark/sec_wd_benchmark.c @@ -62,7 +62,6 @@ static void *aead_async_cb(void *message, void *cipher_tag)

static void *digest_async_cb(void *message, void *digest_tag) { - // struct WCRYPTO_req *req = (struct WCRYPTO_req *)data; return NULL; }

@@ -598,7 +597,7 @@ static void *sec_wd_cipher_async(void *arg) void **res_iv; u32 count = 0; int try_cnt = 0; - int ret, i = 0; + int ret, i; void *pool;

if (pdata->td_id > g_thread_num) @@ -632,7 +631,7 @@ static void *sec_wd_cipher_async(void *arg) ctx = wcrypto_create_cipher_ctx(queue, &cipher_setup); if (!ctx) { SEC_TST_PRT("wd create cipher ctx fail!\n"); - return NULL; + goto tag_err; } tag->ctx = ctx;

@@ -640,7 +639,7 @@ static void *sec_wd_cipher_async(void *arg) if (ret) { SEC_TST_PRT("wd cipher set key fail!\n"); wcrypto_del_cipher_ctx(ctx); - return NULL; + goto tag_err; }

if (queue->capa.priv.direction == 0) @@ -692,6 +691,9 @@ static void *sec_wd_cipher_async(void *arg)

wcrypto_del_cipher_ctx(ctx);

+tag_err: + free(tag); + return NULL; }

@@ -712,7 +714,7 @@ static void *sec_wd_aead_async(void *arg) u32 count = 0; int try_cnt = 0; u32 authsize; - int ret, i = 0; + int ret, i; void *pool;

if (pdata->td_id > g_thread_num) @@ -759,7 +761,7 @@ static void *sec_wd_aead_async(void *arg) if (ret) { SEC_TST_PRT("wd aead set key fail!\n"); wcrypto_del_aead_ctx(ctx); - return NULL; + goto tag_err; }

if (pdata->is_union) { @@ -767,7 +769,7 @@ static void *sec_wd_aead_async(void *arg) if (ret) { SEC_TST_PRT("set akey fail!\n"); wcrypto_del_aead_ctx(ctx); - return NULL; + goto tag_err; } }

@@ -776,7 +778,7 @@ static void *sec_wd_aead_async(void *arg) if (ret) { SEC_TST_PRT("set authsize fail!\n"); wcrypto_del_aead_ctx(ctx); - return NULL; + goto tag_err; }

if (queue->capa.priv.direction == 0) { @@ -833,6 +835,9 @@ static void *sec_wd_aead_async(void *arg)

wcrypto_del_aead_ctx(ctx);

+tag_err: + free(tag); + return NULL; }

@@ -850,7 +855,7 @@ static void *sec_wd_digest_async(void *arg) void **res_out; u32 count = 0; int try_cnt = 0; - int ret, i = 0; + int ret, i; void *pool;

if (pdata->td_id > g_thread_num) @@ -883,7 +888,7 @@ static void *sec_wd_digest_async(void *arg) ctx = wcrypto_create_digest_ctx(queue, &digest_setup); if (!ctx) { SEC_TST_PRT("wd create digest ctx fail!\n"); - return NULL; + goto tag_err; } tag->ctx = ctx;

@@ -893,7 +898,7 @@ static void *sec_wd_digest_async(void *arg) if (ret) { SEC_TST_PRT("wd digest set key fail!\n"); wcrypto_del_digest_ctx(ctx); - return NULL; + goto tag_err; } }

@@ -939,6 +944,9 @@ static void *sec_wd_digest_async(void *arg)

wcrypto_del_digest_ctx(ctx);

+tag_err: + free(tag); + return NULL; }

@@ -957,7 +965,7 @@ static void *sec_wd_cipher_sync(void *arg) void **res_iv; u32 count = 0; int try_cnt = 0; - int ret, i = 0; + int ret, i; void *pool;

if (pdata->td_id > g_thread_num) @@ -1055,7 +1063,7 @@ static void *sec_wd_aead_sync(void *arg) u32 count = 0; int try_cnt = 0; u32 authsize; - int ret, i = 0; + int ret, i; void *pool;

if (pdata->td_id > g_thread_num) @@ -1177,7 +1185,7 @@ static void *sec_wd_digest_sync(void *arg) void **res_out; u32 count = 0; int try_cnt = 0; - int ret, i = 0; + int ret, i; void *pool;

if (pdata->td_id > g_thread_num) diff --git a/uadk_tool/benchmark/uadk_benchmark.c b/uadk_tool/benchmark/uadk_benchmark.c index 2791f84..f36cc4b 100644 --- a/uadk_tool/benchmark/uadk_benchmark.c +++ b/uadk_tool/benchmark/uadk_benchmark.c @@ -281,20 +281,20 @@ void get_rand_data(u8 *addr, u32 size) { unsigned short rand_state[3] = { (0xae >> 16) & 0xffff, 0xae & 0xffff, 0x330e}; + static __thread u64 rand_seed = 0x330eabcd; + u64 rand48 = 0; int i;

-#if 1 // only 32bit valid, other 32bit is zero - for (i = 0; i < size >> 3; i++) - *((u64 *)addr + i) = nrand48(rand_state); -#else - // full 64bit valid - for (i = 0; i < size >> 2; i++) - *((u32 *)addr + i) = nrand48(rand_state); -#endif + for (i = 0; i < size >> 3; i++) { + rand_state[0] = (u16)rand_seed; + rand_state[1] = (u16)(rand_seed >> 16); + rand48 = nrand48(rand_state); + *((u64 *)addr + i) = rand48; + rand_seed = rand48; + } }

- void cal_avg_latency(u32 count) { double latency; @@ -307,7 +307,6 @@ void cal_avg_latency(u32 count) }

/*-------------------------------------main code------------------------------------------------------*/ - static void parse_alg_param(struct acc_option *option) { switch(option->algtype) { diff --git a/uadk_tool/benchmark/zip_uadk_benchmark.c b/uadk_tool/benchmark/zip_uadk_benchmark.c index ffffa9b..d74d3fb 100644 --- a/uadk_tool/benchmark/zip_uadk_benchmark.c +++ b/uadk_tool/benchmark/zip_uadk_benchmark.c @@ -535,7 +535,7 @@ static void *zip_uadk_blk_lz77_sync_run(void *arg) u32 first_len = 0; u32 out_len = 0; u32 count = 0; - int ret, i = 0; + int ret, i;

if (pdata->td_id > g_thread_num) return NULL; @@ -628,7 +628,7 @@ static void *zip_uadk_stm_lz77_sync_run(void *arg) u32 first_len = 0; u32 out_len = 0; u32 count = 0; - int ret, i = 0; + int ret, i;

if (pdata->td_id > g_thread_num) return NULL; @@ -722,7 +722,7 @@ static void *zip_uadk_blk_lz77_async_run(void *arg) u32 out_len = 0; u32 count = 0; u32 try_cnt = 0; - int ret, i = 0; + int ret, i;

if (pdata->td_id > g_thread_num) return NULL; @@ -826,7 +826,7 @@ static void *zip_uadk_blk_sync_run(void *arg) handle_t h_sess; u32 out_len = 0; u32 count = 0; - int ret, i = 0; + int ret, i;

if (pdata->td_id > g_thread_num) return NULL; @@ -885,7 +885,7 @@ static void *zip_uadk_stm_sync_run(void *arg) handle_t h_sess; u32 out_len = 0; u32 count = 0; - int ret, i = 0; + int ret, i;

if (pdata->td_id > g_thread_num) return NULL; @@ -950,7 +950,7 @@ static void *zip_uadk_blk_async_run(void *arg) int try_cnt = 0; u32 out_len = 0; u32 count = 0; - int ret, i = 0; + int ret, i;

if (pdata->td_id > g_thread_num) return NULL; diff --git a/uadk_tool/benchmark/zip_wd_benchmark.c b/uadk_tool/benchmark/zip_wd_benchmark.c index 8d013c5..cbbbb5d 100644 --- a/uadk_tool/benchmark/zip_wd_benchmark.c +++ b/uadk_tool/benchmark/zip_wd_benchmark.c @@ -509,7 +509,7 @@ static void *zip_wd_blk_lz77_sync_run(void *arg) u32 first_len = 0; u32 out_len = 0; u32 count = 0; - int ret, i = 0; + int ret, i;

if (pdata->td_id > g_thread_num) return NULL; @@ -617,7 +617,7 @@ static void *zip_wd_stm_lz77_sync_run(void *arg) u32 first_len = 0; u32 out_len = 0; u32 count = 0; - int ret, i = 0; + int ret, i;

if (pdata->td_id > g_thread_num) return NULL; @@ -726,7 +726,7 @@ static void *zip_wd_blk_lz77_async_run(void *arg) u32 out_len = 0; u32 count = 0; u32 try_cnt = 0; - int ret, i = 0; + int ret, i;

if (pdata->td_id > g_thread_num) return NULL; @@ -847,7 +847,7 @@ static void *zip_wd_blk_sync_run(void *arg) struct wd_bd *bd_pool; u32 out_len = 0; u32 count = 0; - int ret, i = 0; + int ret, i;

if (pdata->td_id > g_thread_num) return NULL; @@ -920,7 +920,7 @@ static void *zip_wd_stm_sync_run(void *arg) struct wd_bd *bd_pool; u32 out_len = 0; u32 count = 0; - int ret, i = 0; + int ret, i;

if (pdata->td_id > g_thread_num) return NULL; @@ -999,7 +999,7 @@ static void *zip_wd_blk_async_run(void *arg) int try_cnt = 0; u32 out_len = 0; u32 count = 0; - int ret, i = 0; + int ret, i;

if (pdata->td_id > g_thread_num) return NULL;

From: Weili Qian qianweili@huawei.com

1.Change the ECC_CURVE_ID to 2 for secp256k1 test. 2.Increase the block size for the nosva test. 3.Modify the sample data of ecdsa 256 verify. 4.Queues on multiple devices can be obtained.

Signed-off-by: Weili Qian qianweili@huawei.com --- uadk_tool/benchmark/hpre_protocol_data.h | 77 ++++++++++++++-- uadk_tool/benchmark/hpre_uadk_benchmark.c | 107 ++++++++++++++++++---- uadk_tool/benchmark/hpre_wd_benchmark.c | 80 ++++++++++------ 3 files changed, 210 insertions(+), 54 deletions(-)

diff --git a/uadk_tool/benchmark/hpre_protocol_data.h b/uadk_tool/benchmark/hpre_protocol_data.h index 9c92138..7bdb942 100644 --- a/uadk_tool/benchmark/hpre_protocol_data.h +++ b/uadk_tool/benchmark/hpre_protocol_data.h @@ -1292,8 +1292,9 @@ static unsigned char ecc_except_kinv_secp256k1[] = { };

static unsigned char ecc_except_e_secp256k1[] = { - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04 + 0x3a, 0x10, 0x3a, 0x4e, 0x57, 0x29, 0xad, 0x68, 0xc0, 0x2a, 0x67, 0x8a, + 0xe3, 0x9a, 0xcc, 0xfb, 0xc0, 0xae, 0x20, 0x80, 0x96, 0x43, 0x74, 0x01, + 0xb7, 0xce, 0xab, 0x63, 0xcc, 0xa0, 0x62, 0x2f };

static unsigned char ecc_cp_sign_secp256k1[] = { @@ -1649,19 +1650,75 @@ static unsigned char sm2_ciphertext_l[609] = {

static unsigned char sm2_pubkey[] = { 0x04, - 0x09, 0xf9, 0xdf, 0x31, 0x1e, 0x54, 0x21, 0xa1, 0x50, 0xdd, 0x7d, 0x16, 0x1e, 0x4b, 0xc5, 0xc6, - 0x72, 0x17, 0x9f, 0xad, 0x18, 0x33, 0xfc, 0x07, 0x6b, 0xb0, 0x8f, 0xf3, 0x56, 0xf3, 0x50, 0x20, - 0xcc, 0xea, 0x49, 0x0c, 0xe2, 0x67, 0x75, 0xa5, 0x2d, 0xc6, 0xea, 0x71, 0x8c, 0xc1, 0xaa, 0x60, - 0x0a, 0xed, 0x05, 0xfb, 0xf3, 0x5e, 0x08, 0x4a, 0x66, 0x32, 0xf6, 0x07, 0x2d, 0xa9, 0xad, 0x13 + 0x09, 0xf9, 0xdf, 0x31, 0x1e, 0x54, 0x21, 0xa1, 0x50, 0xdd, 0x7d, 0x16, + 0x1e, 0x4b, 0xc5, 0xc6, 0x72, 0x17, 0x9f, 0xad, 0x18, 0x33, 0xfc, 0x07, + 0x6b, 0xb0, 0x8f, 0xf3, 0x56, 0xf3, 0x50, 0x20, + 0xcc, 0xea, 0x49, 0x0c, 0xe2, 0x67, 0x75, 0xa5, 0x2d, 0xc6, 0xea, 0x71, + 0x8c, 0xc1, 0xaa, 0x60, 0x0a, 0xed, 0x05, 0xfb, 0xf3, 0x5e, 0x08, 0x4a, + 0x66, 0x32, 0xf6, 0x07, 0x2d, 0xa9, 0xad, 0x13 };

static unsigned char sm2_priv[] = { - 0x39, 0x45, 0x20, 0x8f, 0x7b, 0x21, 0x44, 0xb1, 0x3f, 0x36, 0xe3, 0x8a, 0xc6, 0xd3, 0x9f, 0x95, - 0x88, 0x93, 0x93, 0x69, 0x28, 0x60, 0xb5, 0x1a, 0x42, 0xfb, 0x81, 0xef, 0x4d, 0xf7, 0xc5, 0xb8 + 0x39, 0x45, 0x20, 0x8f, 0x7b, 0x21, 0x44, 0xb1, 0x3f, 0x36, 0xe3, 0x8a, + 0xc6, 0xd3, 0x9f, 0x95, 0x88, 0x93, 0x93, 0x69, 0x28, 0x60, 0xb5, 0x1a, + 0x42, 0xfb, 0x81, 0xef, 0x4d, 0xf7, 0xc5, 0xb8 };

static unsigned char sm2_digest[] = { - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x20, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74 + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, + 0x65, 0x20, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74 +}; + +static char ecdsa_verf_p_secp256k1[] = { + 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF +}; + +static char ecdsa_verf_a_secp256k1[] = { + 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC +}; + +static char ecdsa_verf_b_secp256k1[] = { + 0x5A, 0xC6, 0x35, 0xD8, 0xAA, 0x3A, 0x93, 0xE7, 0xB3, 0xEB, 0xBD, 0x55, + 0x76, 0x98, 0x86, 0xBC, 0x65, 0x1D, 0x06, 0xB0, 0xCC, 0x53, 0xB0, 0xF6, + 0x3B, 0xCE, 0x3C, 0x3E, 0x27, 0xD2, 0x60, 0x4B +}; + +static char ecdsa_verf_g_secp256k1[] = { + 0x6B, 0x17, 0xD1, 0xF2, 0xE1, 0x2C, 0x42, 0x47, 0xF8, 0xBC, 0xE6, 0xE5, + 0x63, 0xA4, 0x40, 0xF2, 0x77, 0x03, 0x7D, 0x81, 0x2D, 0xEB, 0x33, 0xA0, + 0xF4, 0xA1, 0x39, 0x45, 0xD8, 0x98, 0xC2, 0x96, + 0x4F, 0xE3, 0x42, 0xE2, 0xFE, 0x1A, 0x7F, 0x9B, 0x8E, 0xE7, 0xEB, 0x4A, + 0x7C, 0x0F, 0x9E, 0x16, 0x2B, 0xCE, 0x33, 0x57, 0x6B, 0x31, 0x5E, 0xCE, + 0xCB, 0xB6, 0x40, 0x68, 0x37, 0xBF, 0x51, 0xF5 +}; + +static char ecdsa_verf_n_secp256k1[] = { + 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84, + 0xF3, 0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51 +}; + +static char ecdsa_verf_sign_secp256k1[] = { + 0x31, 0x28, 0x18, 0x0d, 0x19, 0x7c, 0xd1, 0xa5, 0xcb, 0x32, 0x95, 0x98, + 0xb6, 0x5f, 0x8c, 0xb8, 0xdf, 0x0b, 0x4e, 0xf3, 0xef, 0x5e, 0x22, 0x79, + 0x7f, 0xe0, 0xdb, 0xf0, 0x33, 0x59, 0x67, 0x01, + 0xeb, 0xd1, 0xca, 0x09, 0x55, 0x6a, 0xbe, 0xd5, 0x32, 0x34, 0xfb, 0xb2, + 0x4f, 0xfc, 0x7d, 0xa3, 0xd1, 0x6d, 0xc9, 0x65, 0x30, 0xca, 0x76, 0x3b, + 0x09, 0xd5, 0xef, 0x6a, 0x65, 0x05, 0x0d, 0x23 +}; + +static char ecdh_verf_pubkey_secp256k1[] = { + 0x04, + 0xab, 0xd2, 0xd9, 0xec, 0x43, 0x60, 0xcc, 0x5b, 0x23, 0x5a, 0x80, 0x74, + 0x2e, 0xbc, 0xb8, 0x36, 0x27, 0xe7, 0xb5, 0x4f, 0x72, 0xc3, 0x4a, 0x05, + 0xe9, 0x70, 0x5a, 0x12, 0x8f, 0xab, 0x95, 0x7c, + 0x6b, 0xf1, 0x84, 0x92, 0x46, 0x7b, 0x81, 0x4e, 0x28, 0x83, 0x25, 0xfb, + 0x1f, 0x60, 0xe9, 0x98, 0xb6, 0x9f, 0xa0, 0xf4, 0x50, 0x3f, 0xa4, 0x1d, + 0x4a, 0x4d, 0x87, 0xb8, 0xe6, 0xe4, 0x81, 0xd4 }; #endif diff --git a/uadk_tool/benchmark/hpre_uadk_benchmark.c b/uadk_tool/benchmark/hpre_uadk_benchmark.c index e3372fb..ffa1a85 100644 --- a/uadk_tool/benchmark/hpre_uadk_benchmark.c +++ b/uadk_tool/benchmark/hpre_uadk_benchmark.c @@ -346,30 +346,40 @@ static int hpre_uadk_param_parse(thread_data *tddata, struct acc_option *options

static int init_hpre_ctx_config(char *alg, int subtype, int mode) { - struct uacce_dev_list *list; struct sched_params param; - int i, max_node; + struct uacce_dev *dev; + int max_node; int ret = 0; + int i = 0;

max_node = numa_max_node() + 1; if (max_node <= 0) return -EINVAL;

- list = wd_get_accel_list(alg); - if (!list) { - HPRE_TST_PRT("failed to get %s device\n", alg); - return -ENODEV; - } memset(&g_ctx_cfg, 0, sizeof(struct wd_ctx_config)); g_ctx_cfg.ctx_num = g_ctxnum; g_ctx_cfg.ctxs = calloc(g_ctxnum, sizeof(struct wd_ctx)); if (!g_ctx_cfg.ctxs) return -ENOMEM;

- for (i = 0; i < g_ctxnum; i++) { - g_ctx_cfg.ctxs[i].ctx = wd_request_ctx(list->dev); - g_ctx_cfg.ctxs[i].op_type = 0; // default op_type - g_ctx_cfg.ctxs[i].ctx_mode = (__u8)mode; + while (i < g_ctxnum) { + dev = wd_get_accel_dev(alg); + if (!dev) { + HPRE_TST_PRT("failed to get %s device\n", alg); + ret = -EINVAL; + goto out; + } + + for (; i < g_ctxnum; i++) { + g_ctx_cfg.ctxs[i].ctx = wd_request_ctx(dev); + if (!g_ctx_cfg.ctxs[i].ctx) + break; + + g_ctx_cfg.ctxs[i].op_type = 0; // default op_type + g_ctx_cfg.ctxs[i].ctx_mode = (__u8)mode; + } + + free(dev); }

switch(subtype) { @@ -395,12 +405,8 @@ static int init_hpre_ctx_config(char *alg, int subtype, int mode) goto out; }

- /* If there is no numa, we defualt config to zero */ - if (list->dev->numa_id < 0) - list->dev->numa_id = 0; - g_sched->name = SCHED_SINGLE; - param.numa_id = list->dev->numa_id; + param.numa_id = 0; param.type = 0; param.mode = mode; param.begin = 0; @@ -434,10 +440,11 @@ static int init_hpre_ctx_config(char *alg, int subtype, int mode) goto out; }

- wd_free_list_accels(list); - return 0; out: + for (i = i - 1; i >= 0; i--) + wd_release_ctx(g_ctx_cfg.ctxs[i].ctx); + free(g_ctx_cfg.ctxs); wd_sched_rr_release(g_sched);

@@ -1964,6 +1971,38 @@ del_ecc_out: return ret; }

+static void fill_ecc_param_data(struct wd_ecc_curve *ecc_pa, + struct hpre_ecc_setup *ecc_set, + u32 key_bits) +{ + u32 key_size = (key_bits + 7) / 8; + + ecc_pa->a.data = ecdsa_verf_a_secp256k1; + ecc_pa->b.data = ecdsa_verf_b_secp256k1; + ecc_pa->p.data = ecdsa_verf_p_secp256k1; + ecc_pa->n.data = ecdsa_verf_n_secp256k1; + ecc_pa->g.x.data = ecdsa_verf_g_secp256k1; + ecc_pa->g.y.data = ecdsa_verf_g_secp256k1 + key_size; + + ecc_set->sign = ecdsa_verf_sign_secp256k1; + ecc_set->sign_size = sizeof(ecdsa_verf_sign_secp256k1); + ecc_set->pub_key = ecdh_verf_pubkey_secp256k1; + ecc_set->pub_key_size = sizeof(ecdh_verf_pubkey_secp256k1); + + ecc_pa->a.bsize = key_size; + ecc_pa->a.dsize = key_size; + ecc_pa->b.bsize = key_size; + ecc_pa->b.dsize = key_size; + ecc_pa->p.bsize = key_size; + ecc_pa->p.dsize = key_size; + ecc_pa->n.bsize = key_size; + ecc_pa->n.dsize = key_size; + ecc_pa->g.x.bsize = key_size; + ecc_pa->g.x.dsize = key_size; + ecc_pa->g.y.bsize = key_size; + ecc_pa->g.y.dsize = key_size; +} + static void *ecc_uadk_sync_run(void *arg) { thread_data *pdata = (thread_data *)arg; @@ -1971,6 +2010,8 @@ static void *ecc_uadk_sync_run(void *arg) u32 subtype = pdata->subtype; struct wd_ecc_sess_setup sess_setup; struct hpre_ecc_setup setup; + struct wd_ecc_curve_cfg cfg; + struct wd_ecc_curve cv; struct wd_ecc_curve param; struct wd_ecc_key *ecc_key; struct wd_ecc_point pbk; @@ -2015,6 +2056,12 @@ static void *ecc_uadk_sync_run(void *arg) case ECDSA_TYPE: sess_setup.alg = "ecdsa"; break; + case X448_TYPE: + sess_setup.alg = "x448"; + break; + case X25519_TYPE: + sess_setup.alg = "x25519"; + break; }

// set def setting; @@ -2025,6 +2072,14 @@ static void *ecc_uadk_sync_run(void *arg) if (ret) return NULL;

+ if (subtype == ECDSA_TYPE && key_size == 32) { + fill_ecc_param_data(&cv, &setup, pdata->keybits); + + cfg.type = WD_CV_CFG_PARAM; + cfg.cfg.pparam = &cv; + sess_setup.cv = cfg; + } + h_sess = wd_ecc_alloc_sess(&sess_setup); if (!h_sess) goto msg_release; @@ -2113,6 +2168,8 @@ static void *ecc_uadk_async_run(void *arg) struct wd_ecc_sess_setup sess_setup; struct rsa_async_tag *tag; struct hpre_ecc_setup setup; + struct wd_ecc_curve_cfg cfg; + struct wd_ecc_curve cv; struct wd_ecc_curve param; struct wd_ecc_key *ecc_key; struct wd_ecc_point pbk; @@ -2158,6 +2215,12 @@ static void *ecc_uadk_async_run(void *arg) case ECDSA_TYPE: sess_setup.alg = "ecdsa"; break; + case X448_TYPE: + sess_setup.alg = "x448"; + break; + case X25519_TYPE: + sess_setup.alg = "x25519"; + break; }

// set def setting; @@ -2168,6 +2231,14 @@ static void *ecc_uadk_async_run(void *arg) if (ret) return NULL;

+ if (subtype == ECDSA_TYPE && key_size == 32) { + fill_ecc_param_data(&cv, &setup, pdata->keybits); + + cfg.type = WD_CV_CFG_PARAM; + cfg.cfg.pparam = &cv; + sess_setup.cv = cfg; + } + h_sess = wd_ecc_alloc_sess(&sess_setup); if (!h_sess) goto msg_release; diff --git a/uadk_tool/benchmark/hpre_wd_benchmark.c b/uadk_tool/benchmark/hpre_wd_benchmark.c index 2e23c95..67d57c6 100644 --- a/uadk_tool/benchmark/hpre_wd_benchmark.c +++ b/uadk_tool/benchmark/hpre_wd_benchmark.c @@ -12,7 +12,7 @@ #include "v1/wd_bmm.h" #include "v1/wd_util.h"

-#define ECC_CURVE_ID 0x3 /* def set secp256k1 */ +#define ECC_CURVE_ID 0x2 /* def set secp256k1 */ #define HPRE_TST_PRT printf #define ERR_OPTYPE 0xFF #define SM2_DG_SZ 1024 @@ -403,33 +403,9 @@ static int hpre_wd_get_block(u32 algtype) case DH_4096: block_size = 8192; break; - case ECDH_256: - block_size = 256; - break; - case ECDH_384: - block_size = 384; - break; - case ECDH_521: - block_size = 576; - break; - case ECDSA_256: - block_size = 256; - break; - case ECDSA_384: - block_size = 384; - break; - case ECDSA_521: + default: block_size = 576; break; - case SM2_ALG: - block_size = 4352; - break; - case X25519_ALG: - block_size = 256; - break; - case X448_ALG: - block_size = 384; - break; }

return block_size; @@ -1759,6 +1735,38 @@ static int get_ecc_param_from_sample(struct hpre_ecc_setup *setup, return 0; }

+static void fill_ecc_cv_data(struct wcrypto_ecc_curve *cv, + struct hpre_ecc_setup *ecc_setup, + u32 key_bits) +{ + u32 key_size = (key_bits + 7) / 8; + + cv->a.data = ecdsa_verf_a_secp256k1; + cv->b.data = ecdsa_verf_b_secp256k1; + cv->p.data = ecdsa_verf_p_secp256k1; + cv->n.data = ecdsa_verf_n_secp256k1; + cv->g.x.data = ecdsa_verf_g_secp256k1; + cv->g.y.data = ecdsa_verf_g_secp256k1 + key_size; + + ecc_setup->sign = ecdsa_verf_sign_secp256k1; + ecc_setup->sign_size = sizeof(ecdsa_verf_sign_secp256k1); + ecc_setup->pub_key = ecdh_verf_pubkey_secp256k1; + ecc_setup->pub_key_size = sizeof(ecdh_verf_pubkey_secp256k1); + + cv->a.bsize = key_size; + cv->a.dsize = key_size; + cv->b.bsize = key_size; + cv->b.dsize = key_size; + cv->p.bsize = key_size; + cv->p.dsize = key_size; + cv->n.bsize = key_size; + cv->n.dsize = key_size; + cv->g.x.bsize = key_size; + cv->g.x.dsize = key_size; + cv->g.y.bsize = key_size; + cv->g.y.dsize = key_size; +} + static int ecdsa_param_fill(void *ctx, struct wcrypto_ecc_op_data *opdata, struct wcrypto_ecc_key *ecc_key, struct hpre_ecc_setup *setup, thread_data *pdata) @@ -2060,6 +2068,8 @@ static void *ecc_wd_sync_run(void *arg) struct wcrypto_ecc_ctx_setup ctx_setup; struct wcrypto_ecc_op_data opdata; struct wcrypto_ecc_curve param; + struct wcrypto_ecc_curve_cfg cfg; + struct wcrypto_ecc_curve cv; struct hpre_ecc_setup setup; struct wcrypto_ecc_key *ecc_key; struct wcrypto_ecc_point pbk; @@ -2114,6 +2124,14 @@ static void *ecc_wd_sync_run(void *arg) if (ret) return NULL;

+ if (subtype == ECDSA_TYPE && key_size == 32) { + fill_ecc_cv_data(&cv, &setup, pdata->keybits); + + cfg.type = WCRYPTO_CV_CFG_PARAM; + cfg.cfg.pparam = &cv; + ctx_setup.cv = cfg; + } + ctx = wcrypto_create_ecc_ctx(queue, &ctx_setup); if (!ctx) goto msg_release; @@ -2208,6 +2226,8 @@ static void *ecc_wd_async_run(void *arg) struct wcrypto_ecc_ctx_setup ctx_setup; struct wcrypto_ecc_op_data opdata; struct wcrypto_ecc_curve param; + struct wcrypto_ecc_curve_cfg cfg; + struct wcrypto_ecc_curve cv; struct hpre_ecc_setup setup; struct wcrypto_ecc_key *ecc_key; struct wcrypto_ecc_point pbk; @@ -2263,6 +2283,14 @@ static void *ecc_wd_async_run(void *arg) if (ret) return NULL;

+ if (subtype == ECDSA_TYPE && key_size == 32) { + fill_ecc_cv_data(&cv, &setup, pdata->keybits); + + cfg.type = WCRYPTO_CV_CFG_PARAM; + cfg.cfg.pparam = &cv; + ctx_setup.cv = cfg; + } + ctx = wcrypto_create_ecc_ctx(queue, &ctx_setup); if (!ctx) goto msg_release;

From: Weili Qian qianweili@huawei.com

Support performance test for TRNG.

Signed-off-by: Weili Qian qianweili@huawei.com --- uadk_tool/Makefile.am | 1 + uadk_tool/benchmark/trng_wd_benchmark.c | 324 ++++++++++++++++++++++++ uadk_tool/benchmark/trng_wd_benchmark.h | 7 + uadk_tool/benchmark/uadk_benchmark.c | 14 + uadk_tool/benchmark/uadk_benchmark.h | 2 + 5 files changed, 348 insertions(+) create mode 100644 uadk_tool/benchmark/trng_wd_benchmark.c create mode 100644 uadk_tool/benchmark/trng_wd_benchmark.h

diff --git a/uadk_tool/Makefile.am b/uadk_tool/Makefile.am index 62372d8..6b787f9 100644 --- a/uadk_tool/Makefile.am +++ b/uadk_tool/Makefile.am @@ -15,6 +15,7 @@ uadk_tool_SOURCES=uadk_tool.c dfx/uadk_dfx.c dfx/uadk_dfx.h \ benchmark/hpre_wd_benchmark.c hpre_wd_benchmark.h \ benchmark/zip_uadk_benchmark.c benchmark/zip_uadk_benchmark.h \ benchmark/zip_wd_benchmark.c benchmark/zip_wd_benchmark.h \ + benchmark/trng_wd_benchmark.c benchmark/trng_wd_benchmark.h \ test/uadk_test.c test/uadk_test.h \ test/test_sec.c test/test_sec.h test/sec_template_tv.h

diff --git a/uadk_tool/benchmark/trng_wd_benchmark.c b/uadk_tool/benchmark/trng_wd_benchmark.c new file mode 100644 index 0000000..64942f0 --- /dev/null +++ b/uadk_tool/benchmark/trng_wd_benchmark.c @@ -0,0 +1,324 @@ +/* SPDX-License-Identifier: Apache-2.0 */ + +#include <numa.h> +#include "uadk_benchmark.h" + +#include "trng_wd_benchmark.h" +#include "v1/wd.h" +#include "v1/wd_rng.h" + +struct thread_bd_res { + struct wd_queue *queue; + void *out; + __u32 in_bytes; +}; + +struct thread_queue_res { + struct thread_bd_res *bd_res; +}; + +struct wd_thread_res { + u32 td_id; + u32 pollid; +}; + +struct trng_async_tag { + void *ctx; + int optype; +}; + +static unsigned int g_thread_num; +static struct thread_queue_res g_thread_queue; + +static int init_trng_wd_queue(struct acc_option *options) +{ + int i, ret; + + g_thread_queue.bd_res = malloc(g_thread_num * sizeof(struct thread_bd_res)); + if (!g_thread_queue.bd_res) { + printf("failed to malloc thread res memory!\n"); + return -ENOMEM; + } + + for (i = 0; i < g_thread_num; i++) { + g_thread_queue.bd_res[i].queue = malloc(sizeof(struct wd_queue)); + if (!g_thread_queue.bd_res[i].queue) { + ret = -ENOMEM; + goto free_mem; + } + + g_thread_queue.bd_res[i].queue->capa.alg = options->algclass; + /* nodemask need to be clean */ + g_thread_queue.bd_res[i].queue->node_mask = 0x0; + memset(g_thread_queue.bd_res[i].queue->dev_path, 0x0, PATH_STR_SIZE); + + g_thread_queue.bd_res[i].in_bytes = options->pktlen; + g_thread_queue.bd_res[i].out = malloc(options->pktlen); + if (!g_thread_queue.bd_res[i].queue) { + free(g_thread_queue.bd_res[i].queue); + ret = -ENOMEM; + goto free_mem; + } + + ret = wd_request_queue(g_thread_queue.bd_res[i].queue); + if (ret) { + printf("failed to request queue %d, ret = %d!\n", i, ret); + free(g_thread_queue.bd_res[i].out); + free(g_thread_queue.bd_res[i].queue); + goto free_mem; + } + } + + return 0; + +free_mem: + for (i = i - 1; i >= 0; i--) { + wd_release_queue(g_thread_queue.bd_res[i].queue); + free(g_thread_queue.bd_res[i].out); + free(g_thread_queue.bd_res[i].queue); + } + + free(g_thread_queue.bd_res); + return ret; +} + +static void uninit_trng_wd_queue(void) +{ + int j; + + for (j = 0; j < g_thread_num; j++) { + wd_release_queue(g_thread_queue.bd_res[j].queue); + free(g_thread_queue.bd_res[j].out); + free(g_thread_queue.bd_res[j].queue); + } + + free(g_thread_queue.bd_res); +} + +static void *trng_wd_sync_run(void *arg) +{ + struct wd_thread_res *pdata = (struct wd_thread_res *)arg; + struct wcrypto_rng_ctx_setup trng_setup; + struct wcrypto_rng_op_data opdata; + struct wd_queue *queue; + void *ctx = NULL; + u32 count = 0; + int ret; + + queue = g_thread_queue.bd_res[pdata->td_id].queue; + ctx = wcrypto_create_rng_ctx(queue, &trng_setup); + if (!ctx) + return NULL; + + memset(&opdata, 0, sizeof(opdata)); + opdata.in_bytes = g_thread_queue.bd_res[pdata->td_id].in_bytes; + opdata.out = g_thread_queue.bd_res[pdata->td_id].out; + opdata.op_type = WCRYPTO_TRNG_GEN; + + do { + ret = wcrypto_do_rng(ctx, &opdata, NULL); + if (ret) { + printf("failed to do rng task, ret: %d\n", ret); + goto ctx_release; + } + + count++; + if (get_run_state() == 0) + break; + } while (true); + +ctx_release: + wcrypto_del_rng_ctx(ctx); + add_recv_data(count, opdata.in_bytes); + + return NULL; +} + +static void trng_wd_sync_threads(void) +{ + struct wd_thread_res threads_args[THREADS_NUM]; + pthread_t tdid[THREADS_NUM]; + int i, ret; + + for (i = 0; i < g_thread_num; i++) { + threads_args[i].td_id = i; + ret = pthread_create(&tdid[i], NULL, trng_wd_sync_run, &threads_args[i]); + if (ret) { + printf("failed to create sync thread!\n"); + return; + } + } + + /* join thread */ + for (i = 0; i < g_thread_num; i++) { + ret = pthread_join(tdid[i], NULL); + if (ret) { + printf("failed to join sync thread!\n"); + return; + } + } +} + +void *wd_trng_poll(void *data) +{ + struct wd_thread_res *pdata = (struct wd_thread_res *)data; + struct wd_queue *queue; + u32 last_time = 2; // poll need one more recv time + u32 count = 0; + u32 in_bytes; + int recv; + + in_bytes = g_thread_queue.bd_res[pdata->pollid].in_bytes; + queue = g_thread_queue.bd_res[pdata->pollid].queue; + + while (last_time) { + recv = wcrypto_rng_poll(queue, ACC_QUEUE_SIZE); + if (recv < 0) { + printf("failed to recv bd, ret: %d!\n", recv); + goto recv_error; + } + count += recv; + + if (get_run_state() == 0) + last_time--; + } + +recv_error: + add_recv_data(count, in_bytes); + + return NULL; +} + +static void *trng_async_cb(const void *msg, void *tag) +{ + return NULL; +} + +static void *wd_trng_async_run(void *arg) +{ + struct wd_thread_res *pdata = (struct wd_thread_res *)arg; + struct wcrypto_rng_ctx_setup trng_setup; + struct wcrypto_rng_op_data opdata; + struct trng_async_tag *tag = NULL; + struct wd_queue *queue; + void *ctx = NULL; + int ret, i; + + memset(&opdata, 0, sizeof(opdata)); + + queue = g_thread_queue.bd_res[pdata->td_id].queue; + trng_setup.cb = (void *)trng_async_cb; + + ctx = wcrypto_create_rng_ctx(queue, &trng_setup); + if (!ctx) + return NULL; + + opdata.in_bytes = g_thread_queue.bd_res[pdata->td_id].in_bytes; + opdata.out = g_thread_queue.bd_res[pdata->td_id].out; + opdata.op_type = WCRYPTO_TRNG_GEN; + + tag = malloc(sizeof(*tag) * MAX_POOL_LENTH); + if (!tag) { + printf("failed to malloc dh tag!\n"); + goto free_ctx; + } + tag->ctx = ctx; + + do { + ret = wcrypto_do_rng(ctx, &opdata, tag); + if (ret && ret != -WD_EBUSY) { + printf("failed to send trng task, ret = %d!\n", ret); + break; + } + + if (get_run_state() == 0) + break; + } while (true); + + /* Release memory after all tasks are complete. */ + i = 0; + while (get_recv_time() != g_thread_num) { + if (i++ >= MAX_TRY_CNT) { + printf("failed to wait poll thread finish!\n"); + break; + } + + usleep(SEND_USLEEP); + } + + if (tag) + free(tag); +free_ctx: + wcrypto_del_rng_ctx(ctx); + add_send_complete(); + + return NULL; +} + +static void trng_wd_async_threads(void) +{ + struct wd_thread_res threads_args[THREADS_NUM]; + pthread_t tdid[THREADS_NUM]; + pthread_t pollid[THREADS_NUM]; + int i, ret; + + for (i = 0; i < g_thread_num; i++) { + threads_args[i].pollid = i; + /* poll thread */ + ret = pthread_create(&pollid[i], NULL, wd_trng_poll, &threads_args[i]); + if (ret) { + printf("failed to create poll thread!\n"); + return; + } + } + + for (i = 0; i < g_thread_num; i++) { + threads_args[i].td_id = i; + ret = pthread_create(&tdid[i], NULL, wd_trng_async_run, &threads_args[i]); + if (ret) { + printf("failed to create async thread!\n"); + return; + } + } + + /* join thread */ + for (i = 0; i < g_thread_num; i++) { + ret = pthread_join(tdid[i], NULL); + if (ret) { + printf("failed to join async thread!\n"); + return; + } + } + + for (i = 0; i < g_thread_num; i++) { + ret = pthread_join(pollid[i], NULL); + if (ret) { + printf("failed to join poll thread!\n"); + return; + } + } +} + +int trng_wd_benchmark(struct acc_option *options) +{ + u32 ptime; + int ret; + + g_thread_num = options->threads; + + ret = init_trng_wd_queue(options); + if (ret) + return ret; + + get_pid_cpu_time(&ptime); + time_start(options->times); + if (options->syncmode) + trng_wd_async_threads(); + else + trng_wd_sync_threads(); + cal_perfermance_data(options, ptime); + + uninit_trng_wd_queue(); + + return 0; +} diff --git a/uadk_tool/benchmark/trng_wd_benchmark.h b/uadk_tool/benchmark/trng_wd_benchmark.h new file mode 100644 index 0000000..49453c8 --- /dev/null +++ b/uadk_tool/benchmark/trng_wd_benchmark.h @@ -0,0 +1,7 @@ +/* SPDX-License-Identifier: Apache-2.0 */ + +#ifndef TRNG_WD_BENCHMARK_H +#define TRNG_WD_BENCHMARK_H + +extern int trng_wd_benchmark(struct acc_option *options); +#endif /* TRNG_WD_BENCHMARK_H */ diff --git a/uadk_tool/benchmark/uadk_benchmark.c b/uadk_tool/benchmark/uadk_benchmark.c index f36cc4b..f903829 100644 --- a/uadk_tool/benchmark/uadk_benchmark.c +++ b/uadk_tool/benchmark/uadk_benchmark.c @@ -14,6 +14,8 @@ #include "zip_uadk_benchmark.h" #include "zip_wd_benchmark.h"

+#include "trng_wd_benchmark.h" + #define TABLE_SPACE_SIZE 8

/*----------------------------------------head struct--------------------------------------------------------*/ @@ -131,6 +133,7 @@ static struct acc_alg_item alg_options[] = { {"sha512", SHA512_ALG}, {"sha512-224", SHA512_224}, {"sha512-256", SHA512_256}, + {"trng", TRNG}, {"", ALG_MAX} };

@@ -345,6 +348,11 @@ static void parse_alg_param(struct acc_option *option) option->acctype = HPRE_TYPE; option->subtype = X448_TYPE; break; + case TRNG: + snprintf(option->algclass, MAX_ALG_NAME, "%s", "trng"); + option->acctype = TRNG_TYPE; + option->subtype = DEFAULT_TYPE; + break; default: if (option->algtype <= RSA_4096_CRT) { snprintf(option->algclass, MAX_ALG_NAME, "%s", "rsa"); @@ -456,6 +464,12 @@ static int benchmark_run(struct acc_option *option) } else if (option->modetype & NOSVA_MODE) { ret = zip_wd_benchmark(option); } + case TRNG_TYPE: + if (option->modetype & SVA_MODE) + ACC_TST_PRT("TRNG not support sva mode..\n"); + else if (option->modetype & NOSVA_MODE) + ret = trng_wd_benchmark(option); + break; }

diff --git a/uadk_tool/benchmark/uadk_benchmark.h b/uadk_tool/benchmark/uadk_benchmark.h index 2c8de11..44e2dd9 100644 --- a/uadk_tool/benchmark/uadk_benchmark.h +++ b/uadk_tool/benchmark/uadk_benchmark.h @@ -78,6 +78,7 @@ enum acc_type { SEC_TYPE, HPRE_TYPE, ZIP_TYPE, + TRNG_TYPE, };

enum alg_type { @@ -174,6 +175,7 @@ enum test_alg { SHA512_ALG, SHA512_224, SHA512_256, // digest key all set 4 Bytes + TRNG, ALG_MAX, };

From: Wenkai Lin linwenkai6@hisilicon.com

The structure of the nosva aead input and output are as follows : AEAD encryption input: assoc data || plaintext AEAD encryption output: assoc data || ciphertext || auth tag AEAD decryption input: assoc data || ciphertext || auth tag AEAD decryption output: assoc data || plaintext

First, we store the encrypted result in a file, and then use the encrypted result as input for decryption.

Signed-off-by: Wenkai Lin linwenkai6@hisilicon.com --- uadk_tool/benchmark/sec_wd_benchmark.c | 165 +++++++++++++++++++++++-- 1 file changed, 157 insertions(+), 8 deletions(-)

diff --git a/uadk_tool/benchmark/sec_wd_benchmark.c b/uadk_tool/benchmark/sec_wd_benchmark.c index 739c49e..95222c5 100644 --- a/uadk_tool/benchmark/sec_wd_benchmark.c +++ b/uadk_tool/benchmark/sec_wd_benchmark.c @@ -14,6 +14,10 @@ #define MAX_IVK_LENTH 64 #define DEF_IVK_DATA 0xAA #define SQE_SIZE 128 +#define SEC_AAD_LEN 16 +#define SEC_PERF_KEY_LEN 16 +#define SEC_SAVE_FILE_LEN 64 +#define SEC_MAC_LEN 16

typedef struct wd_thread_res { u32 subtype; @@ -46,10 +50,134 @@ struct wcrypto_async_tag { int cnt; };

+struct aead_alg_info { + int index; + char *name; + unsigned int mac_len; +}; + static struct thread_queue_res g_thread_queue; static unsigned int g_thread_num; static unsigned int g_pktlen;

+static unsigned int g_alg; +static unsigned int g_algtype; +static unsigned int g_optype; + +static char wd_aead_key[] = "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7" + "\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf"; + +static char wd_aead_aad[] = "\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7" + "\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf"; + +static struct aead_alg_info wd_aead_info[] = { + { + .index = AES_128_CCM, + .name = "AES_128_CCM", + .mac_len = 16, + }, { + .index = AES_128_GCM, + .name = "AES_128_GCM", + .mac_len = 16, + }, { + .index = AES_128_CBC_SHA256_HMAC, + .name = "AES_128_CBC_SHA256_HMAC", + .mac_len = 32, + }, { + .index = SM4_128_GCM, + .name = "SM4_128_GCM", + .mac_len = 16, + }, { + .index = SM4_128_CCM, + .name = "SM4_128_CCM", + .mac_len = 16, + }, +}; + +static char *get_aead_alg_name(int algtype) +{ + int table_size = ARRAY_SIZE(wd_aead_info); + int i; + + for (i = 0; i < table_size; i++) { + if (algtype == wd_aead_info[i].index) + return wd_aead_info[i].name; + } + + SEC_TST_PRT("failed to get the aead alg name\n"); + + return NULL; +} + +static void init_aead_enc_input(u8 *addr, u32 size) +{ + memset(addr, 0, size); + memcpy(addr, wd_aead_aad, SEC_AAD_LEN); +} + +static void save_aead_enc_output(u8 *addr, u32 size) +{ + char file_name[SEC_SAVE_FILE_LEN] = {0}; + char *alg_name; + FILE *fp; + + alg_name = get_aead_alg_name(g_algtype); + if (!alg_name) { + SEC_TST_PRT("failed to get the aead alg name!\n"); + return; + } + + snprintf(file_name, SEC_SAVE_FILE_LEN, "ctext_%s_%u_WD", alg_name, g_pktlen); + + fp = fopen(file_name, "w"); + if (!fp) { + SEC_TST_PRT("failed to open the ctext file!\n"); + return; + } + + for (int i = 0; i < size; i++) + fputc((char)addr[i], fp); + + fclose(fp); +} + +static void init_aead_dec_input(u8 *addr, u32 size) +{ + char file_name[SEC_SAVE_FILE_LEN] = {0}; + char *alg_name; + FILE *fp; + int read_size; + + alg_name = get_aead_alg_name(g_algtype); + if (!alg_name) { + SEC_TST_PRT("failed to get the aead alg name!\n"); + return; + } + + snprintf(file_name, SEC_SAVE_FILE_LEN, "ctext_%s_%u_WD", alg_name, g_pktlen); + + fp = fopen(file_name, "r"); + if (!fp) { + SEC_TST_PRT("failed to open the ctext file!\n"); + return; + } + + fseek(fp, 0, SEEK_END); + size = ftell(fp); + + rewind(fp); + read_size = fread(addr, 1, size, fp); + if (read_size != size) { + SEC_TST_PRT("failed to read enough data from ctext!\n"); + fclose(fp); + return; + } + + addr[size] = '\0'; + + fclose(fp); +} + static void *cipher_async_cb(void *message, void *cipher_tag) { return NULL; @@ -434,6 +562,15 @@ static int init_wd_queue(struct acc_option *options) ret = -ENOMEM; goto in_err; } + if (g_alg == AEAD_TYPE) { + if (!g_optype) { + init_aead_enc_input(g_thread_queue.bd_res[m].in[idx], + g_pktlen + SEC_AAD_LEN); + } else { + init_aead_dec_input(g_thread_queue.bd_res[m].in[idx], + g_pktlen + SEC_AAD_LEN + SEC_MAC_LEN); + } + } } }

@@ -509,6 +646,11 @@ static void uninit_wd_queue(void) { int i, j, idx;

+ // save aad + ciphertxt + mac to file. + if (g_alg == AEAD_TYPE && !g_optype) + save_aead_enc_output(g_thread_queue.bd_res[0].out[0], + g_pktlen + SEC_AAD_LEN + SEC_MAC_LEN); + for (i = 0; i < g_thread_num; i++) { for (idx = 0; idx < MAX_POOL_LENTH; idx++) { wd_free_blk(g_thread_queue.bd_res[i].pool, g_thread_queue.bd_res[i].iv[idx]); @@ -642,7 +784,7 @@ static void *sec_wd_cipher_async(void *arg) goto tag_err; }

- if (queue->capa.priv.direction == 0) + if (!g_optype) copdata.op_type = WCRYPTO_CIPHER_ENCRYPTION; else copdata.op_type = WCRYPTO_CIPHER_DECRYPTION; @@ -728,7 +870,7 @@ static void *sec_wd_aead_async(void *arg) res_iv = bd_res->iv;

memset(priv_key, DEF_IVK_DATA, MAX_IVK_LENTH); - memset(priv_hash, DEF_IVK_DATA, MAX_IVK_LENTH); + memcpy(priv_hash, wd_aead_key, SEC_PERF_KEY_LEN); tag = malloc(sizeof(struct wcrypto_async_tag)); // set the user tag if (!tag) { SEC_TST_PRT("wcrypto async alloc tag fail!\n"); @@ -781,7 +923,7 @@ static void *sec_wd_aead_async(void *arg) goto tag_err; }

- if (queue->capa.priv.direction == 0) { + if (!g_optype) { aopdata.op_type = WCRYPTO_CIPHER_ENCRYPTION_DIGEST; aopdata.out_bytes = g_pktlen + 32; // aad + plen + authsize; } else { @@ -791,7 +933,6 @@ static void *sec_wd_aead_async(void *arg)

aopdata.assoc_size = 16; aopdata.in_bytes = g_pktlen; - aopdata.out_bytes = g_pktlen; aopdata.iv_bytes = pdata->ivsize; aopdata.priv = NULL; aopdata.out_buf_bytes = g_pktlen * 2; @@ -800,6 +941,7 @@ static void *sec_wd_aead_async(void *arg) aopdata.in = res_in[0]; aopdata.out = res_out[0]; aopdata.iv = res_iv[0]; + memset(aopdata.iv, DEF_IVK_DATA, MAX_IVK_LENTH); usleep(SEND_USLEEP); while(1) { if (get_run_state() == 0) @@ -1002,7 +1144,7 @@ static void *sec_wd_cipher_sync(void *arg) return NULL; }

- if (queue->capa.priv.direction == 0) + if (!g_optype) copdata.op_type = WCRYPTO_CIPHER_ENCRYPTION; else copdata.op_type = WCRYPTO_CIPHER_DECRYPTION; @@ -1077,7 +1219,7 @@ static void *sec_wd_aead_sync(void *arg) res_iv = bd_res->iv;

memset(priv_key, DEF_IVK_DATA, MAX_IVK_LENTH); - memset(priv_hash, DEF_IVK_DATA, MAX_IVK_LENTH); + memcpy(priv_hash, wd_aead_key, SEC_PERF_KEY_LEN);

aead_setup.calg = pdata->alg; aead_setup.cmode = pdata->mode; @@ -1122,7 +1264,7 @@ static void *sec_wd_aead_sync(void *arg) return NULL; }

- if (queue->capa.priv.direction == 0) { + if (!g_optype) { aopdata.op_type = WCRYPTO_CIPHER_ENCRYPTION_DIGEST; aopdata.out_bytes = g_pktlen + 32; // aad + plen + authsize; } else { @@ -1132,7 +1274,6 @@ static void *sec_wd_aead_sync(void *arg)

aopdata.assoc_size = 16; aopdata.in_bytes = g_pktlen; - aopdata.out_bytes = g_pktlen; aopdata.iv_bytes = pdata->ivsize; aopdata.priv = NULL; aopdata.out_buf_bytes = g_pktlen * 2; @@ -1140,6 +1281,7 @@ static void *sec_wd_aead_sync(void *arg) aopdata.in = res_in[0]; aopdata.out = res_out[0]; aopdata.iv = res_iv[0]; + memset(aopdata.iv, DEF_IVK_DATA, MAX_IVK_LENTH); usleep(SEND_USLEEP); while(1) { if (get_run_state() == 0) @@ -1290,7 +1432,9 @@ int sec_wd_sync_threads(struct acc_option *options) for (i = 0; i < g_thread_num; i++) { threads_args[i].subtype = threads_option.subtype; threads_args[i].alg = threads_option.alg; + threads_args[i].dalg = threads_option.dalg; threads_args[i].mode = threads_option.mode; + threads_args[i].is_union = threads_option.is_union; threads_args[i].keysize = threads_option.keysize; threads_args[i].ivsize = threads_option.ivsize; threads_args[i].optype = threads_option.optype; @@ -1357,7 +1501,9 @@ int sec_wd_async_threads(struct acc_option *options) for (i = 0; i < g_thread_num; i++) { threads_args[i].subtype = threads_option.subtype; threads_args[i].alg = threads_option.alg; + threads_args[i].dalg = threads_option.dalg; threads_args[i].mode = threads_option.mode; + threads_args[i].is_union = threads_option.is_union; threads_args[i].keysize = threads_option.keysize; threads_args[i].ivsize = threads_option.ivsize; threads_args[i].optype = threads_option.optype; @@ -1395,6 +1541,9 @@ int sec_wd_benchmark(struct acc_option *options) u32 ptime; int ret;

+ g_alg = options->subtype; + g_algtype = options->algtype; + g_optype = options->optype; g_thread_num = options->threads; g_pktlen = options->pktlen; if (options->optype > WCRYPTO_CIPHER_DECRYPTION) {

From: Yang Shen shenyang39@huawei.com

1.The decompression performance is depends on the compression ratio, usually based on 50%. So adjust the compression source data to make the compression ratio near 50%. 2.The per-thread data pool depth determines the size of memory. 4096 is too big for EVB environment. So limit to 512 for compression. 3.The req.src_len will be override after do compression. So need to use 'g_pktlen' to calculate length.

Signed-off-by: Yang Shen shenyang39@huawei.com --- uadk_tool/benchmark/uadk_benchmark.c | 2 +- uadk_tool/benchmark/zip_uadk_benchmark.c | 75 +++++++++++------------ uadk_tool/benchmark/zip_wd_benchmark.c | 76 +++++++++++------------- 3 files changed, 71 insertions(+), 82 deletions(-)

diff --git a/uadk_tool/benchmark/uadk_benchmark.c b/uadk_tool/benchmark/uadk_benchmark.c index d869688..aa884bc 100644 --- a/uadk_tool/benchmark/uadk_benchmark.c +++ b/uadk_tool/benchmark/uadk_benchmark.c @@ -429,7 +429,7 @@ void cal_perfermance_data(struct acc_option *option, u32 sttime) ops = perfops / option->times; cpu_rate = (double)ptime / option->times; ACC_TST_PRT("algname: length: perf: iops: CPU_rate:\n" - "%s %-2uBytes %.1fKB/s %.1fKops %.2f%%\n", + "%s %-2uBytes %.1fKB/s %.1fKops %.2f%%\n", palgname, option->pktlen, perfermance, ops, cpu_rate); }

diff --git a/uadk_tool/benchmark/zip_uadk_benchmark.c b/uadk_tool/benchmark/zip_uadk_benchmark.c index 747172a..44746f6 100644 --- a/uadk_tool/benchmark/zip_uadk_benchmark.c +++ b/uadk_tool/benchmark/zip_uadk_benchmark.c @@ -13,6 +13,8 @@ #define ZIP_FILE "./zip" #define COMP_LEN_RATE 2 #define DECOMP_LEN_RATE 2 +#define MAX_POOL_LENTH_COMP 512 +#define COMPRESSION_RATIO_FACTOR 0.7

struct uadk_bd { u8 *src; @@ -54,7 +56,7 @@ typedef struct uadk_thread_res { struct zip_file_head { u32 file_size; u32 block_num; - u32 blk_sz[MAX_POOL_LENTH]; + u32 blk_sz[MAX_POOL_LENTH_COMP]; };

static struct wd_ctx_config g_ctx_cfg; @@ -115,11 +117,11 @@ static int save_file_data(const char *alg, u32 pkg_len, u32 optype) }

// init file head informations - for (j = 0; j < MAX_POOL_LENTH; j++) { + for (j = 0; j < MAX_POOL_LENTH_COMP; j++) { fhead->blk_sz[j] = g_zip_pool.pool[0].bds[j].dst_len; total_file_size += fhead->blk_sz[j]; } - fhead->block_num = MAX_POOL_LENTH; + fhead->block_num = MAX_POOL_LENTH_COMP; fhead->file_size = total_file_size; size = write(fd, fhead, sizeof(*fhead)); if (size < 0) { @@ -129,7 +131,7 @@ static int save_file_data(const char *alg, u32 pkg_len, u32 optype) }

// write data for one buffer one buffer to file line. - for (j = 0; j < MAX_POOL_LENTH; j++) { + for (j = 0; j < MAX_POOL_LENTH_COMP; j++) { size = write(fd, g_zip_pool.pool[0].bds[j].dst, fhead->blk_sz[j]); if (size < 0) { @@ -144,7 +146,7 @@ write_error: fd_error: close(fd);

- full_size = g_pktlen * MAX_POOL_LENTH; + full_size = g_pktlen * MAX_POOL_LENTH_COMP; comp_rate = (double) total_file_size / full_size; ZIP_TST_PRT("compress data rate: %.1f%%!\n", comp_rate * 100);

@@ -187,14 +189,14 @@ static int load_file_data(const char *alg, u32 pkg_len, u32 optype) goto fd_err; } size = read(fd, fhead, sizeof(*fhead)); - if (size < 0 || fhead->block_num != MAX_POOL_LENTH) { + if (size < 0 || fhead->block_num != MAX_POOL_LENTH_COMP) { ZIP_TST_PRT("failed to read file head\n"); ret = -EINVAL; goto read_err; }

// read data for one buffer one buffer from file line - for (j = 0; j < MAX_POOL_LENTH; j++) { + for (j = 0; j < MAX_POOL_LENTH_COMP; j++) { memset(g_zip_pool.pool[0].bds[j].src, 0x0, g_zip_pool.pool[0].bds[j].src_len); if (size != 0) { // zero size buffer no need to read; @@ -212,7 +214,7 @@ static int load_file_data(const char *alg, u32 pkg_len, u32 optype) }

for (i = 1; i < g_thread_num; i++) { - for (j = 0; j < MAX_POOL_LENTH; j++) { + for (j = 0; j < MAX_POOL_LENTH_COMP; j++) { if (g_zip_pool.pool[0].bds[j].src_len) memcpy(g_zip_pool.pool[i].bds[j].src, g_zip_pool.pool[0].bds[j].src, @@ -383,14 +385,14 @@ static int init_uadk_bd_pool(u32 optype) return -ENOMEM; } else { for (i = 0; i < g_thread_num; i++) { - g_zip_pool.pool[i].bds = malloc(MAX_POOL_LENTH * + g_zip_pool.pool[i].bds = malloc(MAX_POOL_LENTH_COMP * sizeof(struct uadk_bd)); if (!g_zip_pool.pool[i].bds) { ZIP_TST_PRT("init uadk bds alloc failed!\n"); goto malloc_error1; } - for (j = 0; j < MAX_POOL_LENTH; j++) { - g_zip_pool.pool[i].bds[j].src = malloc(insize); + for (j = 0; j < MAX_POOL_LENTH_COMP; j++) { + g_zip_pool.pool[i].bds[j].src = calloc(1, insize); if (!g_zip_pool.pool[i].bds[j].src) goto malloc_error2; g_zip_pool.pool[i].bds[j].src_len = insize; @@ -400,7 +402,7 @@ static int init_uadk_bd_pool(u32 optype) goto malloc_error3; g_zip_pool.pool[i].bds[j].dst_len = outsize;

- get_rand_data(g_zip_pool.pool[i].bds[j].src, insize); + get_rand_data(g_zip_pool.pool[i].bds[j].src, insize * COMPRESSION_RATIO_FACTOR); if (g_prefetch) get_rand_data(g_zip_pool.pool[i].bds[j].dst, outsize); } @@ -418,7 +420,7 @@ malloc_error2: } malloc_error1: for (i--; i >= 0; i--) { - for (j = 0; j < MAX_POOL_LENTH; j++) { + for (j = 0; j < MAX_POOL_LENTH_COMP; j++) { free(g_zip_pool.pool[i].bds[j].src); free(g_zip_pool.pool[i].bds[j].dst); } @@ -438,7 +440,7 @@ static void free_uadk_bd_pool(void)

for (i = 0; i < g_thread_num; i++) { if (g_zip_pool.pool[i].bds) { - for (j = 0; j < MAX_POOL_LENTH; j++) { + for (j = 0; j < MAX_POOL_LENTH_COMP; j++) { free(g_zip_pool.pool[i].bds[j].src); free(g_zip_pool.pool[i].bds[j].dst); } @@ -565,17 +567,17 @@ static void *zip_uadk_blk_lz77_sync_run(void *arg) creq.data_fmt = 0; creq.status = 0;

- ftuple = malloc(sizeof(COMP_TUPLE_TAG) * MAX_POOL_LENTH); + ftuple = malloc(sizeof(COMP_TUPLE_TAG) * MAX_POOL_LENTH_COMP); if (!ftuple) goto fse_err;

- hw_buff_out = malloc(out_len * MAX_POOL_LENTH); + hw_buff_out = malloc(out_len * MAX_POOL_LENTH_COMP); if (!hw_buff_out) goto hw_buff_err; - memset(hw_buff_out, 0x0, out_len * MAX_POOL_LENTH); + memset(hw_buff_out, 0x0, out_len * MAX_POOL_LENTH_COMP);

while(1) { - i = count % MAX_POOL_LENTH; + i = count % MAX_POOL_LENTH_COMP; creq.src = uadk_pool->bds[i].src; creq.dst = &hw_buff_out[i]; //temp out creq.src_len = uadk_pool->bds[i].src_len; @@ -610,7 +612,7 @@ fse_err:

cal_avg_latency(count); if (pdata->optype == WD_DIR_COMPRESS) - add_recv_data(count, creq.src_len); + add_recv_data(count, g_pktlen); else add_recv_data(count, first_len);

@@ -659,17 +661,17 @@ static void *zip_uadk_stm_lz77_sync_run(void *arg) creq.data_fmt = 0; creq.status = 0;

- ftuple = malloc(sizeof(COMP_TUPLE_TAG) * MAX_POOL_LENTH); + ftuple = malloc(sizeof(COMP_TUPLE_TAG) * MAX_POOL_LENTH_COMP); if (!ftuple) goto fse_err;

- hw_buff_out = malloc(out_len * MAX_POOL_LENTH); + hw_buff_out = malloc(out_len * MAX_POOL_LENTH_COMP); if (!hw_buff_out) goto hw_buff_err; - memset(hw_buff_out, 0x0, out_len * MAX_POOL_LENTH); + memset(hw_buff_out, 0x0, out_len * MAX_POOL_LENTH_COMP);

while(1) { - i = count % MAX_POOL_LENTH; + i = count % MAX_POOL_LENTH_COMP; creq.src = uadk_pool->bds[i].src; creq.dst = &hw_buff_out[i]; //temp out creq.src_len = uadk_pool->bds[i].src_len; @@ -707,7 +709,7 @@ fse_err:

cal_avg_latency(count); if (pdata->optype == WD_DIR_COMPRESS) - add_recv_data(count, creq.src_len); + add_recv_data(count, g_pktlen); else add_recv_data(count, first_len);

@@ -754,16 +756,16 @@ static void *zip_uadk_blk_lz77_async_run(void *arg) creq.data_fmt = 0; creq.status = 0;

- ftuple = malloc(sizeof(COMP_TUPLE_TAG) * MAX_POOL_LENTH); + ftuple = malloc(sizeof(COMP_TUPLE_TAG) * MAX_POOL_LENTH_COMP); if (!ftuple) goto fse_err;

- hw_buff_out = malloc(out_len * MAX_POOL_LENTH); + hw_buff_out = malloc(out_len * MAX_POOL_LENTH_COMP); if (!hw_buff_out) goto hw_buff_err; - memset(hw_buff_out, 0x0, out_len * MAX_POOL_LENTH); + memset(hw_buff_out, 0x0, out_len * MAX_POOL_LENTH_COMP);

- tag = malloc(sizeof(*tag) * MAX_POOL_LENTH); + tag = malloc(sizeof(*tag) * MAX_POOL_LENTH_COMP); if (!tag) { ZIP_TST_PRT("failed to malloc zip tag!\n"); goto tag_err; @@ -774,7 +776,7 @@ static void *zip_uadk_blk_lz77_async_run(void *arg) break;

try_cnt = 0; - i = count % MAX_POOL_LENTH; + i = count % MAX_POOL_LENTH_COMP; creq.src = uadk_pool->bds[i].src; creq.dst = &hw_buff_out[i]; //temp out creq.src_len = uadk_pool->bds[i].src_len; @@ -815,10 +817,6 @@ hw_buff_err: fse_err: free(ftuple); wd_comp_free_sess(h_sess); - - // ZIP_TST_PRT("LZ77 valid pool len: %u, send count BD: %u, output len: %u!\n", - // MAX_POOL_LENTH, count, creq.dst_len); - add_send_complete();

return NULL; @@ -861,7 +859,7 @@ static void *zip_uadk_blk_sync_run(void *arg) creq.status = 0;

while(1) { - i = count % MAX_POOL_LENTH; + i = count % MAX_POOL_LENTH_COMP; creq.src = uadk_pool->bds[i].src; creq.dst = uadk_pool->bds[i].dst; creq.src_len = uadk_pool->bds[i].src_len; @@ -921,7 +919,7 @@ static void *zip_uadk_stm_sync_run(void *arg) creq.status = 0;

while(1) { - i = count % MAX_POOL_LENTH; + i = count % MAX_POOL_LENTH_COMP; creq.src = uadk_pool->bds[i].src; creq.dst = uadk_pool->bds[i].dst; creq.src_len = uadk_pool->bds[i].src_len; @@ -986,7 +984,7 @@ static void *zip_uadk_blk_async_run(void *arg) creq.priv = 0; creq.status = 0;

- tag = malloc(sizeof(*tag) * MAX_POOL_LENTH); + tag = malloc(sizeof(*tag) * MAX_POOL_LENTH_COMP); if (!tag) { ZIP_TST_PRT("failed to malloc zip tag!\n"); wd_comp_free_sess(h_sess); @@ -998,7 +996,7 @@ static void *zip_uadk_blk_async_run(void *arg) break;

try_cnt = 0; - i = count % MAX_POOL_LENTH; + i = count % MAX_POOL_LENTH_COMP; creq.src = uadk_pool->bds[i].src; creq.dst = uadk_pool->bds[i].dst; creq.src_len = uadk_pool->bds[i].src_len; @@ -1032,9 +1030,6 @@ static void *zip_uadk_blk_async_run(void *arg) free(tag); wd_comp_free_sess(h_sess);

- // ZIP_TST_PRT("valid pool len: %u, send count BD: %u, output len: %u!\n", - // MAX_POOL_LENTH, count, creq.dst_len); - add_send_complete();

return NULL; diff --git a/uadk_tool/benchmark/zip_wd_benchmark.c b/uadk_tool/benchmark/zip_wd_benchmark.c index dc00631..61f6c69 100644 --- a/uadk_tool/benchmark/zip_wd_benchmark.c +++ b/uadk_tool/benchmark/zip_wd_benchmark.c @@ -18,6 +18,8 @@

#define COMP_LEN_RATE 2 #define DECOMP_LEN_RATE 2 +#define COMPRESSION_RATIO_FACTOR 0.7 +#define MAX_POOL_LENTH_COMP 512

#define __ALIGN_MASK(x, mask) (((x) + (mask)) & ~(mask)) #define ALIGN(x, a) __ALIGN_MASK(x, (typeof(x))(a)-1) @@ -67,7 +69,7 @@ typedef struct uadk_thread_res { struct zip_file_head { u32 file_size; u32 block_num; - u32 blk_sz[MAX_POOL_LENTH]; + u32 blk_sz[MAX_POOL_LENTH_COMP]; };

static unsigned int g_thread_num; @@ -124,11 +126,11 @@ static int save_file_data(const char *alg, u32 pkg_len, u32 optype) }

// init file head informations - for (j = 0; j < MAX_POOL_LENTH; j++) { + for (j = 0; j < MAX_POOL_LENTH_COMP; j++) { fhead->blk_sz[j] = g_thread_queue.bd_res[0].bds[j].dst_len; total_file_size += fhead->blk_sz[j]; } - fhead->block_num = MAX_POOL_LENTH; + fhead->block_num = MAX_POOL_LENTH_COMP; fhead->file_size = total_file_size; size = write(fd, fhead, sizeof(*fhead)); if (size < 0) { @@ -138,7 +140,7 @@ static int save_file_data(const char *alg, u32 pkg_len, u32 optype) }

// write data for one buffer one buffer to file line. - for (j = 0; j < MAX_POOL_LENTH; j++) { + for (j = 0; j < MAX_POOL_LENTH_COMP; j++) { size = write(fd, g_thread_queue.bd_res[0].bds[j].dst, fhead->blk_sz[j]); if (size < 0) { @@ -153,7 +155,7 @@ write_error: fd_error: close(fd);

- full_size = g_pktlen * MAX_POOL_LENTH; + full_size = g_pktlen * MAX_POOL_LENTH_COMP; comp_rate = (double) total_file_size / full_size; ZIP_TST_PRT("compress data rate: %.1f%%!\n", comp_rate * 100);

@@ -196,14 +198,14 @@ static int load_file_data(const char *alg, u32 pkg_len, u32 optype) goto fd_err; } size = read(fd, fhead, sizeof(*fhead)); - if (size < 0 || fhead->block_num != MAX_POOL_LENTH) { + if (size < 0 || fhead->block_num != MAX_POOL_LENTH_COMP) { ZIP_TST_PRT("failed to read file head\n"); ret = -EINVAL; goto read_err; }

// read data for one buffer one buffer from file line - for (j = 0; j < MAX_POOL_LENTH; j++) { + for (j = 0; j < MAX_POOL_LENTH_COMP; j++) { memset(g_thread_queue.bd_res[0].bds[j].src, 0x0, g_thread_queue.bd_res[0].bds[j].src_len); if (size != 0) { // zero size buffer no need to read; @@ -221,7 +223,7 @@ static int load_file_data(const char *alg, u32 pkg_len, u32 optype) }

for (i = 1; i < g_thread_num; i++) { - for (j = 0; j < MAX_POOL_LENTH; j++) { + for (j = 0; j < MAX_POOL_LENTH_COMP; j++) { if (g_thread_queue.bd_res[0].bds[j].src_len) memcpy(g_thread_queue.bd_res[i].bds[j].src, g_thread_queue.bd_res[0].bds[j].src, @@ -328,7 +330,7 @@ static int init_zip_wd_queue(struct acc_option *options) } }

- // use no-sva pbuffer, MAX_BLOCK_NM at least 4 times of MAX_POOL_LENTH + // use no-sva pbuffer, MAX_BLOCK_NM at least 4 times of MAX_POOL_LENTH_COMP memset(&blksetup, 0, sizeof(blksetup)); outsize = ALIGN(outsize, ALIGN_SIZE); blksetup.block_size = outsize; @@ -345,12 +347,12 @@ static int init_zip_wd_queue(struct acc_option *options) } pool = g_thread_queue.bd_res[j].pool;

- g_thread_queue.bd_res[j].bds = malloc(sizeof(struct wd_bd) * MAX_POOL_LENTH); + g_thread_queue.bd_res[j].bds = malloc(sizeof(struct wd_bd) * MAX_POOL_LENTH_COMP); if (!g_thread_queue.bd_res[j].bds) goto bds_error; bds = g_thread_queue.bd_res[j].bds;

- for (i = 0; i < MAX_POOL_LENTH; i++) { + for (i = 0; i < MAX_POOL_LENTH_COMP; i++) { bds[i].src = wd_alloc_blk(pool); if (!bds[i].src) { ret = -ENOMEM; @@ -365,7 +367,7 @@ static int init_zip_wd_queue(struct acc_option *options) } bds[i].dst_len = outsize;

- get_rand_data(bds[i].src, insize); + get_rand_data(bds[i].src, insize * COMPRESSION_RATIO_FACTOR); }

} @@ -385,7 +387,7 @@ pool_err: for (j--; j >= 0; j--) { pool = g_thread_queue.bd_res[j].pool; bds = g_thread_queue.bd_res[j].bds; - for (i = 0; i < MAX_POOL_LENTH; i++) { + for (i = 0; i < MAX_POOL_LENTH_COMP; i++) { wd_free_blk(pool, bds[i].src); wd_free_blk(pool, bds[i].dst); } @@ -410,7 +412,7 @@ static void uninit_zip_wd_queue(void) for (j = 0; j < g_thread_num; j++) { pool = g_thread_queue.bd_res[j].pool; bds = g_thread_queue.bd_res[j].bds; - for (i = 0; i < MAX_POOL_LENTH; i++) { + for (i = 0; i < MAX_POOL_LENTH_COMP; i++) { wd_free_blk(pool, bds[i].src); wd_free_blk(pool, bds[i].dst); } @@ -551,17 +553,17 @@ static void *zip_wd_blk_lz77_sync_run(void *arg)

out_len = bd_pool[0].dst_len;

- ftuple = malloc(sizeof(COMP_TUPLE_TAG) * MAX_POOL_LENTH); + ftuple = malloc(sizeof(COMP_TUPLE_TAG) * MAX_POOL_LENTH_COMP); if (!ftuple) goto fse_err;

- hw_buff_out = malloc(out_len * MAX_POOL_LENTH); + hw_buff_out = malloc(out_len * MAX_POOL_LENTH_COMP); if (!hw_buff_out) goto hw_buff_err; - memset(hw_buff_out, 0x0, out_len * MAX_POOL_LENTH); + memset(hw_buff_out, 0x0, out_len * MAX_POOL_LENTH_COMP);

while(1) { - i = count % MAX_POOL_LENTH; + i = count % MAX_POOL_LENTH_COMP; opdata.in = bd_pool[i].src; opdata.out = &hw_buff_out[i]; //temp out opdata.in_len = bd_pool[i].src_len; @@ -597,7 +599,7 @@ fse_err:

cal_avg_latency(count); if (pdata->optype == WCRYPTO_DEFLATE) - add_recv_data(count, opdata.in_len); + add_recv_data(count, g_pktlen); else add_recv_data(count, first_len);

@@ -659,17 +661,17 @@ static void *zip_wd_stm_lz77_sync_run(void *arg)

out_len = bd_pool[0].dst_len;

- ftuple = malloc(sizeof(COMP_TUPLE_TAG) * MAX_POOL_LENTH); + ftuple = malloc(sizeof(COMP_TUPLE_TAG) * MAX_POOL_LENTH_COMP); if (!ftuple) goto fse_err;

- hw_buff_out = malloc(out_len * MAX_POOL_LENTH); + hw_buff_out = malloc(out_len * MAX_POOL_LENTH_COMP); if (!hw_buff_out) goto hw_buff_err; - memset(hw_buff_out, 0x0, out_len * MAX_POOL_LENTH); + memset(hw_buff_out, 0x0, out_len * MAX_POOL_LENTH_COMP);

while(1) { - i = count % MAX_POOL_LENTH; + i = count % MAX_POOL_LENTH_COMP; opdata.in = bd_pool[i].src; opdata.out = &hw_buff_out[i]; //temp out opdata.in_len = bd_pool[i].src_len; @@ -708,7 +710,7 @@ fse_err:

cal_avg_latency(count); if (pdata->optype == WCRYPTO_DEFLATE) - add_recv_data(count, opdata.in_len); + add_recv_data(count, g_pktlen); else add_recv_data(count, first_len);

@@ -769,16 +771,16 @@ static void *zip_wd_blk_lz77_async_run(void *arg)

out_len = bd_pool[0].dst_len;

- ftuple = malloc(sizeof(COMP_TUPLE_TAG) * MAX_POOL_LENTH); + ftuple = malloc(sizeof(COMP_TUPLE_TAG) * MAX_POOL_LENTH_COMP); if (!ftuple) goto fse_err;

- hw_buff_out = malloc(out_len * MAX_POOL_LENTH); + hw_buff_out = malloc(out_len * MAX_POOL_LENTH_COMP); if (!hw_buff_out) goto hw_buff_err; - memset(hw_buff_out, 0x0, out_len * MAX_POOL_LENTH); + memset(hw_buff_out, 0x0, out_len * MAX_POOL_LENTH_COMP);

- tag = malloc(sizeof(*tag) * MAX_POOL_LENTH); + tag = malloc(sizeof(*tag) * MAX_POOL_LENTH_COMP); if (!tag) { ZIP_TST_PRT("failed to malloc zip tag!\n"); goto tag_err; @@ -789,7 +791,7 @@ static void *zip_wd_blk_lz77_async_run(void *arg) break;

try_cnt = 0; - i = count % MAX_POOL_LENTH; + i = count % MAX_POOL_LENTH_COMP; opdata.in = bd_pool[i].src; opdata.out = &hw_buff_out[i]; //temp out opdata.in_len = bd_pool[i].src_len; @@ -832,10 +834,6 @@ hw_buff_err: fse_err: free(ftuple); wcrypto_del_comp_ctx(ctx); - - // ZIP_TST_PRT("LZ77 valid pool len: %u, send count BD: %u, output len: %u!\n", - // MAX_POOL_LENTH, count, opdata.produced); - add_send_complete();

return NULL; @@ -890,7 +888,7 @@ static void *zip_wd_blk_sync_run(void *arg) out_len = bd_pool[0].dst_len;

while(1) { - i = count % MAX_POOL_LENTH; + i = count % MAX_POOL_LENTH_COMP; opdata.in = bd_pool[i].src; opdata.out = bd_pool[i].dst; opdata.in_len = bd_pool[i].src_len; @@ -963,7 +961,7 @@ static void *zip_wd_stm_sync_run(void *arg) out_len = bd_pool[0].dst_len;

while(1) { - i = count % MAX_POOL_LENTH; + i = count % MAX_POOL_LENTH_COMP; opdata.in = bd_pool[i].src; opdata.out = bd_pool[i].dst; opdata.in_len = bd_pool[i].src_len; @@ -1041,7 +1039,7 @@ static void *zip_wd_blk_async_run(void *arg) opdata.flush = WCRYPTO_FINISH;

out_len = bd_pool[0].dst_len; - tag = malloc(sizeof(*tag) * MAX_POOL_LENTH); + tag = malloc(sizeof(*tag) * MAX_POOL_LENTH_COMP); if (!tag) { ZIP_TST_PRT("failed to malloc zip tag!\n"); goto tag_release; @@ -1051,7 +1049,7 @@ static void *zip_wd_blk_async_run(void *arg) if (get_run_state() == 0) break;

- i = count % MAX_POOL_LENTH; + i = count % MAX_POOL_LENTH_COMP; opdata.in = bd_pool[i].src; opdata.out = bd_pool[i].dst; opdata.in_len = bd_pool[i].src_len; @@ -1088,10 +1086,6 @@ static void *zip_wd_blk_async_run(void *arg) tag_release: free(tag); wcrypto_del_comp_ctx(ctx); - - // ZIP_TST_PRT("valid pool len: %u, send count BD: %u, output len: %u!\n", - // MAX_POOL_LENTH, count, opdata.produced); - add_send_complete();

return NULL;

From: Yang Shen shenyang39@huawei.com

The compression stream mode test case should devide the input package into 128KiB block.

Signed-off-by: Yang Shen shenyang39@huawei.com --- uadk_tool/benchmark/zip_uadk_benchmark.c | 4 +- uadk_tool/benchmark/zip_wd_benchmark.c | 57 ++++++++++++++---------- 2 files changed, 36 insertions(+), 25 deletions(-)

diff --git a/uadk_tool/benchmark/zip_uadk_benchmark.c b/uadk_tool/benchmark/zip_uadk_benchmark.c index 7c96edf..6bf1749 100644 --- a/uadk_tool/benchmark/zip_uadk_benchmark.c +++ b/uadk_tool/benchmark/zip_uadk_benchmark.c @@ -13,7 +13,7 @@ #define ZIP_FILE "./zip" #define COMP_LEN_RATE 2 #define DECOMP_LEN_RATE 2 -#define MAX_POOL_LENTH_COMP 512 +#define MAX_POOL_LENTH_COMP 1 #define COMPRESSION_RATIO_FACTOR 0.7 #define CHUNK_SIZE (128 * 1024) struct uadk_bd { @@ -912,7 +912,7 @@ static void *zip_uadk_stm_sync_run(void *arg) creq.src_len = uadk_pool->bds[i].src_len; creq.dst_len = out_len;

- ret = wd_do_comp_strm(h_sess, &creq); + ret = wd_do_comp_sync2(h_sess, &creq); if (ret < 0 || creq.status == WD_IN_EPARA) { ZIP_TST_PRT("wd comp, invalid or incomplete data! " "ret(%d), req.status(%u)\n", ret, creq.status); diff --git a/uadk_tool/benchmark/zip_wd_benchmark.c b/uadk_tool/benchmark/zip_wd_benchmark.c index b25f1fb..d2340e0 100644 --- a/uadk_tool/benchmark/zip_wd_benchmark.c +++ b/uadk_tool/benchmark/zip_wd_benchmark.c @@ -323,9 +323,8 @@ static int init_zip_wd_queue(struct acc_option *options) memset(&blksetup, 0, sizeof(blksetup)); outsize = ALIGN(outsize, ALIGN_SIZE); blksetup.block_size = outsize; - blksetup.block_num = MAX_BLOCK_NM; + blksetup.block_num = MAX_POOL_LENTH_COMP * 3; blksetup.align_size = ALIGN_SIZE; - // ZIP_TST_PRT("create pool memory: %d KB\n", (MAX_BLOCK_NM * blksetup.block_size) >> 10);

for (j = 0; j < g_thread_num; j++) { g_thread_queue.bd_res[j].pool = wd_blkpool_create(g_thread_queue.bd_res[j].queue, &blksetup); @@ -832,14 +831,14 @@ static void *zip_wd_blk_sync_run(void *arg)

static void *zip_wd_stm_sync_run(void *arg) { + u32 in_len, out_len, total_out, count = 0; thread_data *pdata = (thread_data *)arg; struct wcrypto_comp_ctx_setup comp_setup; struct wcrypto_comp_op_data opdata; struct wcrypto_comp_ctx *ctx; struct wd_queue *queue; struct wd_bd *bd_pool; - u32 out_len = 0; - u32 count = 0; + void *src, *dst; int ret, i;

if (pdata->td_id > g_thread_num) @@ -867,34 +866,46 @@ static void *zip_wd_stm_sync_run(void *arg) if (!ctx) return NULL;

- opdata.stream_pos = WCRYPTO_COMP_STREAM_NEW; opdata.alg_type = pdata->alg; opdata.priv = NULL; opdata.status = 0; - if (pdata->optype == WCRYPTO_INFLATE) - opdata.flush = WCRYPTO_SYNC_FLUSH; - else - opdata.flush = WCRYPTO_FINISH; - - out_len = bd_pool[0].dst_len;

while(1) { i = count % MAX_POOL_LENTH_COMP; - opdata.in = bd_pool[i].src; - opdata.out = bd_pool[i].dst; - opdata.in_len = bd_pool[i].src_len; - opdata.avail_out = out_len; + src = bd_pool[i].src; + dst = bd_pool[i].dst; + in_len = bd_pool[i].src_len; + out_len = g_pktlen * DECOMP_LEN_RATE; + total_out = 0; + opdata.stream_pos = WCRYPTO_COMP_STREAM_NEW;

- ret = wcrypto_do_comp(ctx, &opdata, NULL); - if (ret || opdata.status == WCRYPTO_DECOMP_END_NOSPACE || - opdata.status == WD_IN_EPARA || opdata.status == WD_VERIFY_ERR) { - ZIP_TST_PRT("wd comp, invalid or incomplete data! " - "ret(%d), req.status(%u)\n", ret, opdata.status); - break; - } + do { + opdata.in_len = in_len > CHUNK_SIZE ? CHUNK_SIZE : in_len; + opdata.avail_out = out_len > 2 * CHUNK_SIZE ? 2 * CHUNK_SIZE : out_len; + opdata.in = src; + opdata.out = dst; + opdata.flush = in_len ? WCRYPTO_SYNC_FLUSH : WCRYPTO_FINISH; + + ret = wcrypto_do_comp(ctx, &opdata, NULL); + if (ret || opdata.status == WCRYPTO_DECOMP_END_NOSPACE || + opdata.status == WD_IN_EPARA || opdata.status == WD_VERIFY_ERR) { + ZIP_TST_PRT("wd comp, invalid or incomplete data! " + "ret(%d), req.status(%u)\n", ret, opdata.status); + break; + } + + opdata.stream_pos = WCRYPTO_COMP_STREAM_OLD; + + src += opdata.consumed; + in_len -= opdata.consumed; + dst += opdata.produced; + out_len -= opdata.produced; + total_out += opdata.produced; + } while (in_len > 0);

count++; - bd_pool[i].dst_len = opdata.produced; + bd_pool[i].dst_len = total_out; + if (get_run_state() == 0) break; }

Added support for init2 performance test function for uadk_tools

Signed-off-by: Longfang Liu liulongfang@huawei.com --- uadk_tool/benchmark/uadk_benchmark.c | 108 +++++++++++++++++++++++++++ uadk_tool/benchmark/uadk_benchmark.h | 8 ++ 2 files changed, 116 insertions(+)

diff --git a/uadk_tool/benchmark/uadk_benchmark.c b/uadk_tool/benchmark/uadk_benchmark.c index aa884bc..26b381e 100644 --- a/uadk_tool/benchmark/uadk_benchmark.c +++ b/uadk_tool/benchmark/uadk_benchmark.c @@ -137,6 +137,86 @@ static struct acc_alg_item alg_options[] = { {"", ALG_MAX} };

+static struct acc_alg_item alg_name_options[] = { + {"zlib", ZLIB}, + {"gzip", GZIP}, + {"deflate", DEFLATE}, + {"lz77_zstd", LZ77_ZSTD}, + {"rsa", RSA_1024}, + {"rsa", RSA_2048}, + {"rsa", RSA_3072}, + {"rsa", RSA_4096}, + {"rsa", RSA_1024_CRT}, + {"rsa", RSA_2048_CRT}, + {"rsa", RSA_3072_CRT}, + {"rsa", RSA_4096_CRT}, + {"dh", DH_768}, + {"dh", DH_1024}, + {"dh", DH_1536}, + {"dh", DH_2048}, + {"dh", DH_3072}, + {"dh", DH_4096}, + {"ecdh", ECDH_256}, + {"ecdh", ECDH_384}, + {"ecdh", ECDH_521}, + {"ecdsa", ECDSA_256}, + {"ecdsa", ECDSA_384}, + {"ecdsa", ECDSA_521}, + {"sm2", SM2_ALG}, + {"x25519", X25519_ALG}, + {"x448", X448_ALG}, + {"ecb(aes)", AES_128_ECB}, + {"ecb(aes)", AES_192_ECB}, + {"ecb(aes)", AES_256_ECB}, + {"cbc(aes)", AES_128_CBC}, + {"cbc(aes)", AES_192_CBC}, + {"cbc(aes)", AES_256_CBC}, + {"ctr(aes)", AES_128_CTR}, + {"ctr(aes)", AES_192_CTR}, + {"ctr(aes)", AES_256_CTR}, + {"ofb(aes)", AES_128_OFB}, + {"ofb(aes)", AES_192_OFB}, + {"ofb(aes)", AES_256_OFB}, + {"cfb(aes)", AES_128_CFB}, + {"cfb(aes)", AES_192_CFB}, + {"cfb(aes)", AES_256_CFB}, + {"xts(aes)", AES_256_XTS}, + {"xts(aes)", AES_512_XTS}, + {"ecb(des3_ede)", DES3_128_ECB}, + {"ecb(des3_ede)", DES3_192_ECB}, + {"cbc(des3_ede)", DES3_128_CBC}, + {"cbc(des3_ede)", DES3_192_CBC}, + {"ecb(sm4)", SM4_128_ECB}, + {"cbc(sm4)", SM4_128_CBC}, + {"ctr(sm4)", SM4_128_CTR}, + {"ofb(sm4)", SM4_128_OFB}, + {"cfb(sm4)", SM4_128_CFB}, + {"xts(sm4)", SM4_128_XTS}, + {"ccm(aes)", AES_128_CCM}, + {"ccm(aes)", AES_192_CCM}, + {"ccm(aes)", AES_256_CCM}, + {"gcm(aes)", AES_128_GCM}, + {"gcm(aes)", AES_192_GCM}, + {"gcm(aes)", AES_256_GCM}, + {"authenc(hmac(sha256),cbc(aes))", AES_128_CBC_SHA256_HMAC}, + {"authenc(hmac(sha256),cbc(aes))", AES_192_CBC_SHA256_HMAC}, + {"authenc(hmac(sha256),cbc(aes))", AES_256_CBC_SHA256_HMAC}, + {"ccm(sm4)", SM4_128_CCM}, + {"gcm(sm4)", SM4_128_GCM}, + {"sm3", SM3_ALG}, + {"md5", MD5_ALG}, + {"sha1", SHA1_ALG}, + {"sha256", SHA256_ALG}, + {"sha224", SHA224_ALG}, + {"sha384", SHA384_ALG}, + {"sha512", SHA512_ALG}, + {"sha512-224", SHA512_224}, + {"sha512-256", SHA512_256}, + {"trng", TRNG}, + {"", ALG_MAX} +}; + + /*-------------------------------------tool code------------------------------------------------------*/ void add_send_complete(void) { @@ -194,6 +274,20 @@ static int get_alg_type(const char *alg_name) return alg; }

+int get_alg_name(int alg, char *alg_name) +{ + int i; + + for (i = 0; i < ALG_MAX; i++) { + if (alg == alg_name_options[i].alg) { + strcpy(alg_name, alg_name_options[i].name); + return 0; + } + } + + return -EINVAL; +} + static int get_mode_type(const char *mode_name) { u32 modetype = INVALID_MODE; @@ -491,6 +585,8 @@ static void dump_param(struct acc_option *option) ACC_TST_PRT(" [--acctype]: %u\n", option->acctype); ACC_TST_PRT(" [--prefetch]:%u\n", option->prefetch); ACC_TST_PRT(" [--engine]: %s\n", option->engine); + ACC_TST_PRT(" [--latency]: %u\n", option->latency); + ACC_TST_PRT(" [--init2]: %u\n", option->inittype); }

int acc_benchmark_run(struct acc_option *option) @@ -571,6 +667,7 @@ int acc_default_case(struct acc_option *option) option->threads = 1; option->multis = 1; option->ctxnums = 2; + option->inittype = INIT_TYPE;

return acc_benchmark_run(option); } @@ -611,6 +708,8 @@ static void print_help(void) ACC_TST_PRT(" list the all support alg\n"); ACC_TST_PRT(" [--latency]:\n"); ACC_TST_PRT(" test the running time of packets\n"); + ACC_TST_PRT(" [--init2]:\n"); + ACC_TST_PRT(" select init2 mode in the init interface of UADK SVA\n"); ACC_TST_PRT(" [--help] = usage\n"); ACC_TST_PRT("Example\n"); ACC_TST_PRT(" ./uadk_tool benchmark --alg aes-128-cbc --mode sva --opt 0 --sync\n"); @@ -651,6 +750,7 @@ int acc_cmd_parse(int argc, char *argv[], struct acc_option *option) {"latency", no_argument, 0, 14}, {"winsize", required_argument, 0, 15}, {"complevel", required_argument, 0, 16}, + {"init2", no_argument, 0, 17}, {0, 0, 0, 0} };

@@ -712,6 +812,9 @@ int acc_cmd_parse(int argc, char *argv[], struct acc_option *option) case 16: option->complevel = strtol(optarg, NULL, 0); break; + case 17: + option->inittype = INIT2_TYPE; + break; default: ACC_TST_PRT("bad input test parameter!\n"); print_help(); @@ -783,6 +886,11 @@ int acc_option_convert(struct acc_option *option) goto param_err; }

+ if (option->inittype == INIT2_TYPE && option->modetype != SVA_MODE) { + ACC_TST_PRT("uadk benchmark No-SVA mode can't use init2\n"); + goto param_err; + } + return 0;

param_err: diff --git a/uadk_tool/benchmark/uadk_benchmark.h b/uadk_tool/benchmark/uadk_benchmark.h index 71fe2dc..3a33fd8 100644 --- a/uadk_tool/benchmark/uadk_benchmark.h +++ b/uadk_tool/benchmark/uadk_benchmark.h @@ -73,6 +73,7 @@ struct acc_option { u32 prefetch; u32 winsize; u32 complevel; + u32 inittype; bool latency; };

@@ -83,6 +84,12 @@ enum acc_type { TRNG_TYPE, };

+enum acc_init_type { + INIT_TYPE = 0, + INIT2_TYPE, + MAX_TYPE, +}; + enum alg_type { DEFAULT_TYPE, CIPHER_TYPE, @@ -192,6 +199,7 @@ extern void add_recv_data(u32 cnt, u32 pkglen); extern void add_send_complete(void); extern u32 get_recv_time(void); extern void cal_avg_latency(u32 count); +extern int get_alg_name(int alg, char *alg_name);

int acc_cmd_parse(int argc, char *argv[], struct acc_option *option); int acc_default_case(struct acc_option *option);

Added init2 performance test function for uadk_tools of SEC module.

Signed-off-by: Longfang Liu liulongfang@huawei.com --- uadk_tool/benchmark/sec_uadk_benchmark.c | 119 ++++++++++++++++++++++- 1 file changed, 114 insertions(+), 5 deletions(-)

diff --git a/uadk_tool/benchmark/sec_uadk_benchmark.c b/uadk_tool/benchmark/sec_uadk_benchmark.c index d0bf871..9f1f903 100644 --- a/uadk_tool/benchmark/sec_uadk_benchmark.c +++ b/uadk_tool/benchmark/sec_uadk_benchmark.c @@ -454,10 +454,13 @@ static int sec_uadk_param_parse(thread_data *tddata, struct acc_option *options) return 0; }

-static int init_ctx_config(char *alg, int subtype, int mode) +static int init_ctx_config(struct acc_option *options) { struct sched_params param; struct uacce_dev *dev = NULL; + char *alg = options->algclass; + int subtype = options->subtype; + int mode = options->syncmode; int ret, max_node, i;

max_node = numa_max_node() + 1; @@ -576,6 +579,57 @@ static void uninit_ctx_config(int subtype) wd_sched_rr_release(g_sched); }

+static void uninit_ctx_config2(int subtype) +{ + /* uninit2 */ + switch(subtype) { + case CIPHER_TYPE: + wd_cipher_uninit2(); + break; + case AEAD_TYPE: + wd_aead_uninit2(); + break; + case DIGEST_TYPE: + wd_digest_uninit2(); + break; + default: + SEC_TST_PRT("failed to parse alg subtype on uninit2!\n"); + return; + } +} + +static int init_ctx_config2(struct acc_option *options) +{ + char alg_name[64]; + int subtype = options->subtype; + int ret; + + ret = get_alg_name(options->algtype, alg_name); + if (ret) { + SEC_TST_PRT("failed to get valid alg name!\n"); + return -EINVAL; + } + + /* init */ + switch(subtype) { + case CIPHER_TYPE: + ret = wd_cipher_init2(alg_name, SCHED_POLICY_RR, TASK_HW); + break; + case AEAD_TYPE: + ret = wd_aead_init2(alg_name, SCHED_POLICY_RR, TASK_HW); + break; + case DIGEST_TYPE: + ret = wd_digest_init2(alg_name, SCHED_POLICY_RR, TASK_HW); + break; + } + if (ret) { + SEC_TST_PRT("failed to do cipher init2!\n"); + return ret; + } + + return 0; +} + static void get_aead_data(u8 *addr, u32 size) { memset(addr, 0, size); @@ -852,7 +906,52 @@ static void *sec_uadk_poll(void *data) count += recv; recv = 0; if (unlikely(ret != -WD_EAGAIN && ret < 0)) { - SEC_TST_PRT("poll ret: %u!\n", ret); + SEC_TST_PRT("poll ret: %d!\n", ret); + goto recv_error; + } + + if (get_run_state() == 0) + last_time--; + } + +recv_error: + add_recv_data(count, g_pktlen); + + return NULL; +} + +static void *sec_uadk_poll2(void *data) +{ + typedef int (*poll_ctx)(__u32 expt, __u32 *count); + poll_ctx uadk_poll_policy = NULL; + thread_data *pdata = (thread_data *)data; + u32 expt = ACC_QUEUE_SIZE * g_thread_num; + u32 last_time = 2; // poll need one more recv time + u32 count = 0; + u32 recv = 0; + int ret; + + switch(pdata->subtype) { + case CIPHER_TYPE: + uadk_poll_policy = wd_cipher_poll; + break; + case AEAD_TYPE: + uadk_poll_policy = wd_aead_poll; + break; + case DIGEST_TYPE: + uadk_poll_policy = wd_digest_poll; + break; + default: + SEC_TST_PRT("<<<<<<async poll interface is NULL!\n"); + return NULL; + } + + while (last_time) { + ret = uadk_poll_policy(expt, &recv); + count += recv; + recv = 0; + if (unlikely(ret != -WD_EAGAIN && ret < 0)) { + SEC_TST_PRT("poll ret: %d!\n", ret); goto recv_error; }

@@ -866,6 +965,7 @@ recv_error: return NULL; }

+ static void *sec_uadk_cipher_async(void *arg) { thread_data *pdata = (thread_data *)arg; @@ -1404,7 +1504,10 @@ int sec_uadk_async_threads(struct acc_option *options) threads_args[i].subtype = threads_option.subtype; threads_args[i].td_id = i; /* poll thread */ - ret = pthread_create(&pollid[i], NULL, sec_uadk_poll, &threads_args[i]); + if (options->inittype == INIT2_TYPE) + ret = pthread_create(&pollid[i], NULL, sec_uadk_poll2, &threads_args[i]); + else + ret = pthread_create(&pollid[i], NULL, sec_uadk_poll, &threads_args[i]); if (ret) { SEC_TST_PRT("Create poll thread fail!\n"); goto async_error; @@ -1475,7 +1578,10 @@ int sec_uadk_benchmark(struct acc_option *options) return -EINVAL; }

- ret = init_ctx_config(options->algclass, options->subtype, options->syncmode); + if (options->inittype == INIT2_TYPE) + ret = init_ctx_config2(options); + else + ret = init_ctx_config(options); if (ret) return ret;

@@ -1494,7 +1600,10 @@ int sec_uadk_benchmark(struct acc_option *options) return ret;

free_uadk_bd_pool(); - uninit_ctx_config(options->subtype); + if (options->inittype == INIT2_TYPE) + uninit_ctx_config2(options->subtype); + else + uninit_ctx_config(options->subtype);

return 0; }

From: Weili Qian qianweili@huawei.com

Added support for init2 performance test function for uadk_tools of hpre module. And fix some code style issues.

Signed-off-by: Weili Qian qianweili@huawei.com --- uadk_tool/benchmark/hpre_uadk_benchmark.c | 137 ++++++++++++++++++++-- 1 file changed, 125 insertions(+), 12 deletions(-)

diff --git a/uadk_tool/benchmark/hpre_uadk_benchmark.c b/uadk_tool/benchmark/hpre_uadk_benchmark.c index ffa1a85..028e102 100644 --- a/uadk_tool/benchmark/hpre_uadk_benchmark.c +++ b/uadk_tool/benchmark/hpre_uadk_benchmark.c @@ -344,8 +344,11 @@ static int hpre_uadk_param_parse(thread_data *tddata, struct acc_option *options return 0; }

-static int init_hpre_ctx_config(char *alg, int subtype, int mode) +static int init_hpre_ctx_config(struct acc_option *options) { + int subtype = options->subtype; + char *alg = options->algclass; + int mode = options->syncmode; struct sched_params param; struct uacce_dev *dev; int max_node; @@ -398,7 +401,7 @@ static int init_hpre_ctx_config(char *alg, int subtype, int mode) break; default: HPRE_TST_PRT("failed to parse alg subtype!\n"); - g_sched = NULL; + return -EINVAL; } if (!g_sched) { HPRE_TST_PRT("failed to alloc sched!\n"); @@ -432,8 +435,6 @@ static int init_hpre_ctx_config(char *alg, int subtype, int mode) case X448_TYPE: ret = wd_ecc_init(&g_ctx_cfg, g_sched); break; - default: - ret = -EINVAL; } if (ret) { HPRE_TST_PRT("failed to get hpre ctx!\n"); @@ -456,7 +457,7 @@ static void uninit_hpre_ctx_config(int subtype) int i;

/* uninit */ - switch(subtype) { + switch (subtype) { case RSA_TYPE: wd_rsa_uninit(); break; @@ -481,6 +482,59 @@ static void uninit_hpre_ctx_config(int subtype) wd_sched_rr_release(g_sched); }

+static void uninit_hpre_ctx_config2(int subtype) +{ + /* uninit2 */ + switch (subtype) { + case RSA_TYPE: + wd_rsa_uninit2(); + break; + case DH_TYPE: + wd_dh_uninit2(); + break; + case ECDH_TYPE: + case ECDSA_TYPE: + case SM2_TYPE: + case X25519_TYPE: + case X448_TYPE: + wd_ecc_uninit2(); + break; + default: + HPRE_TST_PRT("failed to parse alg subtype on uninit2!\n"); + return; + } +} + +static int init_hpre_ctx_config2(struct acc_option *options) +{ + int subtype = options->subtype; + char alg_name[MAX_ALG_NAME]; + int ret; + + ret = get_alg_name(options->algtype, alg_name); + if (ret) { + HPRE_TST_PRT("failed to get valid alg name!\n"); + return -EINVAL; + } + + /* init2 */ + switch (subtype) { + case RSA_TYPE: + return wd_rsa_init2(alg_name, SCHED_POLICY_RR, TASK_HW); + case DH_TYPE: + return wd_dh_init2(alg_name, SCHED_POLICY_RR, TASK_HW); + case ECDH_TYPE: + case ECDSA_TYPE: + case SM2_TYPE: + case X25519_TYPE: + case X448_TYPE: + return wd_ecc_init2(alg_name, SCHED_POLICY_RR, TASK_HW); + default: + HPRE_TST_PRT("failed to parse alg subtype on uninit2!\n"); + return -EINVAL; + } +} + /*-------------------------------uadk benchmark main code-------------------------------------*/

void *hpre_uadk_poll(void *data) @@ -498,7 +552,7 @@ void *hpre_uadk_poll(void *data) if (id > g_ctxnum) return NULL;

- switch(pdata->subtype) { + switch (pdata->subtype) { case RSA_TYPE: uadk_poll_ctx = wd_rsa_poll_ctx; break; @@ -522,7 +576,56 @@ void *hpre_uadk_poll(void *data) count += recv; recv = 0; if (unlikely(ret != -WD_EAGAIN && ret < 0)) { - HPRE_TST_PRT("poll ret: %u!\n", ret); + HPRE_TST_PRT("poll ret: %d!\n", ret); + goto recv_error; + } + + if (get_run_state() == 0) + last_time--; + } + +recv_error: + add_recv_data(count, pdata->keybits >> 3); + + return NULL; +} + +void *hpre_uadk_poll2(void *data) +{ + typedef int (*poll_ctx)(__u32 expt, __u32 *count); + thread_data *pdata = (thread_data *)data; + u32 expt = ACC_QUEUE_SIZE * g_thread_num; + poll_ctx uadk_poll = NULL; + u32 last_time = 2; // poll need one more recv time + u32 count = 0; + u32 recv = 0; + int ret; + + switch (pdata->subtype) { + case RSA_TYPE: + uadk_poll = wd_rsa_poll; + break; + case DH_TYPE: + uadk_poll = wd_dh_poll; + break; + case ECDH_TYPE: + case ECDSA_TYPE: + case SM2_TYPE: + case X25519_TYPE: + case X448_TYPE: + uadk_poll = wd_ecc_poll; + break; + default: + HPRE_TST_PRT("<<<<<<async poll interface is NULL!\n"); + return NULL; + } + + while (last_time) { + ret = uadk_poll(expt, &recv); + count += recv; + recv = 0; + if (unlikely(ret != -WD_EAGAIN && ret < 0)) { + HPRE_TST_PRT("poll ret: %d!\n", ret); goto recv_error; }

@@ -2451,7 +2554,10 @@ static int hpre_uadk_async_threads(struct acc_option *options) threads_args[i].subtype = threads_option.subtype; threads_args[i].td_id = i; /* poll thread */ - ret = pthread_create(&pollid[i], NULL, hpre_uadk_poll, &threads_args[i]); + if (options->inittype == INIT2_TYPE) + ret = pthread_create(&pollid[i], NULL, hpre_uadk_poll2, &threads_args[i]); + else + ret = pthread_create(&pollid[i], NULL, hpre_uadk_poll, &threads_args[i]); if (ret) { HPRE_TST_PRT("Create poll thread fail!\n"); goto async_error; @@ -2505,10 +2611,14 @@ int hpre_uadk_benchmark(struct acc_option *options) return -EINVAL; }

- ret = init_hpre_ctx_config(options->algclass, options->subtype, - options->syncmode); - if (ret) + if (options->inittype == INIT2_TYPE) + ret = init_hpre_ctx_config2(options); + else + ret = init_hpre_ctx_config(options); + if (ret) { + HPRE_TST_PRT("failed to init %s ctx, ret = %d!\n", options->algclass, ret); return ret; + }

get_pid_cpu_time(&ptime); time_start(options->times); @@ -2520,7 +2630,10 @@ int hpre_uadk_benchmark(struct acc_option *options) if (ret) return ret;

- uninit_hpre_ctx_config(options->subtype); + if (options->inittype == INIT2_TYPE) + uninit_hpre_ctx_config2(options->subtype); + else + uninit_hpre_ctx_config(options->subtype);

return 0; }

From: Zhiqi Song songzhiqi1@huawei.com

Add test case for AES-CBC CTS mode, CS1/2/3, for both uadk v1 and uadk v2 in uadk_tool benchmark tool.

Use param such as '--alg aes-128-cbc-cs1' to enable cs1 mode test.

Use 'uadk_tool benchmark --alglist' to find the name of other modes.

Signed-off-by: Zhiqi Song songzhiqi1@huawei.com --- uadk_tool/benchmark/sec_uadk_benchmark.c | 54 ++++++++++++++++++++++++ uadk_tool/benchmark/sec_wd_benchmark.c | 54 ++++++++++++++++++++++++ uadk_tool/benchmark/uadk_benchmark.c | 18 ++++++++ uadk_tool/benchmark/uadk_benchmark.h | 9 ++++ 4 files changed, 135 insertions(+)

diff --git a/uadk_tool/benchmark/sec_uadk_benchmark.c b/uadk_tool/benchmark/sec_uadk_benchmark.c index 88806ca..1994ad0 100644 --- a/uadk_tool/benchmark/sec_uadk_benchmark.c +++ b/uadk_tool/benchmark/sec_uadk_benchmark.c @@ -190,6 +190,60 @@ static int sec_uadk_param_parse(thread_data *tddata, struct acc_option *options) mode = WD_CIPHER_CBC; alg = WD_CIPHER_AES; break; + case AES_128_CBC_CS1: + keysize = 16; + ivsize = 16; + mode = WD_CIPHER_CBC_CS1; + alg = WD_CIPHER_AES; + break; + case AES_128_CBC_CS2: + keysize = 16; + ivsize = 16; + mode = WD_CIPHER_CBC_CS2; + alg = WD_CIPHER_AES; + break; + case AES_128_CBC_CS3: + keysize = 16; + ivsize = 16; + mode = WD_CIPHER_CBC_CS3; + alg = WD_CIPHER_AES; + break; + case AES_192_CBC_CS1: + keysize = 24; + ivsize = 16; + mode = WD_CIPHER_CBC_CS1; + alg = WD_CIPHER_AES; + break; + case AES_192_CBC_CS2: + keysize = 24; + ivsize = 16; + mode = WD_CIPHER_CBC_CS2; + alg = WD_CIPHER_AES; + break; + case AES_192_CBC_CS3: + keysize = 24; + ivsize = 16; + mode = WD_CIPHER_CBC_CS3; + alg = WD_CIPHER_AES; + break; + case AES_256_CBC_CS1: + keysize = 32; + ivsize = 16; + mode = WD_CIPHER_CBC_CS1; + alg = WD_CIPHER_AES; + break; + case AES_256_CBC_CS2: + keysize = 32; + ivsize = 16; + mode = WD_CIPHER_CBC_CS2; + alg = WD_CIPHER_AES; + break; + case AES_256_CBC_CS3: + keysize = 32; + ivsize = 16; + mode = WD_CIPHER_CBC_CS3; + alg = WD_CIPHER_AES; + break; case AES_128_CTR: keysize = 16; ivsize = 16; diff --git a/uadk_tool/benchmark/sec_wd_benchmark.c b/uadk_tool/benchmark/sec_wd_benchmark.c index 3791792..aa36c22 100644 --- a/uadk_tool/benchmark/sec_wd_benchmark.c +++ b/uadk_tool/benchmark/sec_wd_benchmark.c @@ -256,6 +256,60 @@ static int sec_wd_param_parse(thread_data *tddata, struct acc_option *options) mode = WCRYPTO_CIPHER_CBC; alg = WCRYPTO_CIPHER_AES; break; + case AES_128_CBC_CS1: + keysize = 16; + ivsize = 16; + mode = WCRYPTO_CIPHER_CBC_CS1; + alg = WCRYPTO_CIPHER_AES; + break; + case AES_128_CBC_CS2: + keysize = 16; + ivsize = 16; + mode = WCRYPTO_CIPHER_CBC_CS2; + alg = WCRYPTO_CIPHER_AES; + break; + case AES_128_CBC_CS3: + keysize = 16; + ivsize = 16; + mode = WCRYPTO_CIPHER_CBC_CS3; + alg = WCRYPTO_CIPHER_AES; + break; + case AES_192_CBC_CS1: + keysize = 24; + ivsize = 16; + mode = WCRYPTO_CIPHER_CBC_CS1; + alg = WCRYPTO_CIPHER_AES; + break; + case AES_192_CBC_CS2: + keysize = 24; + ivsize = 16; + mode = WCRYPTO_CIPHER_CBC_CS2; + alg = WCRYPTO_CIPHER_AES; + break; + case AES_192_CBC_CS3: + keysize = 24; + ivsize = 16; + mode = WCRYPTO_CIPHER_CBC_CS3; + alg = WCRYPTO_CIPHER_AES; + break; + case AES_256_CBC_CS1: + keysize = 32; + ivsize = 16; + mode = WCRYPTO_CIPHER_CBC_CS1; + alg = WCRYPTO_CIPHER_AES; + break; + case AES_256_CBC_CS2: + keysize = 32; + ivsize = 16; + mode = WCRYPTO_CIPHER_CBC_CS2; + alg = WCRYPTO_CIPHER_AES; + break; + case AES_256_CBC_CS3: + keysize = 32; + ivsize = 16; + mode = WCRYPTO_CIPHER_CBC_CS3; + alg = WCRYPTO_CIPHER_AES; + break; case AES_128_CTR: keysize = 16; ivsize = 16; diff --git a/uadk_tool/benchmark/uadk_benchmark.c b/uadk_tool/benchmark/uadk_benchmark.c index 26b381e..ff95bea 100644 --- a/uadk_tool/benchmark/uadk_benchmark.c +++ b/uadk_tool/benchmark/uadk_benchmark.c @@ -92,6 +92,15 @@ static struct acc_alg_item alg_options[] = { {"aes-128-cbc", AES_128_CBC}, {"aes-192-cbc", AES_192_CBC}, {"aes-256-cbc", AES_256_CBC}, + {"aes-128-cbc-cs1", AES_128_CBC_CS1}, + {"aes-128-cbc-cs2", AES_128_CBC_CS2}, + {"aes-128-cbc-cs3", AES_128_CBC_CS3}, + {"aes-192-cbc-cs1", AES_192_CBC_CS1}, + {"aes-192-cbc-cs2", AES_192_CBC_CS2}, + {"aes-192-cbc-cs3", AES_192_CBC_CS3}, + {"aes-256-cbc-cs1", AES_256_CBC_CS1}, + {"aes-256-cbc-cs2", AES_256_CBC_CS2}, + {"aes-256-cbc-cs3", AES_256_CBC_CS3}, {"aes-128-ctr", AES_128_CTR}, {"aes-192-ctr", AES_192_CTR}, {"aes-256-ctr", AES_256_CTR}, @@ -171,6 +180,15 @@ static struct acc_alg_item alg_name_options[] = { {"cbc(aes)", AES_128_CBC}, {"cbc(aes)", AES_192_CBC}, {"cbc(aes)", AES_256_CBC}, + {"cbc-cs1(aes)", AES_128_CBC_CS1}, + {"cbc-cs2(aes)", AES_128_CBC_CS2}, + {"cbc-cs3(aes)", AES_128_CBC_CS3}, + {"cbc-cs1(aes)", AES_192_CBC_CS1}, + {"cbc-cs2(aes)", AES_192_CBC_CS2}, + {"cbc-cs3(aes)", AES_192_CBC_CS3}, + {"cbc-cs1(aes)", AES_256_CBC_CS1}, + {"cbc-cs2(aes)", AES_256_CBC_CS2}, + {"cbc-cs3(aes)", AES_256_CBC_CS3}, {"ctr(aes)", AES_128_CTR}, {"ctr(aes)", AES_192_CTR}, {"ctr(aes)", AES_256_CTR}, diff --git a/uadk_tool/benchmark/uadk_benchmark.h b/uadk_tool/benchmark/uadk_benchmark.h index 3a33fd8..c2ba9bc 100644 --- a/uadk_tool/benchmark/uadk_benchmark.h +++ b/uadk_tool/benchmark/uadk_benchmark.h @@ -143,6 +143,15 @@ enum test_alg { AES_128_CBC, AES_192_CBC, AES_256_CBC, + AES_128_CBC_CS1, + AES_128_CBC_CS2, + AES_128_CBC_CS3, + AES_192_CBC_CS1, + AES_192_CBC_CS2, + AES_192_CBC_CS3, + AES_256_CBC_CS1, + AES_256_CBC_CS2, + AES_256_CBC_CS3, AES_128_CTR, AES_192_CTR, AES_256_CTR,

From: Qi Tao taoqi10@huawei.com

After calling the wd_release_queue (*q), call free(*q) to release the memory pointed to by q.

Signed-off-by: Qi Tao taoqi10@huawei.com --- uadk_tool/benchmark/sec_wd_benchmark.c | 1 + 1 file changed, 1 insertion(+)

diff --git a/uadk_tool/benchmark/sec_wd_benchmark.c b/uadk_tool/benchmark/sec_wd_benchmark.c index aa36c22..f34051e 100644 --- a/uadk_tool/benchmark/sec_wd_benchmark.c +++ b/uadk_tool/benchmark/sec_wd_benchmark.c @@ -733,6 +733,7 @@ static void uninit_wd_queue(void) for (j = 0; j < g_thread_num; j++) { wd_blkpool_destroy(g_thread_queue.bd_res[j].pool); wd_release_queue(g_thread_queue.bd_res[j].queue); + free(g_thread_queue.bd_res[j].queue); }

free(g_thread_queue.bd_res);

From: Weili Qian qianweili@huawei.com

Add testcase cmd sm4-128-xts-gb for sm4-xts GB.

Signed-off-by: Weili Qian qianweili@huawei.com --- uadk_tool/benchmark/sec_uadk_benchmark.c | 6 ++++++ uadk_tool/benchmark/sec_wd_benchmark.c | 6 ++++++ uadk_tool/benchmark/uadk_benchmark.c | 4 +++- uadk_tool/benchmark/uadk_benchmark.h | 1 + 4 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/uadk_tool/benchmark/sec_uadk_benchmark.c b/uadk_tool/benchmark/sec_uadk_benchmark.c index 7ccdb7e..d6effe5 100644 --- a/uadk_tool/benchmark/sec_uadk_benchmark.c +++ b/uadk_tool/benchmark/sec_uadk_benchmark.c @@ -370,6 +370,12 @@ static int sec_uadk_param_parse(thread_data *tddata, struct acc_option *options) mode = WD_CIPHER_XTS; alg = WD_CIPHER_SM4; break; + case SM4_128_XTS_GB: + keysize = 32; + ivsize = 16; + mode = WD_CIPHER_XTS_GB; + alg = WD_CIPHER_SM4; + break; case AES_128_CCM: keysize = 16; ivsize = 16; diff --git a/uadk_tool/benchmark/sec_wd_benchmark.c b/uadk_tool/benchmark/sec_wd_benchmark.c index e620c3c..6e5c8a0 100644 --- a/uadk_tool/benchmark/sec_wd_benchmark.c +++ b/uadk_tool/benchmark/sec_wd_benchmark.c @@ -436,6 +436,12 @@ static int sec_wd_param_parse(thread_data *tddata, struct acc_option *options) mode = WCRYPTO_CIPHER_XTS; alg = WCRYPTO_CIPHER_SM4; break; + case SM4_128_XTS_GB: + keysize = 32; + ivsize = 16; + mode = WCRYPTO_CIPHER_XTS_GB; + alg = WCRYPTO_CIPHER_SM4; + break; case AES_128_CCM: keysize = 16; ivsize = 16; diff --git a/uadk_tool/benchmark/uadk_benchmark.c b/uadk_tool/benchmark/uadk_benchmark.c index ff95bea..6d5d009 100644 --- a/uadk_tool/benchmark/uadk_benchmark.c +++ b/uadk_tool/benchmark/uadk_benchmark.c @@ -122,6 +122,7 @@ static struct acc_alg_item alg_options[] = { {"sm4-128-ofb", SM4_128_OFB}, {"sm4-128-cfb", SM4_128_CFB}, {"sm4-128-xts", SM4_128_XTS}, + {"sm4-128-xts-gb", SM4_128_XTS_GB}, {"aes-128-ccm", AES_128_CCM}, {"aes-192-ccm", AES_192_CCM}, {"aes-256-ccm", AES_256_CCM}, @@ -210,6 +211,7 @@ static struct acc_alg_item alg_name_options[] = { {"ofb(sm4)", SM4_128_OFB}, {"cfb(sm4)", SM4_128_CFB}, {"xts(sm4)", SM4_128_XTS}, + {"xts(sm4)", SM4_128_XTS_GB}, {"ccm(aes)", AES_128_CCM}, {"ccm(aes)", AES_192_CCM}, {"ccm(aes)", AES_256_CCM}, @@ -482,7 +484,7 @@ static void parse_alg_param(struct acc_option *option) snprintf(option->algclass, MAX_ALG_NAME, "%s", "ecdsa"); option->acctype = HPRE_TYPE; option->subtype = ECDSA_TYPE; - } else if (option->algtype <= SM4_128_XTS) { + } else if (option->algtype <= SM4_128_XTS_GB) { snprintf(option->algclass, MAX_ALG_NAME, "%s", "cipher"); option->acctype = SEC_TYPE; option->subtype = CIPHER_TYPE; diff --git a/uadk_tool/benchmark/uadk_benchmark.h b/uadk_tool/benchmark/uadk_benchmark.h index c2ba9bc..1cce63d 100644 --- a/uadk_tool/benchmark/uadk_benchmark.h +++ b/uadk_tool/benchmark/uadk_benchmark.h @@ -173,6 +173,7 @@ enum test_alg { SM4_128_OFB, SM4_128_CFB, SM4_128_XTS, + SM4_128_XTS_GB, AES_128_CCM, // aead AES_192_CCM, AES_256_CCM,

From: Qi Tao taoqi10@huawei.com

Add PIE、PIC、BIND_NOW、SP、NO Rpath/RunPath、FS、Ftrapv and Strip to UADK compilation.

Signed-off-by: Qi Tao taoqi10@huawei.com --- uadk_tool/Makefile.am | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/uadk_tool/Makefile.am b/uadk_tool/Makefile.am index 6b787f9..7f00087 100644 --- a/uadk_tool/Makefile.am +++ b/uadk_tool/Makefile.am @@ -1,7 +1,9 @@ ACLOCAL_AMFLAGS = -I m4 -I./include AUTOMAKE_OPTIONS = foreign subdir-objects -AM_CFLAGS=-Wall -fno-strict-aliasing -I$(top_srcdir) -I$(top_srcdir)/benchmark/include \ +AM_CFLAGS=-Wall -Werror -fno-strict-aliasing -I$(top_srcdir) -I$(top_srcdir)/benchmark/include \ -pthread +AM_CFLAGS += -fPIC -fPIE -pie -fstack-protector-strong -D_FORTIFY_SOURCE=2 \ +-O2 -ftrapv -Wl,-z,now -Wl,-s

#AUTOMAKE_OPTIONS = subdir-objects

@@ -33,8 +35,6 @@ uadk_tool_LDADD=-L../.libs -l:libwd.so.2 -l:libwd_crypto.so.2 \ -l:libwd_comp.so.2 -lnuma endif

-uadk_tool_LDFLAGS=-Wl,-rpath,'/usr/local/lib',--enable-new-dtags - if WITH_ZLIB_FSE_DIR AM_CFLAGS += -DZLIB_FSE uadk_tool_LDADD+= $(with_zlib_fse_dir)/libfse.a