- Acc - lists.linaro.org

[PATCH 1/3] uadk/v1/cipher: support aes-cbc cts mode

by Zhiqi Song

Support AES-CBC CTS(ciphertext stealing) mode in v1, including CBC-CS1, CBC-CS2, CBC-CS3. Signed-off-by: Zhiqi Song <songzhiqi1(a)huawei.com> --- v1/drv/hisi_sec_udrv.c | 100 ++++++++++++++++++++++++++++++++++++++--- v1/drv/hisi_sec_udrv.h | 6 +++ v1/wd_cipher.c | 3 ++ v1/wd_cipher.h | 4 ++ 4 files changed, 106 insertions(+), 7 deletions(-) diff --git a/v1/drv/hisi_sec_udrv.c b/v1/drv/hisi_sec_udrv.c index 4d5ede5..f9cd8c0 100644 --- a/v1/drv/hisi_sec_udrv.c +++ b/v1/drv/hisi_sec_udrv.c @@ -174,6 +174,18 @@ static int fill_cipher_bd2_mode(struct wcrypto_cipher_msg *msg, case WCRYPTO_CIPHER_XTS: sqe->type2.c_mode = C_MODE_XTS; break; + case WCRYPTO_CIPHER_CBC_CS1: + sqe->type2.c_mode = C_MODE_CBC_CS; + sqe->type2.c_width = C_WIDTH_CS1; + break; + case WCRYPTO_CIPHER_CBC_CS2: + sqe->type2.c_mode = C_MODE_CBC_CS; + sqe->type2.c_width = C_WIDTH_CS2; + break; + case WCRYPTO_CIPHER_CBC_CS3: + sqe->type2.c_mode = C_MODE_CBC_CS; + sqe->type2.c_width = C_WIDTH_CS3; + break; default: WD_ERR("Invalid cipher alg type!\n"); ret = -WD_EINVAL; @@ -248,6 +260,9 @@ static void update_iv(struct wcrypto_cipher_msg *msg) { switch (msg->mode) { case WCRYPTO_CIPHER_CBC: + case WCRYPTO_CIPHER_CBC_CS1: + case WCRYPTO_CIPHER_CBC_CS2: + case WCRYPTO_CIPHER_CBC_CS3: if (msg->op_type == WCRYPTO_CIPHER_ENCRYPTION && msg->out_bytes >= msg->iv_bytes) update_iv_from_res(msg->iv, msg->out, @@ -355,6 +370,18 @@ static int fill_cipher_bd1_mode(struct wcrypto_cipher_msg *msg, case WCRYPTO_CIPHER_XTS: sqe->type1.c_mode = C_MODE_XTS; break; + case WCRYPTO_CIPHER_CBC_CS1: + sqe->type1.c_mode = C_MODE_CBC_CS; + sqe->type1.c_width = C_WIDTH_CS1; + break; + case WCRYPTO_CIPHER_CBC_CS2: + sqe->type1.c_mode = C_MODE_CBC_CS; + sqe->type1.c_width = C_WIDTH_CS2; + break; + case WCRYPTO_CIPHER_CBC_CS3: + sqe->type1.c_mode = C_MODE_CBC_CS; + sqe->type1.c_width = C_WIDTH_CS3; + break; default: WD_ERR("Invalid cipher alg type for bd1\n"); return -WD_EINVAL; @@ -582,8 +609,32 @@ map_in_error: return ret; } +static int aes_sm4_param_check(struct wcrypto_cipher_msg *msg) +{ + if (msg->alg == WCRYPTO_CIPHER_AES && + msg->in_bytes <= CBC_AES_BLOCK_SIZE && + (msg->mode == WCRYPTO_CIPHER_CBC_CS1 || + msg->mode == WCRYPTO_CIPHER_CBC_CS2 || + msg->mode == WCRYPTO_CIPHER_CBC_CS3)) { + WD_ERR("failed to check input bytes of AES CTS, size = %u\n", + msg->in_bytes); + return -WD_EINVAL; + } + + if ((msg->in_bytes & (CBC_AES_BLOCK_SIZE - 1)) && + (msg->mode == WCRYPTO_CIPHER_CBC || + msg->mode == WCRYPTO_CIPHER_ECB)) { + WD_ERR("input AES or SM4 cipher parameter is error!\n"); + return -WD_EINVAL; + } + + return WD_SUCCESS; +} + static int cipher_param_check(struct wcrypto_cipher_msg *msg) { + int ret; + if (unlikely(msg->in_bytes > MAX_CIPHER_LENGTH || !msg->in_bytes)) { WD_ERR("input cipher len is too large!\n"); @@ -611,10 +662,9 @@ static int cipher_param_check(struct wcrypto_cipher_msg *msg) } if (msg->alg == WCRYPTO_CIPHER_AES || msg->alg == WCRYPTO_CIPHER_SM4) { - if (unlikely(msg->in_bytes & (CBC_AES_BLOCK_SIZE - 1))) { - WD_ERR("input AES or SM4 cipher parameter is error!\n"); - return -WD_EINVAL; - } + ret = aes_sm4_param_check(msg); + if (ret) + return ret; } return WD_SUCCESS; @@ -788,6 +838,18 @@ static int fill_cipher_bd3_mode(struct wcrypto_cipher_msg *msg, case WCRYPTO_CIPHER_CFB: sqe->c_mode = C_MODE_CFB; break; + case WCRYPTO_CIPHER_CBC_CS1: + sqe->c_mode = C_MODE_CBC_CS; + sqe->c_width = C_WIDTH_CS1; + break; + case WCRYPTO_CIPHER_CBC_CS2: + sqe->c_mode = C_MODE_CBC_CS; + sqe->c_width = C_WIDTH_CS2; + break; + case WCRYPTO_CIPHER_CBC_CS3: + sqe->c_mode = C_MODE_CBC_CS; + sqe->c_width = C_WIDTH_CS3; + break; default: WD_ERR("Invalid cipher alg type!\n"); ret = -WD_EINVAL; @@ -838,7 +900,7 @@ static int fill_cipher_bd3(struct wd_queue *q, struct hisi_sec_bd3_sqe *sqe, return ret; } -static int sm4_aes_mode_check(int mode) +static int sm4_mode_check(int mode) { switch (mode) { case WCRYPTO_CIPHER_ECB: @@ -855,6 +917,26 @@ static int sm4_aes_mode_check(int mode) } } +static int aes_mode_check(int mode) +{ + switch (mode) { + case WCRYPTO_CIPHER_ECB: + case WCRYPTO_CIPHER_CBC: + case WCRYPTO_CIPHER_OFB: + case WCRYPTO_CIPHER_CFB: + case WCRYPTO_CIPHER_CTR: + case WCRYPTO_CIPHER_XTS: + case WCRYPTO_CIPHER_CCM: + case WCRYPTO_CIPHER_GCM: + case WCRYPTO_CIPHER_CBC_CS1: + case WCRYPTO_CIPHER_CBC_CS2: + case WCRYPTO_CIPHER_CBC_CS3: + return WD_SUCCESS; + default: + return -WD_EINVAL; + } +} + static int triple_des_mode_check(int mode) { switch (mode) { @@ -873,8 +955,10 @@ static int cipher_comb_param_check(struct wcrypto_cipher_msg *msg) switch (msg->alg) { case WCRYPTO_CIPHER_SM4: + ret = sm4_mode_check(msg->mode); + break; case WCRYPTO_CIPHER_AES: - ret = sm4_aes_mode_check(msg->mode); + ret = aes_mode_check(msg->mode); break; case WCRYPTO_CIPHER_DES: case WCRYPTO_CIPHER_3DES: @@ -2125,8 +2209,10 @@ static int aead_comb_param_check(struct wcrypto_aead_msg *msg) switch (msg->calg) { case WCRYPTO_CIPHER_SM4: + ret = sm4_mode_check(msg->cmode); + break; case WCRYPTO_CIPHER_AES: - ret = sm4_aes_mode_check(msg->cmode); + ret = aes_mode_check(msg->cmode); break; default: return -WD_EINVAL; diff --git a/v1/drv/hisi_sec_udrv.h b/v1/drv/hisi_sec_udrv.h index 9c0da47..054ab71 100644 --- a/v1/drv/hisi_sec_udrv.h +++ b/v1/drv/hisi_sec_udrv.h @@ -461,6 +461,12 @@ enum C_MODE { C_MODE_CBC_CS = 0x9 }; +enum SEC_C_WIDTH { + C_WIDTH_CS1 = 0x1, + C_WIDTH_CS2 = 0x2, + C_WIDTH_CS3 = 0x3, +}; + enum CKEY_LEN { CKEY_LEN_128_BIT = 0x0, CKEY_LEN_192_BIT = 0x1, diff --git a/v1/wd_cipher.c b/v1/wd_cipher.c index 3d7d140..a53cf8f 100644 --- a/v1/wd_cipher.c +++ b/v1/wd_cipher.c @@ -82,6 +82,9 @@ static __u32 get_iv_block_size(int alg, int mode) switch (mode) { case WCRYPTO_CIPHER_CBC: + case WCRYPTO_CIPHER_CBC_CS1: + case WCRYPTO_CIPHER_CBC_CS2: + case WCRYPTO_CIPHER_CBC_CS3: case WCRYPTO_CIPHER_OFB: if (alg == WCRYPTO_CIPHER_3DES || alg == WCRYPTO_CIPHER_DES) diff --git a/v1/wd_cipher.h b/v1/wd_cipher.h index 591a590..dafd8a4 100644 --- a/v1/wd_cipher.h +++ b/v1/wd_cipher.h @@ -47,6 +47,10 @@ enum wcrypto_cipher_mode { WCRYPTO_CIPHER_CFB, WCRYPTO_CIPHER_CCM, WCRYPTO_CIPHER_GCM, + WCRYPTO_CIPHER_CBC_CS1, + WCRYPTO_CIPHER_CBC_CS2, + WCRYPTO_CIPHER_CBC_CS3, + WCRYPTO_CIPHER_MODE_MAX, }; /** -- 2.33.0

2 years

1
2
0 0

[PATCH 1/2] digest: fix free sess when it is still used

by Wenkai Lin

When EVP_MD_CTX_copy is used, the session is shared among ctxs. Ensure that the session is released when it is not used. Signed-off-by: Wenkai Lin <linwenkai6(a)hisilicon.com> --- src/uadk_digest.c | 184 ++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 163 insertions(+), 21 deletions(-) diff --git a/src/uadk_digest.c b/src/uadk_digest.c index b75c408..b7b9533 100644 --- a/src/uadk_digest.c +++ b/src/uadk_digest.c @@ -148,6 +148,78 @@ static EVP_MD *uadk_sha256; static EVP_MD *uadk_sha384; static EVP_MD *uadk_sha512; +struct ctx_info { + /* Use md_ctx as the key */ + EVP_MD_CTX *md_ctx; + /* Multiple ctxs may share the same session and data */ + handle_t sess; + unsigned char *data; + struct ctx_info *next; +}; + +/* Global table to record ctx and its session */ +static struct ctx_info *digest_ctx_info; +/* Lock for global ctx_info table */ +static pthread_mutex_t digest_ctx_mutex = PTHREAD_MUTEX_INITIALIZER; + +static void find_ctx_info(EVP_MD_CTX *ctx, struct ctx_info **node) +{ + struct ctx_info *pnext = digest_ctx_info; + + while (pnext) { + if (pnext->md_ctx == ctx) { + *node = pnext; + return; + } + pnext = pnext->next; + } +} + +static void del_ctx_info(struct ctx_info *node) +{ + struct ctx_info *pnext = digest_ctx_info; + + if (pnext == node) { + digest_ctx_info = pnext->next; + return; + } + + while (pnext) { + if (pnext->next == node) { + pnext->next = pnext->next->next; + return; + } + pnext = pnext->next; + } +} + +static void add_ctx_info(struct ctx_info *node) +{ + struct ctx_info *pnext = digest_ctx_info; + + if (!pnext) { + digest_ctx_info = node; + node->next = NULL; + } else { + node->next = digest_ctx_info; + digest_ctx_info = node; + } +} + +static bool is_ctx_sess_shared(struct ctx_info *node) +{ + struct ctx_info *pnext = digest_ctx_info; + + while (pnext) { + if ((pnext != node) && (pnext->sess == node->sess)) + return true; + + pnext = pnext->next; + } + + return false; +} + static const EVP_MD *uadk_e_digests_soft_md(uint32_t e_nid) { const EVP_MD *digest_md = NULL; @@ -491,6 +563,7 @@ static int uadk_e_init_digest(void) goto err_unlock; g_digest_engine.pid = getpid(); + digest_ctx_info = NULL; pthread_spin_unlock(&g_digest_engine.lock); free(dev); } @@ -515,7 +588,7 @@ static void digest_priv_ctx_setup(struct digest_priv_ctx *priv, priv->req.out_bytes = out_len; } -static void digest_priv_ctx_cleanup(struct digest_priv_ctx *priv) +static void digest_priv_ctx_reset(struct digest_priv_ctx *priv) { /* Ensure that private variable values are initialized */ priv->state = SEC_DIGEST_INIT; @@ -524,29 +597,52 @@ static void digest_priv_ctx_cleanup(struct digest_priv_ctx *priv) priv->switch_flag = 0; } +static int alloc_ctx_info(EVP_MD_CTX *ctx) +{ + struct digest_priv_ctx *priv = + (struct digest_priv_ctx *) EVP_MD_CTX_md_data(ctx); + struct ctx_info *node = NULL; + + pthread_mutex_lock(&digest_ctx_mutex); + find_ctx_info(ctx, &node); + if (node == NULL) { + node = malloc(sizeof(*node)); + if (node == NULL) { + pthread_mutex_unlock(&digest_ctx_mutex); + return 0; + } + node->md_ctx = ctx; + add_ctx_info(node); + } + node->sess = priv->sess; + node->data = priv->data; + pthread_mutex_unlock(&digest_ctx_mutex); + + return 1; +} + static int uadk_e_digest_init(EVP_MD_CTX *ctx) { struct digest_priv_ctx *priv = (struct digest_priv_ctx *) EVP_MD_CTX_md_data(ctx); __u32 digest_counts = ARRAY_SIZE(digest_info_table); - int nid = EVP_MD_nid(EVP_MD_CTX_md(ctx)); struct sched_params params = {0}; __u32 i; int ret; - priv->e_nid = nid; + priv->e_nid = EVP_MD_nid(EVP_MD_CTX_md(ctx)); - digest_priv_ctx_cleanup(priv); + digest_priv_ctx_reset(priv); ret = uadk_e_init_digest(); if (unlikely(!ret)) { priv->switch_flag = UADK_DO_SOFT; fprintf(stderr, "uadk failed to initialize digest.\n"); - goto soft_init; + return digest_soft_init(priv); } for (i = 0; i < digest_counts; i++) { - if (nid == digest_info_table[i].nid) { + if (priv->e_nid == digest_info_table[i].nid) { digest_priv_ctx_setup(priv, digest_info_table[i].alg, digest_info_table[i].mode, digest_info_table[i].out_len); break; @@ -561,22 +657,30 @@ static int uadk_e_digest_init(EVP_MD_CTX *ctx) /* Use the default numa parameters */ params.numa_id = -1; priv->setup.sched_param = &params; - priv->sess = wd_digest_alloc_sess(&priv->setup); - if (unlikely(!priv->sess)) - return 0; + if (!priv->sess) { + priv->sess = wd_digest_alloc_sess(&priv->setup); + if (unlikely(!priv->sess)) + return 0; - priv->data = malloc(DIGEST_BLOCK_SIZE); - if (unlikely(!priv->data)) { - wd_digest_free_sess(priv->sess); - return 0; + priv->data = malloc(DIGEST_BLOCK_SIZE); + if (unlikely(!priv->data)) + goto out; + + if (!alloc_ctx_info(ctx)) { + free(priv->data); + priv->data = NULL; + goto out; + } } - priv->switch_threshold = sec_digest_get_sw_threshold(nid); + priv->switch_threshold = sec_digest_get_sw_threshold(priv->e_nid); return 1; -soft_init: - return digest_soft_init(priv); +out: + wd_digest_free_sess(priv->sess); + priv->sess = 0; + return 0; } static void digest_update_out_length(EVP_MD_CTX *ctx) @@ -809,19 +913,36 @@ static int uadk_e_digest_cleanup(EVP_MD_CTX *ctx) { struct digest_priv_ctx *priv = (struct digest_priv_ctx *)EVP_MD_CTX_md_data(ctx); + struct ctx_info *node = NULL; - /* Prevent double-free after the copy is used */ - if (!priv || priv->copy) + if (!priv) + return 1; + + pthread_mutex_lock(&digest_ctx_mutex); + find_ctx_info(ctx, &node); + if (node == NULL) { + pthread_mutex_unlock(&digest_ctx_mutex); return 1; + } + + /* If another ctx uses the same session, the session is not released */ + if (is_ctx_sess_shared(node)) + goto out; + + if (priv->data) { + free(priv->data); + priv->data = NULL; + } if (priv->sess) { wd_digest_free_sess(priv->sess); priv->sess = 0; } - if (priv && priv->data) - free(priv->data); - +out: + del_ctx_info(node); + free(node); + pthread_mutex_unlock(&digest_ctx_mutex); return 1; } @@ -831,6 +952,7 @@ static int uadk_e_digest_copy(EVP_MD_CTX *to, const EVP_MD_CTX *from) (struct digest_priv_ctx *)EVP_MD_CTX_md_data(from); struct digest_priv_ctx *t = (struct digest_priv_ctx *)EVP_MD_CTX_md_data(to); + struct ctx_info *node = NULL; /* * EVP_MD_CTX_copy will copy from->priv to to->priv, @@ -838,6 +960,26 @@ static int uadk_e_digest_copy(EVP_MD_CTX *to, const EVP_MD_CTX *from) * add a flag to prevent double-free. */ + pthread_mutex_lock(&digest_ctx_mutex); + find_ctx_info(to, &node); + if (node == NULL) { + node = malloc(sizeof(*node)); + if (node == NULL) { + pthread_mutex_unlock(&digest_ctx_mutex); + return 0; + } + node->md_ctx = to; + add_ctx_info(node); + } else { + if (!is_ctx_sess_shared(node)) { + wd_digest_free_sess(node->sess); + free(node->data); + } + } + node->sess = t->sess; + node->data = t->data; + pthread_mutex_unlock(&digest_ctx_mutex); + if (f && f->data) t->copy = true; -- 2.33.0

2 years

1
1
0 0

[PATCH 0/3] uadk: add msg pool depth set

by Weili Qian

2 years

1
3
0 0

[PATCH 0/3] uadk: fix some issues in uadk

by Weili Qian

1. Fix local variable type. 2. Fix memory leak in sgl-related interfaces. Weili Qian (3): uadk/v1 - fix local variable type drv/qm: fix memory leak in hisi_qm_create_sglpool() uadk/v1: fix memory leak in wd_sgl.c drv/hisi_qm_udrv.c | 7 ++--- v1/drv/hisi_rng_udrv.c | 2 +- v1/wd_sgl.c | 58 ++++++++++++++++++++++++++++-------------- 3 files changed, 44 insertions(+), 23 deletions(-) -- 2.30.0

2 years, 1 month

1
3
0 0

[PATCH 0/2] Some bugfix for hisi-comp

by Yang Shen

1.Fix memory leak. 2.Add output size check. Yang Shen (2): uadk/hisi_comp - free sgl when send request error uadk/hisi_comp - add output length check for lz77_zstd sgl mode drv/hisi_comp.c | 92 +++++++++++++++++++++++++++++-------------------- 1 file changed, 54 insertions(+), 38 deletions(-) -- 2.24.0

2 years, 1 month

1
2
0 0

[PATCH 00/15] Some cleanup and bugfix of uadk_engine

by Zhiqi Song

This series patch include bugfix about: 1. Source release problems. 2. Null pointer judgement. 3. Error handling. Hao Fang (1): uadk_engine/v1: clean the empty body in an if statement Zhiqi Song (14): uadk_engine: fixup signed-unsigned mix with relational uadk_engine: fixup variable naming conflicts digest: fixup free source method ecc: fixup free source method inconsistent cipher: fixup error handling in ctx init uadk_engine: modify setting async poll state process dh: fixup release source of private key ecc: Add pkey method null pointer judgment rsa: release source when new kg out failed rsa: bugfix repeated source release sm2: fixup unreleased source in data conversion ecc: add openssl method null pointer judgement async: add null pointer judgment uadk_engine: cleanup call form of callback func src/uadk_async.c | 13 ++- src/uadk_cipher.c | 127 ++++++++++++++------------ src/uadk_dh.c | 104 +++++++++++----------- src/uadk_digest.c | 89 ++++++++++--------- src/uadk_ec.c | 28 +++++- src/uadk_ecx.c | 28 ++++-- src/uadk_pkey.c | 19 ++-- src/uadk_pkey.h | 2 +- src/uadk_rsa.c | 13 ++- src/uadk_sm2.c | 181 ++++++++++++++++++++++---------------- src/uadk_utils.h | 1 - src/v1/utils/engine_log.c | 3 +- 12 files changed, 359 insertions(+), 249 deletions(-) -- 2.33.0

2 years, 2 months

1
15
0 0

[PATCH 00/10] Somen bugfix and cleanup of uadk_engine

by Zhiqi Song

This seires patch include: 1. Cleanup of v1 code. 2. Bugfix about some variable type and memory release issues. Hao Fang (1): uadk_engine/v1: clean the empty body in an if statement Zhiqi Song (9): uadk_engine: fixup signed-unsigned mix with relational uadk_engine: fixup variable naming conflicts digest: fixup free source method ecc: fixup free source method inconsistent cipher: fixup error handling in ctx init uadk_engine: modify setting async poll state process dh: fixup release source of private key ecc: add pkey method null pointer judgment rsa: release source when new kg out failed src/uadk_async.c | 5 +- src/uadk_cipher.c | 121 +++++++++++++++++++++----------------- src/uadk_dh.c | 102 +++++++++++++++++--------------- src/uadk_digest.c | 77 ++++++++++++------------ src/uadk_ec.c | 7 ++- src/uadk_ecx.c | 26 +++++--- src/uadk_pkey.c | 15 +++-- src/uadk_rsa.c | 7 ++- src/uadk_sm2.c | 25 ++++++++ src/uadk_utils.h | 1 - src/v1/utils/engine_log.c | 3 +- 11 files changed, 225 insertions(+), 164 deletions(-) -- 2.33.0

2 years, 2 months

1
10
0 0

[PATCH] uadk/comp - some misc fixes

by Yang Shen

Some misc fixes: 1. Add parameters check. 2. Fix some static check. 3. Some typo. Signed-off-by: Yang Shen <shenyang39(a)huawei.com> --- wd_comp.c | 146 ++++++++++++++++++++++++++++++++++-------------------- 1 file changed, 92 insertions(+), 54 deletions(-) diff --git a/wd_comp.c b/wd_comp.c index 6be6b72..671baba 100644 --- a/wd_comp.c +++ b/wd_comp.c @@ -27,6 +27,10 @@ #define cpu_to_be32(x) swap_byte(x) +static char *wd_comp_alg_name[WD_COMP_ALG_MAX] = { + "zlib", "gzip", "deflate", "lz77_zstd" +}; + struct wd_comp_sess { enum wd_comp_alg_type alg_type; enum wd_comp_level comp_lv; @@ -68,13 +72,6 @@ static int wd_comp_open_driver(void) const char *alg_name = "zlib"; int ret; - /* - * Compatible with the normal acquisition of device - * drivers in the init interface - */ - if (wd_comp_setting.dlh_list) - return 0; - ret = wd_get_lib_file_path("libhisi_zip.so", lib_path, false); if (ret) return ret; @@ -102,6 +99,21 @@ static void wd_comp_clear_status(void) wd_alg_clear_init(&wd_comp_setting.status); } +static bool wd_comp_alg_check(const char *alg_name) +{ + int i; + + for (i = 0; i < WD_COMP_ALG_MAX; i++) { + /* Some algorithms do not support all modes */ + if (!wd_comp_alg_name[i] || !strlen(wd_comp_alg_name[i])) + continue; + if (!strcmp(alg_name, wd_comp_alg_name[i])) + return true; + } + + return false; +} + static int wd_comp_init_nolock(struct wd_ctx_config *config, struct wd_sched *sched) { int ret; @@ -143,21 +155,23 @@ out_clear_ctx_config: return ret; } -static void wd_comp_uninit_nolock(void) +static int wd_comp_uninit_nolock(void) { void *priv = wd_comp_setting.priv; if (!priv) - return; + return -WD_EINVAL; - /* uninit async request pool */ + /* Uninit async request pool */ wd_uninit_async_request_pool(&wd_comp_setting.pool); - /* unset config, sched, driver */ + /* Unset config, sched, driver */ wd_clear_sched(&wd_comp_setting.sched); wd_alg_uninit_driver(&wd_comp_setting.config, wd_comp_setting.driver, &priv); + + return 0; } int wd_comp_init(struct wd_ctx_config *config, struct wd_sched *sched) @@ -196,7 +210,11 @@ out_clear_init: void wd_comp_uninit(void) { - wd_comp_uninit_nolock(); + int ret; + + ret = wd_comp_uninit_nolock(); + if (ret) + return; wd_comp_close_driver(); wd_alg_clear_init(&wd_comp_setting.status); @@ -206,7 +224,7 @@ int wd_comp_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_par { struct wd_ctx_nums comp_ctx_num[WD_DIR_MAX] = {0}; struct wd_ctx_params comp_ctx_params; - int ret = 0; + int ret = -WD_EINVAL; bool flag; pthread_atfork(NULL, NULL, wd_comp_clear_status); @@ -215,16 +233,21 @@ int wd_comp_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_par if (!flag) return -WD_EEXIST; - if (!alg || sched_type > SCHED_POLICY_BUTT || - task_type < 0 || task_type > TASK_MAX_TYPE) { + if (!alg || sched_type >= SCHED_POLICY_BUTT || + task_type < 0 || task_type >= TASK_MAX_TYPE) { WD_ERR("invalid: input param is wrong!\n"); - ret = -WD_EINVAL; + goto out_uninit; + } + + flag = wd_comp_alg_check(alg); + if (!flag) { + WD_ERR("invalid: comp:%s unsupported!\n", alg); goto out_uninit; } /* * Driver lib file path could set by env param. - * than open tham by wd_dlopen_drv() + * then open tham by wd_dlopen_drv() * use NULL means dynamic query path */ wd_comp_setting.dlh_list = wd_dlopen_drv(NULL); @@ -233,44 +256,45 @@ int wd_comp_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_par goto out_uninit; } -res_retry: - memset(&wd_comp_setting.config, 0, sizeof(struct wd_ctx_config_internal)); + while (ret != 0) { + memset(&wd_comp_setting.config, 0, sizeof(struct wd_ctx_config_internal)); - /* Get alg driver and dev name */ - wd_comp_setting.driver = wd_alg_drv_bind(task_type, alg); - if (!wd_comp_setting.driver) { - WD_ERR("fail to bind a valid driver.\n"); - goto out_dlopen; - } + /* Get alg driver and dev name */ + wd_comp_setting.driver = wd_alg_drv_bind(task_type, alg); + if (!wd_comp_setting.driver) { + WD_ERR("failed to bind %s driver.\n", alg); + goto out_dlclose; + } - comp_ctx_params.ctx_set_num = comp_ctx_num; - ret = wd_ctx_param_init(&comp_ctx_params, ctx_params, - wd_comp_setting.driver, WD_COMP_TYPE, WD_DIR_MAX); - if (ret) { - if (ret == -WD_EAGAIN) { - wd_disable_drv(wd_comp_setting.driver); - wd_alg_drv_unbind(wd_comp_setting.driver); - goto res_retry; + comp_ctx_params.ctx_set_num = comp_ctx_num; + ret = wd_ctx_param_init(&comp_ctx_params, ctx_params, + wd_comp_setting.driver, WD_COMP_TYPE, WD_DIR_MAX); + if (ret) { + if (ret == -WD_EAGAIN) { + wd_disable_drv(wd_comp_setting.driver); + wd_alg_drv_unbind(wd_comp_setting.driver); + continue; + } + goto out_unbind_drv; } - goto out_driver; - } - - wd_comp_init_attrs.alg = alg; - wd_comp_init_attrs.sched_type = sched_type; - wd_comp_init_attrs.driver = wd_comp_setting.driver; - wd_comp_init_attrs.ctx_params = &comp_ctx_params; - wd_comp_init_attrs.alg_init = wd_comp_init_nolock; - wd_comp_init_attrs.alg_poll_ctx = wd_comp_poll_ctx; - ret = wd_alg_attrs_init(&wd_comp_init_attrs); - if (ret) { - if (ret == -WD_ENODEV) { - wd_disable_drv(wd_comp_setting.driver); - wd_alg_drv_unbind(wd_comp_setting.driver); - wd_ctx_param_uninit(&comp_ctx_params); - goto res_retry; + + wd_comp_init_attrs.alg = alg; + wd_comp_init_attrs.sched_type = sched_type; + wd_comp_init_attrs.driver = wd_comp_setting.driver; + wd_comp_init_attrs.ctx_params = &comp_ctx_params; + wd_comp_init_attrs.alg_init = wd_comp_init_nolock; + wd_comp_init_attrs.alg_poll_ctx = wd_comp_poll_ctx; + ret = wd_alg_attrs_init(&wd_comp_init_attrs); + if (ret) { + if (ret == -WD_ENODEV) { + wd_disable_drv(wd_comp_setting.driver); + wd_alg_drv_unbind(wd_comp_setting.driver); + wd_ctx_param_uninit(&comp_ctx_params); + continue; + } + WD_ERR("fail to init alg attrs.\n"); + goto out_params_uninit; } - WD_ERR("fail to init alg attrs.\n"); - goto out_params_uninit; } wd_alg_set_init(&wd_comp_setting.status); @@ -280,9 +304,9 @@ res_retry: out_params_uninit: wd_ctx_param_uninit(&comp_ctx_params); -out_driver: +out_unbind_drv: wd_alg_drv_unbind(wd_comp_setting.driver); -out_dlopen: +out_dlclose: wd_dlclose_drv(wd_comp_setting.dlh_list); out_uninit: wd_alg_clear_init(&wd_comp_setting.status); @@ -291,7 +315,11 @@ out_uninit: void wd_comp_uninit2(void) { - wd_comp_uninit_nolock(); + int ret; + + ret = wd_comp_uninit_nolock(); + if (ret) + return; wd_alg_attrs_uninit(&wd_comp_init_attrs); wd_alg_drv_unbind(wd_comp_setting.driver); @@ -844,6 +872,11 @@ int wd_comp_poll(__u32 expt, __u32 *count) handle_t h_sched_ctx; struct wd_sched *sched; + if (unlikely(!count)) { + WD_ERR("invalid: comp poll count is NULL!\n"); + return -WD_EINVAL; + } + h_sched_ctx = wd_comp_setting.sched.h_sched_ctx; sched = &wd_comp_setting.sched; @@ -915,6 +948,11 @@ int wd_comp_get_env_param(__u32 node, __u32 type, __u32 mode, struct wd_ctx_attr ctx_attr; int ret; + if (!num || !is_enable) { + WD_ERR("invalid: num or is_enable is NULL!\n"); + return -WD_EINVAL; + } + if (type >= WD_DIR_MAX) { WD_ERR("invalid: op_type is %u!\n", type); return -WD_EINVAL; -- 2.24.0

2 years, 2 months

1
0
0 0

[PATCH 0/4] uadk: fix some uadk framework issues

by Longfang Liu

According to the needs of device driver registration. Algorithm-driven priorities and types need to be distinguished. Hao Fang (1): uadk/crypto: tinyfix for digest/aead/cipher init2 Longfang Liu (3): uadk/alg: bugfix some dynamically loading framework issues uadk: fix some uadk framework issues uadk/drv: update the registration properties of the uadk driver. drv/hisi_comp.c | 9 +-- drv/hisi_hpre.c | 52 ++++++++++------- drv/hisi_sec.c | 26 ++++----- include/wd.h | 6 ++ include/wd_alg.h | 52 ++++++++++++++++- wd.c | 18 +++--- wd_aead.c | 102 ++++++++++++++++------------------ wd_alg.c | 139 +++++++++++++++++++++++++++++++++------------- wd_cipher.c | 141 ++++++++++++++++++++++++++++------------------- wd_digest.c | 104 ++++++++++++++++------------------ wd_util.c | 21 +++++-- 11 files changed, 412 insertions(+), 258 deletions(-) -- 2.33.0

2 years, 2 months

1
4
0 0

[PATCH 00/10] uadk_engine: bugfix and cleanup

by Zhiqi Song

This patch set including the following modify: 1. Some optimization of ECC and Digest algorithms to improve the performance of them. 2. Some bugfix and cleanup of the code. 3. Fixup the README.md info about enviroment variable. Zhiqi Song (10): uadk_engine: bugfix null dereference in abnormal conditions digest: cleanup magic number in digest dh: cleanup redundant macro definition ecc: bugfix about repeated alg and dev queries ecc: bugfix the conversion of sm2 pubkey point uadk_engine: modify static check problem ecc: optimize sm2 ctrl process to improve performance digest: remove soft ctx allocation in digest init process ecc: optimize sm2 update session process uadk_engine: fix openssl config info README.md | 16 ++++---- src/uadk_async.c | 22 +++++++++-- src/uadk_async.h | 7 +++- src/uadk_dh.c | 1 - src/uadk_digest.c | 98 +++++++++++++++++++++++++++-------------------- src/uadk_ec.c | 79 ++++++++++++++++++++++++++++---------- src/uadk_ecx.c | 23 +++++++++-- src/uadk_pkey.c | 66 +++++++++++++++++++------------ src/uadk_pkey.h | 13 ++++++- src/uadk_rsa.c | 18 +++++++++ src/uadk_sm2.c | 87 ++++++++++++++++++++++++++++++----------- 11 files changed, 303 insertions(+), 127 deletions(-) -- 2.30.0

2 years, 2 months

1
10
0 0

2025

2024

2023

2022

Acc