From: lizhi <lizhi206@huawei.com> Upstream: Yes Bugfix or Feature: Bugfix DTS: DTS2024111417327 1. Support ecdh with secp256r1 curve. 2. The algorithm will be scheduled first for high-performance cores. 3. The result of configuration does not affect the task success or failure. Signed-off-by: lizhi <lizhi206@huawei.com> Signed-off-by: Qi Tao <taoqi10@huawei.com> --- drv/hisi_hpre.c | 90 +++++++++++++++++++++++++++++++++++++++- include/drv/wd_ecc_drv.h | 9 ++++ include/wd_ecc_curve.h | 27 ++++++++++++ wd_ecc.c | 60 +++++++++++++++++++++++++-- 4 files changed, 182 insertions(+), 4 deletions(-) diff --git a/drv/hisi_hpre.c b/drv/hisi_hpre.c index c92d63ed..4270413d 100644 --- a/drv/hisi_hpre.c +++ b/drv/hisi_hpre.c @@ -10,6 +10,7 @@ #include <sys/mman.h> #include <sys/types.h> #include "hisi_qm_udrv.h" +#include "../include/wd_ecc_curve.h" #include "../include/drv/wd_rsa_drv.h" #include "../include/drv/wd_dh_drv.h" #include "../include/drv/wd_ecc_drv.h" @@ -42,6 +43,10 @@ #define WD_TRANS_FAIL 0 +#define CURVE_PARAM_NUM 6 +#define SECP256R1_KEY_SIZE 32 +#define SECP256R1_PARAM_SIZE (CURVE_PARAM_NUM * SECP256R1_KEY_SIZE) + enum hpre_alg_type { HPRE_ALG_NC_NCRT = 0x0, HPRE_ALG_NC_CRT = 0x1, @@ -110,6 +115,10 @@ struct hisi_hpre_ctx { struct wd_ctx_config_internal config; }; +struct hpre_ecc_ctx { + __u32 enable_hpcore; +}; + static void dump_hpre_msg(void *msg, int alg) { struct wd_rsa_msg *rsa_msg; @@ -1359,6 +1368,7 @@ static int u_is_in_p(struct wd_ecc_msg *msg) static int ecc_prepare_in(struct wd_ecc_msg *msg, struct hisi_hpre_sqe *hw_msg, void **data) { + struct hpre_ecc_ctx *ecc_ctx = msg->drv_cfg; int ret = -WD_EINVAL; switch (msg->req.op_type) { @@ -1367,11 +1377,15 @@ static int ecc_prepare_in(struct wd_ecc_msg *msg, /* driver to identify sm2 algorithm when async receive */ hw_msg->sm2_mlen = msg->req.op_type; hw_msg->bd_rsv2 = 1; /* fall through */ - case WD_SM2_KG: /* fall through */ + case WD_SM2_KG: + ret = ecc_prepare_dh_gen_in(msg, hw_msg, data); + break; case WD_ECXDH_GEN_KEY: + hw_msg->bd_rsv2 = ecc_ctx->enable_hpcore; ret = ecc_prepare_dh_gen_in(msg, hw_msg, data); break; case WD_ECXDH_COMPUTE_KEY: + hw_msg->bd_rsv2 = ecc_ctx->enable_hpcore; ret = ecc_prepare_dh_compute_in(msg, hw_msg, data); if (!ret && (msg->curve_id == WD_X25519 || msg->curve_id == WD_X448)) @@ -2492,6 +2506,79 @@ static int hpre_get_usage(void *param) return WD_SUCCESS; } +static int ecc_sess_eops_init(void **params) +{ + struct hpre_ecc_ctx *ecc_ctx; + + if (!params) { + WD_ERR("invalid: extend ops init params address is NULL!\n"); + return -WD_EINVAL; + } + + if (*params) { + WD_ERR("invalid: extend ops init params repeatedly!\n"); + return -WD_EINVAL; + } + + ecc_ctx = calloc(1, sizeof(struct hpre_ecc_ctx)); + if (!ecc_ctx) + return -WD_ENOMEM; + + *params = ecc_ctx; + + return WD_SUCCESS; +} + +static void ecc_sess_eops_uninit(void *params) +{ + if (!params) { + WD_ERR("invalid: extend ops uninit params is NULL!\n"); + return; + } + + free(params); + params = NULL; +} + +static void ecc_sess_eops_params_cfg(struct wd_ecc_sess_setup *setup, + struct wd_ecc_curve *cv, void *params) +{ + __u8 data[SECP256R1_PARAM_SIZE] = SECG_P256_R1_PARAM; + struct hpre_ecc_ctx *ecc_ctx = params; + __u32 key_size; + int ret = 0; + + if (!ecc_ctx) { + WD_INFO("Info: eops config exits, but params is NULL!\n"); + return; + } + + if (strcmp(setup->alg, "ecdh")) + return; + + key_size = BITS_TO_BYTES(setup->key_bits); + if (key_size != SECP256R1_KEY_SIZE) + return; + + ret = memcmp(data, cv->p.data, SECP256R1_PARAM_SIZE); + if (!ret) + ecc_ctx->enable_hpcore = 1; +} + +static int hpre_ecc_get_extend_ops(void *ops) +{ + struct wd_ecc_extend_ops *ecc_ops = ops; + + if (!ecc_ops) + return -WD_EINVAL; + + ecc_ops->params = NULL; + ecc_ops->sess_init = ecc_sess_eops_init; + ecc_ops->eops_params_cfg = ecc_sess_eops_params_cfg; + ecc_ops->sess_uninit = ecc_sess_eops_uninit; + return WD_SUCCESS; +} + #define GEN_HPRE_ALG_DRIVER(hpre_alg_name) \ {\ .drv_name = "hisi_hpre",\ @@ -2506,6 +2593,7 @@ static int hpre_get_usage(void *param) .send = ecc_send,\ .recv = ecc_recv,\ .get_usage = hpre_get_usage,\ + .get_extend_ops = hpre_ecc_get_extend_ops,\ } static struct wd_alg_driver hpre_ecc_driver[] = { diff --git a/include/drv/wd_ecc_drv.h b/include/drv/wd_ecc_drv.h index f5805cdc..37908cd2 100644 --- a/include/drv/wd_ecc_drv.h +++ b/include/drv/wd_ecc_drv.h @@ -54,6 +54,7 @@ struct wd_ecc_msg { __u16 key_bytes; /* key bytes */ __u8 curve_id; /* Ec curve denoted by enum wd_ecc_curve_type */ __u8 result; /* alg op error code */ + void *drv_cfg; /* internal driver configuration */ }; struct wd_ecc_pubkey { @@ -175,6 +176,14 @@ struct wd_ecc_out { char data[]; }; +struct wd_ecc_extend_ops { + void *params; /* the params are passed to the following ops */ + int (*eops_params_cfg)(struct wd_ecc_sess_setup *setup, + struct wd_ecc_curve *cv, void *params); + int (*sess_init)(void **params); + void (*sess_uninit)(void *params); +}; + struct wd_ecc_msg *wd_ecc_get_msg(__u32 idx, __u32 tag); #ifdef __cplusplus diff --git a/include/wd_ecc_curve.h b/include/wd_ecc_curve.h index 20b017a8..1f83edcd 100644 --- a/include/wd_ecc_curve.h +++ b/include/wd_ecc_curve.h @@ -175,6 +175,33 @@ extern "C" { 0xBF, 0xD2, 0x5E, 0x8C, 0xD0, 0x36, 0x41, 0x41\ } +#define SECG_P256_R1_PARAM {\ + /* p */\ + 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,\ + /* a */\ + 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,\ + /* b */\ + 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,\ + /* x */\ + 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,\ + /* y */\ + 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,\ + /* order */\ + 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,\ +} + #define BRAINPOOL_P320_R1_PARAM {\ /* p */\ 0xD3, 0x5E, 0x47, 0x20, 0x36, 0xBC, 0x4F, 0xB7, 0xE1, 0x3C, 0x78, 0x5E,\ diff --git a/wd_ecc.c b/wd_ecc.c index bf7cd346..b60eedaa 100644 --- a/wd_ecc.c +++ b/wd_ecc.c @@ -28,6 +28,7 @@ #define SM2_KEY_SIZE 32 #define GET_NEGATIVE(val) (0 - (val)) #define ZA_PARAM_NUM 6 +#define WD_SECP256R1 0x18 /* consistent with enum wd_ecc_curve_id */ static __thread __u64 balance; @@ -49,6 +50,7 @@ struct wd_ecc_sess { __u32 key_size; struct wd_ecc_key key; struct wd_ecc_sess_setup setup; + struct wd_ecc_extend_ops eops; void *sched_key; }; @@ -84,7 +86,8 @@ static const struct wd_ecc_curve_list curve_list[] = { { WD_BRAINPOOLP384R1, "bpP384r1", 384, BRAINPOOL_P384_R1_PARAM }, { WD_SECP384R1, "secp384r1", 384, SECG_P384_R1_PARAM }, { WD_SECP521R1, "secp521r1", 521, SECG_P521_R1_PARAM }, - { WD_SM2P256, "sm2", 256, SM2_P256_V1_PARAM } + { WD_SM2P256, "sm2", 256, SM2_P256_V1_PARAM }, + { WD_SECP256R1, "secp256r1", 256, SECG_P256_R1_PARAM }, }; static const struct curve_param_desc curve_pram_list[] = { @@ -1166,6 +1169,39 @@ static void del_sess_key(struct wd_ecc_sess *sess) } } +static int wd_ecc_sess_eops_init(struct wd_ecc_sess *sess) +{ + int ret; + + if (sess->eops.sess_init) { + if (!sess->eops.sess_uninit) { + WD_ERR("failed to get extend ops in session!\n"); + return -WD_EINVAL; + } + ret = sess->eops.sess_init(&sess->eops.params); + if (ret) { + WD_ERR("failed to init extend ops params in session!\n"); + return ret; + } + } + return WD_SUCCESS; +} + +static void wd_ecc_sess_eops_uninit(struct wd_ecc_sess *sess) +{ + if (sess->eops.sess_uninit) + sess->eops.sess_uninit(sess->eops.params); +} + +static void wd_ecc_sess_eops_cfg(struct wd_ecc_sess_setup *setup, + struct wd_ecc_sess *sess) +{ + if (sess->eops.sess_init && sess->eops.eops_params_cfg) { + /* the config result does not impact task sucesss or failure */ + sess->eops.eops_params_cfg(setup, sess->key.cv, sess->eops.params); + } +} + handle_t wd_ecc_alloc_sess(struct wd_ecc_sess_setup *setup) { struct wd_ecc_sess *sess; @@ -1187,12 +1223,26 @@ handle_t wd_ecc_alloc_sess(struct wd_ecc_sess_setup *setup) memcpy(&sess->setup, setup, sizeof(*setup)); sess->key_size = BITS_TO_BYTES(setup->key_bits); - ret = create_sess_key(setup, sess); + ret = wd_ecc_setting.driver->get_extend_ops(&sess->eops); + if (ret) { + WD_ERR("failed to get ecc sess extend ops!\n"); + goto sess_err; + } + + ret = wd_ecc_sess_eops_init(sess); if (ret) { - WD_ERR("failed to creat ecc sess keys!\n"); + WD_ERR("failed to init ecc sess extend eops!\n"); goto sess_err; } + ret = create_sess_key(setup, sess); + if (ret) { + WD_ERR("failed to create ecc sess keys!\n"); + goto eops_err; + } + + wd_ecc_sess_eops_cfg(setup, sess); + /* Some simple scheduler don't need scheduling parameters */ sess->sched_key = (void *)wd_ecc_setting.sched.sched_init( wd_ecc_setting.sched.h_sched_ctx, setup->sched_param); @@ -1205,6 +1255,8 @@ handle_t wd_ecc_alloc_sess(struct wd_ecc_sess_setup *setup) sched_err: del_sess_key(sess); +eops_err: + wd_ecc_sess_eops_uninit(sess); sess_err: free(sess); return (handle_t)0; @@ -1222,6 +1274,7 @@ void wd_ecc_free_sess(handle_t sess) if (sess_t->sched_key) free(sess_t->sched_key); del_sess_key(sess_t); + wd_ecc_sess_eops_uninit(sess); free(sess_t); } @@ -1494,6 +1547,7 @@ static int fill_ecc_msg(struct wd_ecc_msg *msg, struct wd_ecc_req *req, memcpy(&msg->hash, &sess->setup.hash, sizeof(msg->hash)); msg->key_bytes = sess->key_size; msg->curve_id = sess->setup.cv.cfg.id; + msg->drv_cfg = sess->eops.params; msg->result = WD_EINVAL; switch (req->op_type) { -- 2.33.0

From: Zhiqi Song <songzhiqi1@huawei.com> The operation of setting the input parameter to NULL is redundant and therefore deleted. Signed-off-by: Zhiqi Song <songzhiqi1@huawei.com> Signed-off-by: Qi Tao <taoqi10@huawei.com> --- drv/hisi_hpre.c | 1 - 1 file changed, 1 deletion(-) diff --git a/drv/hisi_hpre.c b/drv/hisi_hpre.c index 4270413d..e0cd7424 100644 --- a/drv/hisi_hpre.c +++ b/drv/hisi_hpre.c @@ -2537,7 +2537,6 @@ static void ecc_sess_eops_uninit(void *params) } free(params); - params = NULL; } static void ecc_sess_eops_params_cfg(struct wd_ecc_sess_setup *setup, -- 2.33.0

From: Hao Fang <fanghao11@huawei.com> The judement is incorrect. As a result, the x448 and x25519 alg process is intercepted. So just remove it. Signed-off-by: Hao Fang <fanghao11@huawei.com> Signed-off-by: Qi Tao <taoqi10@huawei.com> --- uadk_tool/benchmark/hpre_uadk_benchmark.c | 32 ++++++++++------------- uadk_tool/benchmark/hpre_wd_benchmark.c | 32 ++++++++++------------- 2 files changed, 28 insertions(+), 36 deletions(-) diff --git a/uadk_tool/benchmark/hpre_uadk_benchmark.c b/uadk_tool/benchmark/hpre_uadk_benchmark.c index 2eb7a188..585d70af 100644 --- a/uadk_tool/benchmark/hpre_uadk_benchmark.c +++ b/uadk_tool/benchmark/hpre_uadk_benchmark.c @@ -2262,22 +2262,20 @@ static void *ecc_uadk_sync_run(void *arg) u32 count = 0; int ret; - memset(&sess_setup, 0, sizeof(sess_setup)); - memset(¶m, 0, sizeof(param)); - memset(&req, 0, sizeof(req)); + memset(&sess_setup, 0, sizeof(sess_setup)); + memset(¶m, 0, sizeof(param)); + memset(&req, 0, sizeof(req)); - memset(&setup, 0, sizeof(setup)); + memset(&setup, 0, sizeof(setup)); if (pdata->algtype == ECDH_256R1) cid = ECC_CURVE_SECP256R1; else cid = ECC_CURVE_SECP256K1; - if (subtype != X448_TYPE && subtype != X25519_TYPE) { - ret = get_ecc_curve(&setup, cid); - if (ret) - return NULL; - } + ret = get_ecc_curve(&setup, cid); + if (ret) + return NULL; sess_setup.key_bits = pdata->keybits; if (subtype == ECDH_TYPE || subtype == ECDSA_TYPE) { @@ -2427,22 +2425,20 @@ static void *ecc_uadk_async_run(void *arg) u32 count = 0; int i, ret; - memset(&sess_setup, 0, sizeof(sess_setup)); - memset(¶m, 0, sizeof(param)); - memset(&req, 0, sizeof(req)); + memset(&sess_setup, 0, sizeof(sess_setup)); + memset(¶m, 0, sizeof(param)); + memset(&req, 0, sizeof(req)); - memset(&setup, 0, sizeof(setup)); + memset(&setup, 0, sizeof(setup)); if (pdata->algtype == ECDH_256R1) cid = ECC_CURVE_SECP256R1; else cid = ECC_CURVE_SECP256K1; - if (subtype != X448_TYPE && subtype != X25519_TYPE) { - ret = get_ecc_curve(&setup, cid); - if (ret) - return NULL; - } + ret = get_ecc_curve(&setup, cid); + if (ret) + return NULL; sess_setup.key_bits = pdata->keybits; if (subtype == ECDH_TYPE || subtype == ECDSA_TYPE) { diff --git a/uadk_tool/benchmark/hpre_wd_benchmark.c b/uadk_tool/benchmark/hpre_wd_benchmark.c index c4ee73cd..60ed3bd9 100644 --- a/uadk_tool/benchmark/hpre_wd_benchmark.c +++ b/uadk_tool/benchmark/hpre_wd_benchmark.c @@ -2107,19 +2107,17 @@ static void *ecc_wd_sync_run(void *arg) u32 count = 0; int ret; - memset(&ctx_setup, 0, sizeof(ctx_setup)); - memset(¶m, 0, sizeof(param)); - memset(&opdata, 0, sizeof(opdata)); + memset(&ctx_setup, 0, sizeof(ctx_setup)); + memset(¶m, 0, sizeof(param)); + memset(&opdata, 0, sizeof(opdata)); pool = g_thread_queue.bd_res[pdata->td_id].pool; queue = g_thread_queue.bd_res[pdata->td_id].queue; - memset(&setup, 0, sizeof(setup)); - if (subtype != X448_TYPE && subtype != X25519_TYPE) { - ret = get_ecc_curve(&setup, cid); - if (ret) - return NULL; - } + memset(&setup, 0, sizeof(setup)); + ret = get_ecc_curve(&setup, cid); + if (ret) + return NULL; ctx_setup.br.alloc = (void *)wd_alloc_blk; ctx_setup.br.free = (void *)wd_free_blk; @@ -2265,19 +2263,17 @@ static void *ecc_wd_async_run(void *arg) u32 count = 0; int i, ret; - memset(&ctx_setup, 0, sizeof(ctx_setup)); - memset(¶m, 0, sizeof(param)); - memset(&opdata, 0, sizeof(opdata)); + memset(&ctx_setup, 0, sizeof(ctx_setup)); + memset(¶m, 0, sizeof(param)); + memset(&opdata, 0, sizeof(opdata)); pool = g_thread_queue.bd_res[pdata->td_id].pool; queue = g_thread_queue.bd_res[pdata->td_id].queue; - memset(&setup, 0, sizeof(setup)); - if (subtype != X448_TYPE && subtype != X25519_TYPE) { - ret = get_ecc_curve(&setup, cid); - if (ret) - return NULL; - } + memset(&setup, 0, sizeof(setup)); + ret = get_ecc_curve(&setup, cid); + if (ret) + return NULL; ctx_setup.cb = (void *)ecc_async_cb; ctx_setup.br.alloc = (void *)wd_alloc_blk; -- 2.33.0

From: Chenghai Huang <huangchenghai2@huawei.com> When the tail packet is buffered, the driver actively parses whether the tail packet is complete. If the tail packet is complete, sends the WD_EAGAIN signal to info the user to empty the data. Signed-off-by: Chenghai Huang <huangchenghai2@huawei.com> Signed-off-by: Qi Tao <taoqi10@huawei.com> --- Makefile.am | 1 + drv/hisi_comp.c | 33 +++++- drv/hisi_comp_huf.c | 250 ++++++++++++++++++++++++++++++++++++++++++++ drv/hisi_comp_huf.h | 19 ++++ 4 files changed, 302 insertions(+), 1 deletion(-) create mode 100644 drv/hisi_comp_huf.c create mode 100644 drv/hisi_comp_huf.h diff --git a/Makefile.am b/Makefile.am index 9b36ae94..cb22770e 100644 --- a/Makefile.am +++ b/Makefile.am @@ -75,6 +75,7 @@ libwd_comp_la_SOURCES=wd_comp.c wd_comp.h wd_comp_drv.h wd_util.c wd_util.h \ wd_sched.c wd_sched.h wd.c wd.h wd_zlibwrapper.c libhisi_zip_la_SOURCES=drv/hisi_comp.c hisi_comp.h drv/hisi_qm_udrv.c \ + drv/hisi_comp_huf.c drv/hisi_comp_huf.h \ hisi_qm_udrv.h wd_comp_drv.h libwd_crypto_la_SOURCES=wd_cipher.c wd_cipher.h wd_cipher_drv.h \ diff --git a/drv/hisi_comp.c b/drv/hisi_comp.c index 64b9c62c..cd558a80 100644 --- a/drv/hisi_comp.c +++ b/drv/hisi_comp.c @@ -3,6 +3,7 @@ #include <asm/types.h> #include "drv/wd_comp_drv.h" +#include "drv/hisi_comp_huf.h" #include "hisi_qm_udrv.h" #define ZLIB 0 @@ -48,6 +49,7 @@ #define LITLEN_OVERFLOW_POS_MASK 0xffffff #define HZ_DECOMP_NO_SPACE 0x01 +#define HZ_DECOMP_BLK_NOSTART 0x03 #define HZ_NEGACOMPRESS 0x0d #define HZ_CRC_ERR 0x10 #define HZ_DECOMP_END 0x13 @@ -94,6 +96,12 @@ /* The 38KB offset in ctx_buf is used as the internal buffer */ #define CTX_STOREBUF_OFFSET 0x9800 +#define CTX_BLOCKST_OFFSET 0xc00 +#define CTX_WIN_LEN_MASK 0xffff +#define CTX_HEAD_BIT_CNT_SHIFT 0xa +#define CTX_HEAD_BIT_CNT_MASK 0xfC00 +#define WIN_LEN_ALIGN(len) ((len + 15) & ~(__u32)0x0F) + enum alg_type { HW_DEFLATE = 0x1, HW_ZLIB, @@ -1210,14 +1218,16 @@ static int parse_zip_sqe(struct hisi_qp *qp, struct hisi_zip_sqe *sqe, struct wd_comp_msg *msg) { __u32 buf_type = (sqe->dw9 & HZ_BUF_TYPE_MASK) >> BUF_TYPE_SHIFT; + __u32 ctx_win_len = sqe->ctx_dw2 & CTX_WIN_LEN_MASK; __u16 ctx_st = sqe->ctx_dw0 & HZ_CTX_ST_MASK; __u16 lstblk = sqe->dw3 & HZ_LSTBLK_MASK; __u32 status = sqe->dw3 & HZ_STATUS_MASK; __u32 type = sqe->dw9 & HZ_REQ_TYPE_MASK; struct wd_comp_msg *recv_msg = msg; bool need_debug = wd_need_debug(); + __u32 bit_cnt, tag; int alg_type, ret; - __u32 tag; + void *cache_data; alg_type = get_alg_type(type); if (unlikely(alg_type < 0)) { @@ -1262,6 +1272,27 @@ static int parse_zip_sqe(struct hisi_qp *qp, struct hisi_zip_sqe *sqe, if (ctx_st == HZ_DECOMP_NO_SPACE) recv_msg->req.status = WD_EAGAIN; + /* + * It need to analysis the data cache by hardware. + * If the cache data is a complete huffman block, + * the drv send WD_EAGAIN to user to continue + * sending a request for clearing the cache. + */ + bit_cnt = (sqe->ctx_dw0 & CTX_HEAD_BIT_CNT_MASK) >> CTX_HEAD_BIT_CNT_SHIFT; + if (!recv_msg->req.status && bit_cnt && ctx_st == HZ_DECOMP_BLK_NOSTART && + recv_msg->alg_type == WD_DEFLATE) { + /* ctx_win_len need to aligned with 16 */ + ctx_win_len = WIN_LEN_ALIGN(ctx_win_len); + cache_data = recv_msg->ctx_buf + RSV_OFFSET + CTX_BLOCKST_OFFSET + ctx_win_len; + ret = check_bfinal_complete_block(cache_data, bit_cnt); + if (ret < 0) { + WD_ERR("invalid: unable to parse data!\n"); + recv_msg->req.status = WD_IN_EPARA; + } else if (ret) { + recv_msg->req.status = WD_EAGAIN; + } + } + if (need_debug) WD_DEBUG("zip recv lst =%hu, ctx_st=0x%x, status=0x%x, alg=%u!\n", lstblk, ctx_st, status, type); diff --git a/drv/hisi_comp_huf.c b/drv/hisi_comp_huf.c new file mode 100644 index 00000000..b8347106 --- /dev/null +++ b/drv/hisi_comp_huf.c @@ -0,0 +1,250 @@ +// SPDX-License-Identifier: Apache-2.0 +/* Copyright 2025 Huawei Technologies Co.,Ltd. All rights reserved. */ + +#include <asm/types.h> + +#include "drv/hisi_comp_huf.h" +#include "wd_util.h" + +#define MAX_HW_TAIL_CACHE_LEN 0x28 +#define MIN_COMPLETE_STORE_LEN 0x20 +#define DEFLATE_BFINAL_LEN 1 +#define DEFLATE_BTYPE_LEN 2 +#define BYTE_ALIGN_MASK 7 +#define EMPTY_STORE_BLOCK_VAL 0xffff0000L +#define BLOCK_IS_COMPLETE 1 +#define BLOCK_IS_INCOMPLETE 0 +#define LEN_NLEN_CHECK(data) ((data & 0xffff) != ((data >> 16) ^ 0xffff)) + +/* Constants related to the Huffman code table */ +#define LIT_LEN_7BIT_THRESHOLD 7 +#define LIT_LEN_8BIT_THRESHOLD 8 +#define MAX_LIT_LEN_BITS 9 +#define DIST_CODE_BITS 5 +#define LEN_CODE_7BIT_MAX 0x17 +#define LEN_CODE_7BIT_OFFSET 0x100 +#define LIT_LEN_8BIT_LOW 0x30 +#define LIT_LEN_8BIT_HIGH 0xBF +#define LIT_CODE_8BIT_OFFSET 0x30 +#define LEN_CODE_8BIT_LOW 0xC0 +#define LEN_CODE_8BIT_HIGH 0xC7 +#define LEN_CODE_8BIT_BASE 0x118 +#define LIT_LEN_9BIT_LOW 0x190 +#define LIT_LEN_9BIT_HIGH 0x1FF +#define LIT_LEN_9BIT_BASE 0x90 +/* Special code value */ +#define END_OF_BLOCK_CODE 256 +#define MIN_LEN_CODE 257 +#define MAX_LEN_CODE 285 +#define MAX_DIST_CODE 29 + +enum huffman_block_type { + STORE_TYPE, + FIX_TYPE, + DYN_TYPE, +}; + +struct bit_reader { + __u64 data; + __u32 cur_pos; + __u32 total_bits; +}; + +struct huffman_code { + __u32 base; + __u32 bits; +}; + +static struct huffman_code len_tab[] = { + {3, 0}, {4, 0}, {5, 0}, {6, 0}, {7, 0}, {8, 0}, {9, 0}, {10, 0}, {11, 1}, + {13, 1}, {15, 2}, {19, 2}, {23, 3}, {27, 3}, {31, 4}, {35, 4}, {43, 5}, + {51, 5}, {59, 6}, {67, 6}, {83, 7}, {99, 7}, {115, 8}, {131, 8}, {163, 9}, + {195, 9}, {227, 10}, {258, 0} +}; + +static struct huffman_code dist_tab[] = { + {1, 0}, {2, 0}, {3, 0}, {4, 0}, {5, 1}, {7, 1}, {9, 2}, {13, 2}, {17, 3}, + {25, 3}, {33, 4}, {49, 4}, {65, 5}, {97, 5}, {129, 6}, {193, 6}, {257, 7}, + {385, 7}, {513, 8}, {769, 8}, {1025, 9}, {1537, 9}, {2049, 10}, {3073, 10}, + {4097, 11}, {6145, 11}, {8193, 12}, {12289, 12}, {16385, 13}, {24577, 13} +}; + +static long read_bits(struct bit_reader *br, __u32 n) +{ + long ret; + + if (br->cur_pos + n > br->total_bits) + return -WD_EINVAL; + + ret = (br->data >> br->cur_pos) & ((1L << n) - 1L); + br->cur_pos += n; + + return ret; +} + +static int check_store_huffman_block(struct bit_reader *br, __u32 bit_len) +{ + __u32 pad; + long data; + + /* In store mode, data whose length is less than 32 bits must be incomplete */ + if (bit_len < MIN_COMPLETE_STORE_LEN) + return BLOCK_IS_INCOMPLETE; + + /* go to a byte boundary */ + pad = bit_len & BYTE_ALIGN_MASK; + bit_len -= pad; + data = read_bits(br, pad); + if (data < 0) + return BLOCK_IS_INCOMPLETE; + + data = read_bits(br, bit_len); + if (data < 0) + return BLOCK_IS_INCOMPLETE; + + /* check len and nlen */ + if (LEN_NLEN_CHECK(data)) + return -WD_EINVAL; + + if (data == EMPTY_STORE_BLOCK_VAL) + return BLOCK_IS_COMPLETE; + + return BLOCK_IS_INCOMPLETE; +} + +static int check_fix_huffman_block(struct bit_reader *br, __u32 bit_len) +{ + long bit, len_idx, dist_code, extra; + long code, bits; + + while (br->cur_pos < bit_len) { + /* reads 7~9 bits to determine literal/length */ + code = 0; + bits = 0; + while (bits <= MAX_LIT_LEN_BITS) { + bit = read_bits(br, 1); + if (bit < 0) + return BLOCK_IS_INCOMPLETE; + + code = (code << 1) | bit; + bits++; + + /* + * Matching by bit in ascending order and convert code value to + * literal/length range value. The literal/length is determined + * based on the code value (256 indicates END_OF_BLOCK): + * Range Code Type Len + * 0-143 [0x30, 0xBF] literal 8bit + * 144-255 [0x190, 0x1ff] literal 9bit + * 256-279 [0x0, 0x17] length 7bit + * 280-287 [0xC0, 0xC7] length 8bit + */ + if (bits == LIT_LEN_7BIT_THRESHOLD && code <= LEN_CODE_7BIT_MAX) { + code += LEN_CODE_7BIT_OFFSET; + break; + } else if (bits == LIT_LEN_8BIT_THRESHOLD) { + if (code >= LIT_LEN_8BIT_LOW && code <= LIT_LEN_8BIT_HIGH) { + code -= LIT_CODE_8BIT_OFFSET; + break; + } else if (code >= LEN_CODE_8BIT_LOW && + code <= LEN_CODE_8BIT_HIGH) { + code = LEN_CODE_8BIT_BASE + (code - LEN_CODE_8BIT_LOW); + break; + } + } else if (bits == MAX_LIT_LEN_BITS && code >= LIT_LEN_9BIT_LOW && + code <= LIT_LEN_9BIT_HIGH) { + code = LIT_LEN_9BIT_BASE + (code - LIT_LEN_9BIT_LOW); + break; + } + } + + /* if the 9 bits cannot determin literal/length, an error occurs */ + if (bits > MAX_LIT_LEN_BITS) + return -WD_EINVAL; + + /* end of a block */ + if (code == END_OF_BLOCK_CODE) + return BLOCK_IS_COMPLETE; + + /* The literal encoding directly represents the byte content of the original data */ + if (code < END_OF_BLOCK_CODE) + continue; + + if (code > MAX_LEN_CODE) + return -WD_EINVAL; + + /* + * The length encoding needs to query the len_tab and dist_tab + * to determine the data length. + */ + len_idx = code - MIN_LEN_CODE; + extra = read_bits(br, len_tab[len_idx].bits); + if (extra < 0) + return BLOCK_IS_INCOMPLETE; + + /* read 5 bits to determine the distance value */ + dist_code = read_bits(br, DIST_CODE_BITS); + if (dist_code < 0) + return BLOCK_IS_INCOMPLETE; + else if (dist_code > MAX_DIST_CODE) + return -WD_EINVAL; + + extra = read_bits(br, dist_tab[dist_code].bits); + if (extra < 0) + return BLOCK_IS_INCOMPLETE; + } + + return BLOCK_IS_INCOMPLETE; +} + +int check_bfinal_complete_block(void *addr, __u32 bit_len) +{ + struct bit_reader br = {0}; + __u32 remain = bit_len; + long bfinal = 0; + long btype; + int ret; + + if (bit_len == 0 || bit_len >= MAX_HW_TAIL_CACHE_LEN) + return BLOCK_IS_INCOMPLETE; + + br.total_bits = bit_len; + br.data = *((__u64 *)addr); + remain = bit_len; + + while (!bfinal && br.cur_pos < bit_len) { + bfinal = read_bits(&br, DEFLATE_BFINAL_LEN); + btype = read_bits(&br, DEFLATE_BTYPE_LEN); + if (bfinal < 0 || btype < 0) + return BLOCK_IS_INCOMPLETE; + + if (btype > DYN_TYPE) + return -WD_EINVAL; + + remain = bit_len - br.cur_pos; + + /* + * Data in dynamic type must be incomplete when less than 5byte, + * the store type can have at most one complete block, + * the fix type needs to check the integrity of each block. + */ + if (btype == DYN_TYPE) { + return BLOCK_IS_INCOMPLETE; + } else if (btype == STORE_TYPE) { + return check_store_huffman_block(&br, remain); + } else if (btype == FIX_TYPE) { + ret = check_fix_huffman_block(&br, remain); + if (ret <= 0) + return ret; + } + } + + /* + * The data seem to be incomplete if bfinal is 0 when + * the analyzed data is judged to be complete. + */ + if (!bfinal) + return BLOCK_IS_INCOMPLETE; + + return BLOCK_IS_COMPLETE; +} diff --git a/drv/hisi_comp_huf.h b/drv/hisi_comp_huf.h new file mode 100644 index 00000000..6585b7a1 --- /dev/null +++ b/drv/hisi_comp_huf.h @@ -0,0 +1,19 @@ +/* SPDX-License-Identifier: Apache-2.0 */ +/* Copyright 2025 Huawei Technologies Co.,Ltd. All rights reserved. */ + +#ifndef __HISI_COMP_HUF_H +#define __HISI_COMP_HUF_H + +#include <asm/types.h> + +#ifdef __cplusplus +extern "C" { +#endif + +int check_bfinal_complete_block(void *addr, __u32 bit_len); + +#ifdef __cplusplus +} +#endif + +#endif /* __HISI_COMP_HUF_H */ -- 2.33.0

From: Chenghai Huang <huangchenghai2@huawei.com> The windowsize is incorrectly calculated. For example, when the user input -14 to configure a 16 KB window size, *windowsize should be WD_COMP_WS_16KB. Signed-off-by: Chenghai Huang <huangchenghai2@huawei.com> Signed-off-by: Qi Tao <taoqi10@huawei.com> --- wd_zlibwrapper.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/wd_zlibwrapper.c b/wd_zlibwrapper.c index 6effd6a4..4aa070c2 100644 --- a/wd_zlibwrapper.c +++ b/wd_zlibwrapper.c @@ -86,7 +86,7 @@ static int wd_zlib_analy_alg(int windowbits, int *alg, int *windowsize) static const int DEFLATE_MIN_WBITS = -15; static const int WBINS_ZLIB_4K = 12; static const int WBINS_GZIP_4K = 27; - static const int WBINS_DEFLATE_4K = -12; + static const int WBINS_DEFLATE_4K = 12; if ((windowbits >= ZLIB_MIN_WBITS) && (windowbits <= ZLIB_MAX_WBITS)) { *alg = WD_ZLIB; @@ -96,6 +96,7 @@ static int wd_zlib_analy_alg(int windowbits, int *alg, int *windowsize) *windowsize = max(windowbits - WBINS_GZIP_4K, WD_COMP_WS_4K); } else if ((windowbits >= DEFLATE_MIN_WBITS) && (windowbits <= DEFLATE_MAX_WBITS)) { *alg = WD_DEFLATE; + windowbits = -windowbits; *windowsize = max(windowbits - WBINS_DEFLATE_4K, WD_COMP_WS_4K); } else { return Z_STREAM_ERROR; -- 2.33.0

From: lizhi <lizhi206@huawei.com> Add algorithm driver as a function parameter. Do not enable high-performance core if hardware version is not met. Signed-off-by: lizhi <lizhi206@huawei.com> Signed-off-by: Qi Tao <taoqi10@huawei.com> --- drv/hisi_hpre.c | 27 +++++++++++++++++++++++---- include/drv/wd_ecc_drv.h | 9 +++++---- wd_ecc.c | 7 ++++--- 3 files changed, 32 insertions(+), 11 deletions(-) diff --git a/drv/hisi_hpre.c b/drv/hisi_hpre.c index e0cd7424..7ce842b8 100644 --- a/drv/hisi_hpre.c +++ b/drv/hisi_hpre.c @@ -2506,7 +2506,7 @@ static int hpre_get_usage(void *param) return WD_SUCCESS; } -static int ecc_sess_eops_init(void **params) +static int ecc_sess_eops_init(struct wd_alg_driver *drv, void **params) { struct hpre_ecc_ctx *ecc_ctx; @@ -2529,7 +2529,7 @@ static int ecc_sess_eops_init(void **params) return WD_SUCCESS; } -static void ecc_sess_eops_uninit(void *params) +static void ecc_sess_eops_uninit(struct wd_alg_driver *drv, void *params) { if (!params) { WD_ERR("invalid: extend ops uninit params is NULL!\n"); @@ -2539,13 +2539,32 @@ static void ecc_sess_eops_uninit(void *params) free(params); } -static void ecc_sess_eops_params_cfg(struct wd_ecc_sess_setup *setup, +static bool is_valid_hw_type(struct wd_alg_driver *drv) +{ + struct hisi_hpre_ctx *hpre_ctx; + struct hisi_qp *qp; + + if (unlikely(!drv || !drv->priv)) + return false; + + hpre_ctx = (struct hisi_hpre_ctx *)drv->priv; + qp = (struct hisi_qp *)wd_ctx_get_priv(hpre_ctx->config.ctxs[0].ctx); + if (qp->q_info.hw_type < HISI_QM_API_VER3_BASE) + return false; + return true; +} + +static void ecc_sess_eops_params_cfg(struct wd_alg_driver *drv, + struct wd_ecc_sess_setup *setup, struct wd_ecc_curve *cv, void *params) { __u8 data[SECP256R1_PARAM_SIZE] = SECG_P256_R1_PARAM; struct hpre_ecc_ctx *ecc_ctx = params; __u32 key_size; - int ret = 0; + int ret; + + if (!is_valid_hw_type(drv)) + return; if (!ecc_ctx) { WD_INFO("Info: eops config exits, but params is NULL!\n"); diff --git a/include/drv/wd_ecc_drv.h b/include/drv/wd_ecc_drv.h index 085bd4ae..6193c8be 100644 --- a/include/drv/wd_ecc_drv.h +++ b/include/drv/wd_ecc_drv.h @@ -178,10 +178,11 @@ struct wd_ecc_out { struct wd_ecc_extend_ops { void *params; /* the params are passed to the following ops */ - void (*eops_params_cfg)(struct wd_ecc_sess_setup *setup, - struct wd_ecc_curve *cv, void *params); - int (*sess_init)(void **params); - void (*sess_uninit)(void *params); + void (*eops_params_cfg)(struct wd_alg_driver *drv, + struct wd_ecc_sess_setup *setup, + struct wd_ecc_curve *cv, void *params); + int (*sess_init)(struct wd_alg_driver *drv, void **params); + void (*sess_uninit)(struct wd_alg_driver *drv, void *params); }; struct wd_ecc_msg *wd_ecc_get_msg(__u32 idx, __u32 tag); diff --git a/wd_ecc.c b/wd_ecc.c index 36e5206f..f47df652 100644 --- a/wd_ecc.c +++ b/wd_ecc.c @@ -1178,7 +1178,7 @@ static int wd_ecc_sess_eops_init(struct wd_ecc_sess *sess) WD_ERR("failed to get extend ops in session!\n"); return -WD_EINVAL; } - ret = sess->eops.sess_init(&sess->eops.params); + ret = sess->eops.sess_init(wd_ecc_setting.driver, &sess->eops.params); if (ret) { WD_ERR("failed to init extend ops params in session!\n"); return ret; @@ -1190,7 +1190,7 @@ static int wd_ecc_sess_eops_init(struct wd_ecc_sess *sess) static void wd_ecc_sess_eops_uninit(struct wd_ecc_sess *sess) { if (sess->eops.sess_uninit) { - sess->eops.sess_uninit(sess->eops.params); + sess->eops.sess_uninit(wd_ecc_setting.driver, sess->eops.params); sess->eops.params = NULL; } } @@ -1200,7 +1200,8 @@ static void wd_ecc_sess_eops_cfg(struct wd_ecc_sess_setup *setup, { if (sess->eops.sess_init && sess->eops.eops_params_cfg) { /* the config result does not impact task sucesss or failure */ - sess->eops.eops_params_cfg(setup, sess->key.cv, sess->eops.params); + sess->eops.eops_params_cfg(wd_ecc_setting.driver, setup, sess->key.cv, + sess->eops.params); } } -- 2.33.0

From: Zhushuai Yin <yinzhushuai@huawei.com> The MAX MIN function of hash agg and the function of combining buckets using rehash are added. Signed-off-by: Zhushuai Yin <yinzhushuai@huawei.com> Signed-off-by: Qi Tao <taoqi10@huawei.com> --- drv/hisi_dae.c | 234 +++++++++++++++++++++++++++++++++++---- drv/hisi_qm_udrv.h | 3 +- include/drv/wd_agg_drv.h | 10 +- include/wd_agg.h | 9 +- wd_agg.c | 12 +- 5 files changed, 229 insertions(+), 39 deletions(-) diff --git a/drv/hisi_dae.c b/drv/hisi_dae.c index ae91475b..37ae0019 100644 --- a/drv/hisi_dae.c +++ b/drv/hisi_dae.c @@ -18,8 +18,6 @@ #define DAE_CTX_Q_NUM_DEF 1 /* will remove in next version */ -#define DAE_HASHAGG_SUM 0x1 -#define DAE_HASHAGG_COUNT 0x2 #define DAE_HASH_COUNT_ALL 0x1 /* column information */ @@ -60,6 +58,9 @@ #define HASH_TABLE_OFFSET_3ROW 3 #define HASH_TABLE_OFFSET_1ROW 1 +/* hash agg operations col max num */ +#define DAE_AGG_COL_ALG_MAX_NUM 2 + #define __ALIGN_MASK(x, mask) (((x) + (mask)) & ~(mask)) #define ALIGN(x, a) __ALIGN_MASK(x, (typeof(x))(a)-1) #define PTR_ALIGN(p, a) ((typeof(p))ALIGN((uintptr_t)(p), (a))) @@ -73,10 +74,14 @@ enum dae_stage { DAE_HASH_AGGREGATE = 0x0, DAE_HASHAGG_OUTPUT = 0x7, + /* new platform rehash new operation */ + DAE_HASHAGG_MERGE = 0x6, }; enum dae_op_type { DAE_COUNT = 0x1, + DAE_MAX = 0x2, + DAE_MIN = 0x3, DAE_SUM = 0x5, }; @@ -127,6 +132,18 @@ enum dae_sum_optype { DECIMAL64_TO_DECIMAL128 = 0x3, }; +enum dae_alg_optype { + DAE_HASHAGG_SUM = 0x1, + DAE_HASHAGG_COUNT = 0x2, + DAE_HASHAGG_MAX = 0x4, + DAE_HASHAGG_MIN = 0x8, +}; + +enum dae_bd_type { + DAE_BD_TYPE_V1 = 0x0, + DAE_BD_TYPE_V2 = 0x1, +}; + struct dae_sqe { __u32 bd_type : 6; __u32 resv1 : 2; @@ -292,7 +309,7 @@ static void put_ext_addr(struct dae_extend_addr *ext_addr, int idx) __atomic_clear(&ext_addr->addr_status[idx], __ATOMIC_RELEASE); } -static void fill_hashagg_task_type(struct wd_agg_msg *msg, struct dae_sqe *sqe) +static void fill_hashagg_task_type(struct wd_agg_msg *msg, struct dae_sqe *sqe, __u16 hw_type) { /* * The variable 'pos' is enumeration type, and the case branches @@ -304,9 +321,14 @@ static void fill_hashagg_task_type(struct wd_agg_msg *msg, struct dae_sqe *sqe) sqe->task_type_ext = DAE_HASH_AGGREGATE; break; case WD_AGG_STREAM_OUTPUT: - case WD_AGG_REHASH_OUTPUT: sqe->task_type_ext = DAE_HASHAGG_OUTPUT; break; + case WD_AGG_REHASH_OUTPUT: + if (hw_type >= HISI_QM_API_VER5_BASE) + sqe->task_type_ext = DAE_HASHAGG_MERGE; + else + sqe->task_type_ext = DAE_HASHAGG_OUTPUT; + break; } } @@ -335,8 +357,27 @@ static void fill_hashagg_output_order(struct dae_sqe *sqe, struct dae_ext_sqe *e } } +static void fill_hashagg_merge_output_order(struct dae_sqe *sqe, struct dae_ext_sqe *ext_sqe, + struct wd_agg_msg *msg) +{ + struct hashagg_ctx *agg_ctx = msg->priv; + struct hashagg_col_data *cols_data = &agg_ctx->cols_data; + struct hashagg_output_src *output_src = cols_data->normal_output; + __u32 out_cols_num = cols_data->output_num; + __u32 offset = 0; + __u32 i; + + output_src = cols_data->rehash_output; + + for (i = 0; i < out_cols_num; i++) { + ext_sqe->out_from_in_idx |= (__u64)output_src[i].out_from_in_idx << offset; + ext_sqe->out_optype |= (__u64)output_src[i].out_optype << offset; + offset += DAE_COL_BIT_NUM; + } +} + static void fill_hashagg_table_data(struct dae_sqe *sqe, struct dae_addr_list *addr_list, - struct wd_agg_msg *msg) + struct wd_agg_msg *msg) { struct hashagg_ctx *agg_ctx = (struct hashagg_ctx *)msg->priv; struct hash_table_data *table_data = &agg_ctx->table_data; @@ -370,6 +411,31 @@ static void fill_hashagg_table_data(struct dae_sqe *sqe, struct dae_addr_list *a hw_table->ext_table_size = table_data->ext_table_size; } +static void fill_hashagg_merge_table_data(struct dae_sqe *sqe, + struct dae_addr_list *addr_list, + struct wd_agg_msg *msg) +{ + struct hashagg_ctx *agg_ctx = (struct hashagg_ctx *)msg->priv; + struct hash_table_data *table_data_src = &agg_ctx->rehash_table; + struct hash_table_data *table_data_dst = &agg_ctx->table_data; + struct dae_table_addr *hw_table_src = &addr_list->src_table; + struct dae_table_addr *hw_table_dst = &addr_list->dst_table; + + sqe->table_row_size = agg_ctx->row_size; + sqe->src_table_width = table_data_src->table_width; + sqe->dst_table_width = table_data_dst->table_width; + + hw_table_dst->std_table_addr = (__u64)(uintptr_t)table_data_dst->std_table; + hw_table_dst->std_table_size = table_data_dst->std_table_size; + hw_table_dst->ext_table_addr = (__u64)(uintptr_t)table_data_dst->ext_table; + hw_table_dst->ext_table_size = table_data_dst->ext_table_size; + + hw_table_src->std_table_addr = (__u64)(uintptr_t)table_data_src->std_table; + hw_table_src->std_table_size = table_data_src->std_table_size; + hw_table_src->ext_table_addr = (__u64)(uintptr_t)table_data_src->ext_table; + hw_table_src->ext_table_size = table_data_src->ext_table_size; +} + static void fill_hashagg_key_data(struct dae_sqe *sqe, struct dae_ext_sqe *ext_sqe, struct dae_addr_list *addr_list, struct wd_agg_msg *msg) { @@ -415,6 +481,21 @@ static void fill_hashagg_key_data(struct dae_sqe *sqe, struct dae_ext_sqe *ext_s } } } +static void fill_hashagg_merge_key_data(struct dae_sqe *sqe, struct dae_ext_sqe *ext_sqe, + struct dae_addr_list *addr_list, struct wd_agg_msg *msg) +{ + struct hashagg_ctx *agg_ctx = msg->priv; + struct hw_agg_data *key_data = agg_ctx->cols_data.key_data; + __u32 j = DAE_MAX_ADDR_NUM - 1; + __u32 i; + + sqe->key_col_bitmap = GENMASK(msg->key_cols_num - 1, 0); + + for (i = 0; i < msg->key_cols_num; i++) { + sqe->key_data_type[i] = key_data[i].hw_type; + ext_sqe->key_data_info[i] = key_data[i].data_info; + } +} static void fill_hashagg_normal_info(struct dae_sqe *sqe, struct dae_ext_sqe *ext_sqe, struct hashagg_col_data *cols_data, __u32 agg_cols_num) @@ -501,6 +582,15 @@ static void fill_hashagg_input_data(struct dae_sqe *sqe, struct dae_ext_sqe *ext } } +static void fill_hashagg_merge_input_data(struct dae_sqe *sqe, struct dae_ext_sqe *ext_sqe, + struct dae_addr_list *addr_list, struct wd_agg_msg *msg) +{ + struct hashagg_ctx *agg_ctx = msg->priv; + struct hashagg_col_data *cols_data = &agg_ctx->cols_data; + + fill_hashagg_rehash_info(sqe, ext_sqe, cols_data->output_data, msg->agg_cols_num); +} + static void fill_hashagg_ext_addr(struct dae_sqe *sqe, struct dae_ext_sqe *ext_sqe, struct dae_addr_list *addr_list) { @@ -511,6 +601,28 @@ static void fill_hashagg_ext_addr(struct dae_sqe *sqe, struct dae_ext_sqe *ext_s addr_list->ext_sqe_size = DAE_EXT_SQE_SIZE; } +static void fill_hashagg_info(struct dae_sqe *sqe, struct dae_ext_sqe *ext_sqe, + struct dae_addr_list *addr_list, struct wd_agg_msg *msg, + __u16 hw_type) +{ + fill_hashagg_ext_addr(sqe, ext_sqe, addr_list); + + if (hw_type >= HISI_QM_API_VER5_BASE) + sqe->bd_type = DAE_BD_TYPE_V2; + + if (sqe->task_type_ext == DAE_HASHAGG_MERGE) { + fill_hashagg_merge_table_data(sqe, addr_list, msg); + fill_hashagg_merge_key_data(sqe, ext_sqe, addr_list, msg); + fill_hashagg_merge_input_data(sqe, ext_sqe, addr_list, msg); + fill_hashagg_merge_output_order(sqe, ext_sqe, msg); + } else { + fill_hashagg_table_data(sqe, addr_list, msg); + fill_hashagg_key_data(sqe, ext_sqe, addr_list, msg); + fill_hashagg_input_data(sqe, ext_sqe, addr_list, msg); + fill_hashagg_output_order(sqe, ext_sqe, msg); + } +} + static int check_hashagg_param(struct wd_agg_msg *msg) { if (!msg) { @@ -544,7 +656,11 @@ static int hashagg_send(struct wd_alg_driver *drv, handle_t ctx, void *hashagg_m if (ret) return ret; - fill_hashagg_task_type(msg, &sqe); + if (qp->q_info.hw_type >= HISI_QM_API_VER5_BASE && + qp->q_info.qp_mode == CTX_MODE_SYNC && msg->pos == WD_AGG_REHASH_INPUT) + return WD_SUCCESS; + + fill_hashagg_task_type(msg, &sqe, qp->q_info.hw_type); sqe.row_num = msg->row_count; idx = get_free_ext_addr(ext_addr); @@ -553,11 +669,7 @@ static int hashagg_send(struct wd_alg_driver *drv, handle_t ctx, void *hashagg_m addr_list = &ext_addr->addr_list[idx]; ext_sqe = &ext_addr->ext_sqe[idx]; - fill_hashagg_ext_addr(&sqe, ext_sqe, addr_list); - fill_hashagg_table_data(&sqe, addr_list, msg); - fill_hashagg_key_data(&sqe, ext_sqe, addr_list, msg); - fill_hashagg_input_data(&sqe, ext_sqe, addr_list, msg); - fill_hashagg_output_order(&sqe, ext_sqe, msg); + fill_hashagg_info(&sqe, ext_sqe, addr_list, msg, qp->q_info.hw_type); hisi_set_msg_id(h_qp, &msg->tag); sqe.low_tag = msg->tag; @@ -611,6 +723,9 @@ static void fill_hashagg_msg_task_done(struct dae_sqe *sqe, struct wd_agg_msg *m if (sqe->task_type_ext == DAE_HASHAGG_OUTPUT) { msg->out_row_count = sqe->out_raw_num; msg->output_done = sqe->output_end; + } else if (sqe->task_type_ext == DAE_HASHAGG_MERGE) { + msg->out_row_count = temp_msg->row_count; + msg->output_done = sqe->output_end; } else { msg->in_row_count = temp_msg->row_count; } @@ -673,6 +788,12 @@ static int hashagg_recv(struct wd_alg_driver *drv, handle_t ctx, void *hashagg_m __u16 recv_cnt = 0; int ret; + if (qp->q_info.hw_type >= HISI_QM_API_VER5_BASE && + qp->q_info.qp_mode == CTX_MODE_SYNC && msg->pos == WD_AGG_REHASH_INPUT) { + msg->result = WD_AGG_TASK_DONE; + return WD_SUCCESS; + } + ret = hisi_qm_recv(h_qp, &sqe, 1, &recv_cnt); if (ret) return ret; @@ -768,7 +889,8 @@ static int agg_get_output_num(enum wd_dae_data_type type, return WD_SUCCESS; } -static int agg_output_num_check(struct wd_agg_col_info *agg_cols, __u32 cols_num, bool is_count_all) +static int agg_output_num_check(struct wd_agg_col_info *agg_cols, __u32 cols_num, + bool is_count_all, __u16 hw_type) { __u32 size8 = 0, size16 = 0; __u32 i, j, count_num; @@ -786,11 +908,13 @@ static int agg_output_num_check(struct wd_agg_col_info *agg_cols, __u32 cols_num if (is_count_all) size8++; - if (size8 > DAE_MAX_8B_COLS_NUM || size16 > DAE_MAX_16B_COLS_NUM) { + if (hw_type < HISI_QM_API_VER5_BASE && + (size8 > DAE_MAX_8B_COLS_NUM || size16 > DAE_MAX_16B_COLS_NUM)) { WD_ERR("invalid: output col num 8B-16B %u-%u is more than support %d-%d !\n", size8, size16, DAE_MAX_8B_COLS_NUM, DAE_MAX_16B_COLS_NUM); return -WD_EINVAL; } + count_num = size8 + size16; if (count_num > DAE_MAX_OUTPUT_COLS) { WD_ERR("invalid: agg output cols num %u is more than device support %d!\n", @@ -801,7 +925,7 @@ static int agg_output_num_check(struct wd_agg_col_info *agg_cols, __u32 cols_num return WD_SUCCESS; } -static int hashagg_init_param_check(struct wd_agg_sess_setup *setup) +static int hashagg_init_param_check(struct wd_agg_sess_setup *setup, __u16 hw_type) { int ret; @@ -827,7 +951,8 @@ static int hashagg_init_param_check(struct wd_agg_sess_setup *setup) if (ret) return -WD_EINVAL; - return agg_output_num_check(setup->agg_cols_info, setup->agg_cols_num, setup->is_count_all); + return agg_output_num_check(setup->agg_cols_info, setup->agg_cols_num, + setup->is_count_all, hw_type); } static __u32 hashagg_get_data_type_size(enum dae_data_type type, __u16 data_info) @@ -1027,9 +1152,35 @@ static int hashagg_check_count_info(enum wd_dae_data_type input_type, return WD_SUCCESS; } +static int hashagg_check_max_min_info(struct wd_agg_col_info *agg_col, + struct hw_agg_data *user_input_data, + struct hw_agg_data *user_output_data) +{ + switch (agg_col->input_data_type) { + case WD_DAE_LONG: + user_input_data->hw_type = DAE_SINT64; + user_output_data->hw_type = DAE_SINT64; + break; + case WD_DAE_SHORT_DECIMAL: + user_input_data->hw_type = DAE_DECIMAL64; + user_output_data->hw_type = DAE_DECIMAL64; + break; + case WD_DAE_LONG_DECIMAL: + user_input_data->hw_type = DAE_DECIMAL128; + user_output_data->hw_type = DAE_DECIMAL128; + break; + default: + WD_ERR("invalid: device not support col data type %u do max or min!\n", + agg_col->input_data_type); + return -WD_EINVAL; + } + + return WD_SUCCESS; +} + static int hashagg_check_input_data(struct wd_agg_col_info *agg_col, - struct hw_agg_data *user_input_data, - struct hw_agg_data *user_output_data, __u32 index) + struct hw_agg_data *user_input_data, + struct hw_agg_data *user_output_data, __u32 index) { int ret; @@ -1050,6 +1201,20 @@ static int hashagg_check_input_data(struct wd_agg_col_info *agg_col, user_output_data->hw_type = DAE_SINT64; user_output_data->optype = DAE_COUNT; break; + case WD_AGG_MAX: + ret = hashagg_check_max_min_info(agg_col, user_input_data, user_output_data); + if (ret) + return ret; + user_input_data->optype |= DAE_HASHAGG_MAX; + user_output_data->optype = DAE_MAX; + break; + case WD_AGG_MIN: + ret = hashagg_check_max_min_info(agg_col, user_input_data, user_output_data); + if (ret) + return ret; + user_input_data->optype |= DAE_HASHAGG_MIN; + user_output_data->optype = DAE_MIN; + break; default: WD_ERR("invalid: device not support alg %u!\n", agg_col->output_col_algs[index]); return -WD_EINVAL; @@ -1068,6 +1233,11 @@ static int transfer_input_col_info(struct wd_agg_col_info *agg_cols, int ret; for (i = 0; i < cols_num; i++) { + if (agg_cols[i].col_alg_num > DAE_AGG_COL_ALG_MAX_NUM) { + WD_ERR("invalid: col alg num(%u) more than 2!\n", agg_cols[i].col_alg_num); + return -WD_EINVAL; + } + for (j = 0; j < agg_cols[i].col_alg_num; j++) { ret = hashagg_check_input_data(&agg_cols[i], &user_input_data[i], &user_output_data[k], j); @@ -1102,8 +1272,8 @@ static void hashagg_swap_out_index(struct hw_agg_data *user_output_data, } static void transfer_input_to_hw_order(struct hashagg_col_data *cols_data, - struct hw_agg_data *user_input_data, - struct hw_agg_data *user_output_data) + struct hw_agg_data *user_input_data, + struct hw_agg_data *user_output_data) { struct hw_agg_data *input_data = cols_data->input_data; __u32 type_num = ARRAY_SIZE(hw_data_type_order); @@ -1266,7 +1436,7 @@ static int hashagg_fill_agg_ctx(struct hashagg_ctx *agg_ctx, struct wd_agg_sess_ return WD_SUCCESS; } -static void hashagg_sess_priv_uninit(void *priv) +static void hashagg_sess_priv_uninit(struct wd_alg_driver *drv, void *priv) { struct hashagg_ctx *agg_ctx = priv; @@ -1279,17 +1449,32 @@ static void hashagg_sess_priv_uninit(void *priv) free(agg_ctx); } -static int hashagg_sess_priv_init(struct wd_agg_sess_setup *setup, void **priv) +static int hashagg_sess_priv_init(struct wd_alg_driver *drv, + struct wd_agg_sess_setup *setup, void **priv) { + struct wd_ctx_config_internal *config; + struct hisi_dae_ctx *dae_priv; struct hashagg_ctx *agg_ctx; + struct hisi_qp *qp; + handle_t h_qp; int ret; + if (!drv || !drv->priv) { + WD_ERR("invalid: dae drv is NULL!\n"); + return -WD_EINVAL; + } + if (!setup || !priv) { WD_ERR("invalid: dae sess priv is NULL!\n"); return -WD_EINVAL; } - ret = hashagg_init_param_check(setup); + dae_priv = (struct hisi_dae_ctx *)drv->priv; + config = &dae_priv->config; + h_qp = (handle_t)wd_ctx_get_priv(config->ctxs[0].ctx); + qp = (struct hisi_qp *)h_qp; + + ret = hashagg_init_param_check(setup, qp->q_info.hw_type); if (ret) return -WD_EINVAL; @@ -1365,7 +1550,7 @@ free_ext_addr: return ret; } -static int dae_get_row_size(void *param) +static int dae_get_row_size(struct wd_alg_driver *drv, void *param) { struct hashagg_ctx *agg_ctx = param; @@ -1514,7 +1699,8 @@ static int dae_std_table_init(struct hash_table_data *hw_table, return WD_SUCCESS; } -static int dae_hash_table_init(struct wd_dae_hash_table *hash_table, void *priv) +static int dae_hash_table_init(struct wd_alg_driver *drv, + struct wd_dae_hash_table *hash_table, void *priv) { struct hashagg_ctx *agg_ctx = priv; struct hash_table_data *hw_table; diff --git a/drv/hisi_qm_udrv.h b/drv/hisi_qm_udrv.h index b02e8e7f..e7871932 100644 --- a/drv/hisi_qm_udrv.h +++ b/drv/hisi_qm_udrv.h @@ -41,7 +41,8 @@ enum hisi_qm_sgl_copy_dir { enum hisi_hw_type { HISI_QM_API_VER_BASE = 1, HISI_QM_API_VER2_BASE, - HISI_QM_API_VER3_BASE + HISI_QM_API_VER3_BASE, + HISI_QM_API_VER5_BASE = 5, }; struct hisi_qm_priv { diff --git a/include/drv/wd_agg_drv.h b/include/drv/wd_agg_drv.h index 3d26eeb3..978c2d34 100644 --- a/include/drv/wd_agg_drv.h +++ b/include/drv/wd_agg_drv.h @@ -42,10 +42,12 @@ struct wd_agg_msg { }; struct wd_agg_ops { - int (*get_row_size)(void *priv); - int (*sess_init)(struct wd_agg_sess_setup *setup, void **priv); - void (*sess_uninit)(void *priv); - int (*hash_table_init)(struct wd_dae_hash_table *hash_table, void *priv); + int (*get_row_size)(struct wd_alg_driver *drv, void *priv); + int (*sess_init)(struct wd_alg_driver *drv, + struct wd_agg_sess_setup *setup, void **priv); + void (*sess_uninit)(struct wd_alg_driver *drv, void *priv); + int (*hash_table_init)(struct wd_alg_driver *drv, + struct wd_dae_hash_table *hash_table, void *priv); }; struct wd_agg_msg *wd_agg_get_msg(__u32 idx, __u32 tag); diff --git a/include/wd_agg.h b/include/wd_agg.h index aac3d406..fed08c50 100644 --- a/include/wd_agg.h +++ b/include/wd_agg.h @@ -20,6 +20,8 @@ extern "C" { enum wd_agg_alg { WD_AGG_SUM, WD_AGG_COUNT, + WD_AGG_MAX, + WD_AGG_MIN, WD_AGG_ALG_TYPE_MAX, }; @@ -141,10 +143,9 @@ struct wd_agg_req { }; /** - * wd_agg_init() - A simplify interface to initializate uadk - * encryption and decryption. This interface keeps most functions of - * wd_agg_init(). Users just need to descripe the deployment of - * business scenarios. Then the initialization will request appropriate + * wd_agg_init() - A simplify interface to initializate uadk hash agg. + * Users just need to descripe the deployment of business scenarios. + * Then the initialization will request appropriate * resources to support the business scenarios. * To make the initializate simpler, ctx_params support set NULL. * And then the function will set them as driver's default. diff --git a/wd_agg.c b/wd_agg.c index 33fa0f82..152f1a6e 100644 --- a/wd_agg.c +++ b/wd_agg.c @@ -361,7 +361,7 @@ static int wd_agg_init_sess_priv(struct wd_agg_sess *sess, struct wd_agg_sess_se WD_ERR("failed to get session uninit ops!\n"); return -WD_EINVAL; } - ret = sess->ops.sess_init(setup, &sess->priv); + ret = sess->ops.sess_init(wd_agg_setting.driver, setup, &sess->priv); if (ret) { WD_ERR("failed to init session priv!\n"); return ret; @@ -369,10 +369,10 @@ static int wd_agg_init_sess_priv(struct wd_agg_sess *sess, struct wd_agg_sess_se } if (sess->ops.get_row_size) { - ret = sess->ops.get_row_size(sess->priv); + ret = sess->ops.get_row_size(wd_agg_setting.driver, sess->priv); if (ret <= 0) { if (sess->ops.sess_uninit) - sess->ops.sess_uninit(sess->priv); + sess->ops.sess_uninit(wd_agg_setting.driver, sess->priv); WD_ERR("failed to get hash table row size: %d!\n", ret); return ret; } @@ -435,7 +435,7 @@ handle_t wd_agg_alloc_sess(struct wd_agg_sess_setup *setup) uninit_priv: if (sess->ops.sess_uninit) - sess->ops.sess_uninit(sess->priv); + sess->ops.sess_uninit(wd_agg_setting.driver, sess->priv); err_sess: if (sess->sched_key) free(sess->sched_key); @@ -457,7 +457,7 @@ void wd_agg_free_sess(handle_t h_sess) free(sess->key_conf.data_size); if (sess->ops.sess_uninit) - sess->ops.sess_uninit(sess->priv); + sess->ops.sess_uninit(wd_agg_setting.driver, sess->priv); if (sess->sched_key) free(sess->sched_key); @@ -550,7 +550,7 @@ int wd_agg_set_hash_table(handle_t h_sess, struct wd_dae_hash_table *info) memcpy(hash_table, info, sizeof(struct wd_dae_hash_table)); if (sess->ops.hash_table_init) { - ret = sess->ops.hash_table_init(hash_table, sess->priv); + ret = sess->ops.hash_table_init(wd_agg_setting.driver, hash_table, sess->priv); if (ret) { memcpy(hash_table, rehash_table, sizeof(struct wd_dae_hash_table)); memset(rehash_table, 0, sizeof(struct wd_dae_hash_table)); -- 2.33.0

1. Fix memory leak problem; 2. Modify the incorrect return value of the function. 3. Correct the incorrect memory release. Signed-off-by: Qi Tao <taoqi10@huawei.com> --- include/wd_util.h | 2 +- wd.c | 4 ++-- wd_aead.c | 5 ++--- wd_agg.c | 18 +++++++++--------- wd_cipher.c | 12 +++++------- wd_comp.c | 4 ++-- wd_dh.c | 2 +- wd_digest.c | 4 +--- wd_ecc.c | 2 +- wd_rsa.c | 2 +- wd_util.c | 6 ++++-- 11 files changed, 29 insertions(+), 32 deletions(-) diff --git a/include/wd_util.h b/include/wd_util.h index 1040f19b..9e9d4e35 100644 --- a/include/wd_util.h +++ b/include/wd_util.h @@ -124,7 +124,7 @@ struct wd_msg_handle { struct wd_init_attrs { __u32 sched_type; - const char *alg; + char alg[CRYPTO_MAX_ALG_NAME]; struct wd_alg_driver *driver; struct wd_sched *sched; struct wd_ctx_params *ctx_params; diff --git a/wd.c b/wd.c index 2f8bbbe0..75a94695 100644 --- a/wd.c +++ b/wd.c @@ -955,8 +955,8 @@ struct wd_capability *wd_get_alg_cap(void) goto alloc_err; } - strcpy(cap_node->alg_name, pnext->alg_name); - strcpy(cap_node->drv_name, pnext->drv_name); + (void)strcpy(cap_node->alg_name, pnext->alg_name); + (void)strcpy(cap_node->drv_name, pnext->drv_name); cap_node->available = pnext->available; cap_node->priority = pnext->priority; cap_node->calc_type = pnext->calc_type; diff --git a/wd_aead.c b/wd_aead.c index 2715e910..fddf5f18 100644 --- a/wd_aead.c +++ b/wd_aead.c @@ -344,9 +344,8 @@ handle_t wd_aead_alloc_sess(struct wd_aead_sess_setup *setup) } return (handle_t)sess; + err_sess: - if (sess->sched_key) - free(sess->sched_key); free(sess); return (handle_t)0; } @@ -604,7 +603,7 @@ int wd_aead_init2_(char *alg, __u32 sched_type, int task_type, goto out_driver; } - wd_aead_init_attrs.alg = alg; + (void)strcpy(wd_aead_init_attrs.alg, alg); wd_aead_init_attrs.sched_type = sched_type; wd_aead_init_attrs.driver = wd_aead_setting.driver; wd_aead_init_attrs.ctx_params = &aead_ctx_params; diff --git a/wd_agg.c b/wd_agg.c index 152f1a6e..ba2cb86a 100644 --- a/wd_agg.c +++ b/wd_agg.c @@ -374,7 +374,7 @@ static int wd_agg_init_sess_priv(struct wd_agg_sess *sess, struct wd_agg_sess_se if (sess->ops.sess_uninit) sess->ops.sess_uninit(wd_agg_setting.driver, sess->priv); WD_ERR("failed to get hash table row size: %d!\n", ret); - return ret; + return -WD_EINVAL; } sess->hash_table.table_row_size = ret; } @@ -404,7 +404,7 @@ handle_t wd_agg_alloc_sess(struct wd_agg_sess_setup *setup) ret = wd_drv_alg_support(sess->alg_name, wd_agg_setting.driver); if (!ret) { WD_ERR("failed to support agg algorithm: %s!\n", sess->alg_name); - goto err_sess; + goto free_sess; } /* Some simple scheduler don't need scheduling parameters */ @@ -412,18 +412,18 @@ handle_t wd_agg_alloc_sess(struct wd_agg_sess_setup *setup) wd_agg_setting.sched.h_sched_ctx, setup->sched_param); if (WD_IS_ERR(sess->sched_key)) { WD_ERR("failed to init agg session schedule key!\n"); - goto err_sess; + goto free_sess; } ret = wd_agg_setting.driver->get_extend_ops(&sess->ops); if (ret) { WD_ERR("failed to get agg extend ops!\n"); - goto err_sess; + goto free_key; } ret = wd_agg_init_sess_priv(sess, setup); if (ret) - goto err_sess; + goto free_key; ret = fill_agg_session(sess, setup); if (ret) { @@ -436,9 +436,9 @@ handle_t wd_agg_alloc_sess(struct wd_agg_sess_setup *setup) uninit_priv: if (sess->ops.sess_uninit) sess->ops.sess_uninit(wd_agg_setting.driver, sess->priv); -err_sess: - if (sess->sched_key) - free(sess->sched_key); +free_key: + free(sess->sched_key); +free_sess: free(sess); return (handle_t)0; } @@ -678,7 +678,7 @@ int wd_agg_init(char *alg, __u32 sched_type, int task_type, struct wd_ctx_params goto out_driver; } - wd_agg_init_attrs.alg = alg; + (void)strcpy(wd_agg_init_attrs.alg, alg); wd_agg_init_attrs.sched_type = sched_type; wd_agg_init_attrs.driver = wd_agg_setting.driver; wd_agg_init_attrs.ctx_params = &agg_ctx_params; diff --git a/wd_cipher.c b/wd_cipher.c index 59992170..86a9dcc9 100644 --- a/wd_cipher.c +++ b/wd_cipher.c @@ -270,14 +270,14 @@ handle_t wd_cipher_alloc_sess(struct wd_cipher_sess_setup *setup) if (setup->alg >= WD_CIPHER_ALG_TYPE_MAX || setup->mode >= WD_CIPHER_MODE_TYPE_MAX) { WD_ERR("failed to check algorithm!\n"); - goto err_sess; + goto free_sess; } sess->alg_name = wd_cipher_alg_name[setup->alg][setup->mode]; ret = wd_drv_alg_support(sess->alg_name, wd_cipher_setting.driver); if (!ret) { WD_ERR("failed to support this algorithm: %s!\n", sess->alg_name); - goto err_sess; + goto free_sess; } sess->alg = setup->alg; sess->mode = setup->mode; @@ -287,14 +287,12 @@ handle_t wd_cipher_alloc_sess(struct wd_cipher_sess_setup *setup) wd_cipher_setting.sched.h_sched_ctx, setup->sched_param); if (WD_IS_ERR(sess->sched_key)) { WD_ERR("failed to init session schedule key!\n"); - goto err_sess; + goto free_sess; } return (handle_t)sess; -err_sess: - if (sess->sched_key) - free(sess->sched_key); +free_sess: free(sess); return (handle_t)0; } @@ -478,7 +476,7 @@ int wd_cipher_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_p goto out_driver; } - wd_cipher_init_attrs.alg = alg; + (void)strcpy(wd_cipher_init_attrs.alg, alg); wd_cipher_init_attrs.sched_type = sched_type; wd_cipher_init_attrs.driver = wd_cipher_setting.driver; wd_cipher_init_attrs.ctx_params = &cipher_ctx_params; diff --git a/wd_comp.c b/wd_comp.c index ca8faa39..6a746316 100644 --- a/wd_comp.c +++ b/wd_comp.c @@ -297,7 +297,7 @@ int wd_comp_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_par goto out_unbind_drv; } - wd_comp_init_attrs.alg = alg; + (void)strcpy(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; @@ -537,7 +537,7 @@ static int wd_comp_check_buffer(struct wd_comp_req *req) } if (!req->dst_len) { - WD_ERR("invalid: dst_len is NULL!\n"); + WD_ERR("invalid: dst_len is 0!\n"); return -WD_EINVAL; } diff --git a/wd_dh.c b/wd_dh.c index 3e02f2a1..8fa4f4b6 100644 --- a/wd_dh.c +++ b/wd_dh.c @@ -269,7 +269,7 @@ int wd_dh_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_param goto out_driver; } - wd_dh_init_attrs.alg = alg; + (void)strcpy(wd_dh_init_attrs.alg, alg); wd_dh_init_attrs.sched_type = sched_type; wd_dh_init_attrs.driver = wd_dh_setting.driver; wd_dh_init_attrs.ctx_params = &dh_ctx_params; diff --git a/wd_digest.c b/wd_digest.c index 1851203c..a709147a 100644 --- a/wd_digest.c +++ b/wd_digest.c @@ -225,8 +225,6 @@ handle_t wd_digest_alloc_sess(struct wd_digest_sess_setup *setup) return (handle_t)sess; err_sess: - if (sess->sched_key) - free(sess->sched_key); free(sess); return (handle_t)0; } @@ -414,7 +412,7 @@ int wd_digest_init2_(char *alg, __u32 sched_type, int task_type, goto out_driver; } - wd_digest_init_attrs.alg = alg; + (void)strcpy(wd_digest_init_attrs.alg, alg); wd_digest_init_attrs.sched_type = sched_type; wd_digest_init_attrs.driver = wd_digest_setting.driver; wd_digest_init_attrs.ctx_params = &digest_ctx_params; diff --git a/wd_ecc.c b/wd_ecc.c index f47df652..f3b734ce 100644 --- a/wd_ecc.c +++ b/wd_ecc.c @@ -337,7 +337,7 @@ int wd_ecc_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_para goto out_driver; } - wd_ecc_init_attrs.alg = alg; + (void)strcpy(wd_ecc_init_attrs.alg, alg); wd_ecc_init_attrs.sched_type = sched_type; wd_ecc_init_attrs.driver = wd_ecc_setting.driver; wd_ecc_init_attrs.ctx_params = &ecc_ctx_params; diff --git a/wd_rsa.c b/wd_rsa.c index caac7e60..8ac206a1 100644 --- a/wd_rsa.c +++ b/wd_rsa.c @@ -309,7 +309,7 @@ int wd_rsa_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_para goto out_driver; } - wd_rsa_init_attrs.alg = alg; + (void)strcpy(wd_rsa_init_attrs.alg, alg); wd_rsa_init_attrs.sched_type = sched_type; wd_rsa_init_attrs.driver = wd_rsa_setting.driver; wd_rsa_init_attrs.ctx_params = &rsa_ctx_params; diff --git a/wd_util.c b/wd_util.c index ac6c3e44..f1b27bf8 100644 --- a/wd_util.c +++ b/wd_util.c @@ -1166,8 +1166,10 @@ static int wd_get_wd_ctx(struct wd_env_config_per_numa *config, ctx_config->ctxs[i].ctx = h_ctx; ctx_config->ctxs[i].ctx_mode = get_ctx_mode(config, i); ret = get_op_type(config, i, ctx_config->ctxs[i].ctx_mode); - if (ret < 0) + if (ret < 0) { + wd_release_ctx(ctx_config->ctxs[i].ctx); goto free_ctx; + } ctx_config->ctxs[i].op_type = ret; } @@ -2810,7 +2812,7 @@ int wd_alg_attrs_init(struct wd_init_attrs *attrs) break; case UADK_ALG_HW: wd_get_alg_type(alg, alg_type); - attrs->alg = alg_type; + (void)strcpy(attrs->alg, alg_type); ctx_config = calloc(1, sizeof(*ctx_config)); if (!ctx_config) { -- 2.33.0

From: Longfang Liu <liulongfang@huawei.com> After removing the shared queue memory allocation interface, the UADK test tools must also eliminate the shared memory functionality. For individual memory reservations, the wd_reserve_memory interface should be used. When allocating memory for multiple queues, each queue should independently request its own reserved memory allocation. Signed-off-by: Longfang Liu <liulongfang@huawei.com> Signed-off-by: Qi Tao <taoqi10@huawei.com> --- v1/test/hisi_hpre_test/hpre_test_tools.c | 392 ----------------------- v1/test/hisi_zip_test_sgl/wd_sched_sgl.c | 310 +++++++++--------- v1/test/test_mm/test_wd_mem.c | 8 +- v1/test/wd_sched.c | 247 +++++++------- 4 files changed, 300 insertions(+), 657 deletions(-) diff --git a/v1/test/hisi_hpre_test/hpre_test_tools.c b/v1/test/hisi_hpre_test/hpre_test_tools.c index 7f562f34..10a4ade9 100755 --- a/v1/test/hisi_hpre_test/hpre_test_tools.c +++ b/v1/test/hisi_hpre_test/hpre_test_tools.c @@ -644,317 +644,6 @@ int application_release_multiple_queue(char *dev, char *alg_type, unsigned int q printf("application_release_multiple_queue test end!\n"); return 0; } - -/*** - -***/ -int hpre_dev_queue_share(char *dev, char * share_dev, char *alg_type, unsigned long m_size) -{ - void *addr=NULL; - int ret = 0; - struct wd_queue q; - struct wd_queue target_q; - unsigned long memory_size; - - memset((void *)&q, 0, sizeof(q)); - q.capa.alg = alg_type; - snprintf(q.dev_path, sizeof(q.dev_path), "%s", dev); - printf("queue path:%s\n", q.dev_path); - - ret = wd_request_queue(&q); - if(ret) - { - printf("wd request queue fail!\n"); - return 1; - } - printf("wd request queue success!\n"); - memory_size = m_size; - addr = wd_reserve_memory(&q, memory_size); - if(!addr) - { - wd_release_queue(&q); - printf("wd reserve memory fail!\n"); - return 1; - } - printf("wd reserve memory success!\n"); - memset(addr, 0, memory_size); - - memset((void *)&target_q, 0, sizeof(target_q)); - target_q.capa.alg = alg_type; - snprintf(target_q.dev_path, sizeof(target_q.dev_path), "%s", share_dev); - printf("target queue path:%s\n", target_q.dev_path); - - ret = wd_request_queue(&target_q); - if(ret) - { - wd_release_queue(&q); - printf("wd request target_q queue fail!\n"); - return 1; - } - printf("wd request target_q queue success!\n"); - //target_q队列共享q队列预留内存； - ret = wd_share_reserved_memory(&q, &target_q); - if(ret) - { - wd_release_queue(&q); - wd_release_queue(&target_q); - printf("wd target_q queue share reserved memory fail!\n"); - return 1; - } - printf("wd target_q queue share reserved memory success!\n"); - wd_release_queue(&target_q); - wd_release_queue(&q); - - return 0; -} -/*** - -***/ -int hpre_node_queue_share(char *dev, unsigned int node, unsigned int share_node, char *alg_type, unsigned long m_size) -{ - void *addr=NULL; - int ret = 0; - struct wd_queue q; - struct wd_queue target_q; - unsigned long memory_size; - - memset((void *)&q, 0, sizeof(q)); - q.capa.alg = alg_type; - snprintf(q.dev_path, sizeof(q.dev_path), "%s", dev); - printf("queue path:%s\n", q.dev_path); - q.node_mask = node; - - ret = wd_request_queue(&q); - if(ret) - { - printf("wd request queue fail!\n"); - return 1; - } - printf("wd request queue success!\n"); - memory_size = m_size; - addr = wd_reserve_memory(&q, memory_size); - if(!addr) - { - wd_release_queue(&q); - printf("wd reserve memory fail!\n"); - return 1; - } - printf("wd reserve memory success!\n"); - memset(addr, 0, memory_size); - - memset((void *)&target_q, 0, sizeof(target_q)); - target_q.capa.alg = alg_type; - target_q.node_mask = node; - - ret = wd_request_queue(&target_q); - if(ret) - { - wd_release_queue(&q); - printf("wd request target_q queue fail!\n"); - return 1; - } - printf("wd request target_q queue success!\n"); - //target_q队列共享q队列预留内存； - ret = do_dh(&q); - if(ret) - { - printf("do dh on q fail!\n"); - return 1; - } - ret = do_dh(&target_q); - if(ret) - { - printf("do dh on target q fail!\n"); - return 1; - } - - ret = wd_share_reserved_memory(&q, &target_q); - - if(ret) - { - wd_release_queue(&q); - wd_release_queue(&target_q); - printf("wd target_q queue share reserved memory fail!\n"); - return 1; - } - printf("wd target_q queue share reserved memory success!\n"); - ret = do_dh(&q); - if(ret) - { - printf("do dh on share q fail!\n"); - return 1; - } - ret = do_dh(&target_q); - if(ret) - { - printf("do dh on share target q fail!\n"); - return 1; - } - - wd_release_queue(&target_q); - wd_release_queue(&q); - - return 0; -} -/*** - -***/ -int hpre_dev_queue_interact_share(char *dev, char * share_dev, char *alg_type, unsigned long m_size) -{ - void *addr=NULL; - int ret = 0; - struct wd_queue q; - struct wd_queue target_q; - unsigned long memory_size; - - memset((void *)&q, 0, sizeof(q)); - q.capa.alg = alg_type; - snprintf(q.dev_path, sizeof(q.dev_path), "%s", dev); - printf("queue path:%s\n", q.dev_path); - - ret = wd_request_queue(&q); - if(ret) - { - printf("wd request queue fail!\n"); - return ret; - } - printf("wd request queue success!\n"); - memory_size = m_size; - addr = wd_reserve_memory(&q, memory_size); - if(!addr) - { - wd_release_queue(&q); - printf("wd reserve memory fail!\n"); - return 1; - } - printf("wd reserve memory success!\n"); - memset(addr, 0, memory_size); - - memset((void *)&target_q, 0, sizeof(target_q)); - target_q.capa.alg = alg_type; - snprintf(target_q.dev_path, sizeof(target_q.dev_path), "%s", share_dev); - printf("target queue path:%s\n", target_q.dev_path); - - ret = wd_request_queue(&target_q); - if(ret) - { - wd_release_queue(&q); - printf("wd request target_q queue fail!\n"); - return 1; - } - printf("wd request target_q queue success!\n"); - addr = wd_reserve_memory(&target_q, memory_size); - if(!addr) - { - wd_release_queue(&q); - wd_release_queue(&target_q); - printf("wd reserve memory fail!\n"); - return 1; - } - printf("wd reserve memory success!\n"); - memset(addr, 0, memory_size); - - //target_q - ret = wd_share_reserved_memory(&q, &target_q); - if(ret) - { - wd_release_queue(&q); - wd_release_queue(&target_q); - printf("wd target_q queue share reserved memory fail!\n"); - return 1; - } - printf("wd target_q queue share reserved memory success!\n"); - - wd_release_queue(&target_q); - wd_release_queue(&q); - - return 0; -} - -/*** - -***/ -int hpre_dev_queue_cross_proc_share(char *dev, char *alg_type, unsigned long m_size) -{ - void *addr=NULL; - int ret = 0; - pid_t pid; - struct wd_queue q; - struct wd_queue target_q; - unsigned long memory_size=0; - - pid = fork(); - if(pid < 0) - { - printf("Creation process failed, pid:%d\n",pid); - return 1; - } - else if(pid == 0) - { - printf("child process:%d\n", pid); - memset((void *)&q, 0, sizeof(q)); - q.capa.alg = alg_type; - snprintf(q.dev_path, sizeof(q.dev_path), "%s", dev); - printf("queue path:%s\n", q.dev_path); - - ret = wd_request_queue(&q); - if(ret) - { - printf("request queue fail!\n"); - exit(1); - } - printf("wd request queue success!\n"); - memory_size = m_size; - addr = wd_reserve_memory(&q, memory_size); - if(!addr) - { - wd_release_queue(&q); - printf("queue reserve memory fail!\n"); - exit(2); - } - printf("queue reserve memory success!\n"); - memset(addr, 0, memory_size); - exit(0); - } - printf("parent process:%d\n", pid); - pid_t wpid; - int status = -1; - wpid = waitpid(pid, &status, WUNTRACED | WCONTINUED); - if( wpid < 0) - { - printf("exited, status=%d\n", WEXITSTATUS(status)); - return(status); - } - - memset((void *)&target_q, 0, sizeof(target_q)); - target_q.capa.alg = alg_type; - snprintf(target_q.dev_path, sizeof(target_q.dev_path), "%s", dev); - printf("target queue path:%s\n", target_q.dev_path); - - ret = wd_request_queue(&target_q); - if(ret) - { - wd_release_queue(&q); - printf("wd request target_q queue fail!\n"); - return 1; - } - printf("wd request target_q queue success!\n"); - ret = wd_share_reserved_memory(&q, &target_q); - if(ret) - { - wd_release_queue(&target_q); - wd_release_queue(&q); - printf("wd target_q queue share reserved memory fail!\n"); - return 1; - } - printf("wd target_q queue share reserved memory success!\n"); - - wd_release_queue(&target_q); - wd_release_queue(&q); - - return 0; -} - /*** ***/ @@ -1696,87 +1385,6 @@ int main(int arc, char *argv[]) return 1; } } - else if(!strcmp(argv[1], "queue-share")) - { - /*** - argv[2] - 表示算法类型 - argv[3] - 表示申请队列设备 - argv[4] - 表示共享预留内存的设备 - argv[5] - 表示申请队列的预留内存大小 - ***/ - //申请单个队列，预留内存，与其它队列共享预留内存 - snprintf(algorithm_type, sizeof(algorithm_type), "%s", argv[2]); - snprintf(dev, sizeof(dev), "%s", argv[3]); - snprintf(share_dev, sizeof(share_dev), "%s", argv[4]); - memory_size = strtoul(argv[5], NULL, 10); - - ret = hpre_dev_queue_share(dev, share_dev, algorithm_type, memory_size); - if(0 != ret) - { - return 1; - } - } - else if(!strcmp(argv[1], "node-queue-share")) - { - /*** - argv[2] - 表示算法类型 - argv[3] - 表示申请队列设备 - argv[4] - 表示设备node - argv[5] - 表示共享内存设备node - argv[6] - 表示申请队列的预留内存大小 - ***/ - //申请单个队列，预留内存，与其它队列共享预留内存 - snprintf(algorithm_type, sizeof(algorithm_type), "%s", argv[2]); - snprintf(dev, sizeof(dev), "%s", argv[3]); - unsigned int node=0; - node = strtoul(argv[4], NULL, 16); - unsigned int share_node=0; - share_node = strtoul(argv[5], NULL, 16); - memory_size = strtoul(argv[6], NULL, 10); - - ret = hpre_node_queue_share(dev, node, share_node, algorithm_type, memory_size); - if(0 != ret) - { - return 1; - } - } - else if(!strcmp(argv[1], "queue-interact-share")) - { - /*** - argv[2] - 表示算法类型 - argv[3] - 表示申请队列设备 - argv[4] - 表示共享预留内存的设备 - argv[5] - 表示申请队列的预留内存大小 - ***/ - //队列预留内存后作为共享的目标队列 - snprintf(algorithm_type, sizeof(algorithm_type), "%s", argv[2]); - snprintf(dev, sizeof(dev), "%s", argv[3]); - snprintf(share_dev, sizeof(share_dev), "%s", argv[4]); - memory_size = strtoul(argv[5], NULL, 10); - - ret = hpre_dev_queue_interact_share(dev, share_dev, algorithm_type, memory_size); - if(0 != ret) - { - return 1; - } - } - else if(!strcmp(argv[1], "queue-cross-proc-share")) - { - /*** - argv[2] - 表示算法类型 - argv[3] - 表示申请队列设备 - argv[4] - 表示申请队列的预留内存大小 - ***/ - //跨进程进行队列共享 - snprintf(algorithm_type, sizeof(algorithm_type), "%s", argv[2]); - snprintf(dev, sizeof(dev), "%s", argv[3]); - memory_size = strtoul(argv[4], NULL, 10); - ret = hpre_dev_queue_cross_proc_share(dev, algorithm_type, memory_size); - if(0 != ret) - { - return 1; - } - } else if(!strcmp(argv[1], "mult-thread-queue")) { /*** diff --git a/v1/test/hisi_zip_test_sgl/wd_sched_sgl.c b/v1/test/hisi_zip_test_sgl/wd_sched_sgl.c index 31637565..7a3be22c 100644 --- a/v1/test/hisi_zip_test_sgl/wd_sched_sgl.c +++ b/v1/test/hisi_zip_test_sgl/wd_sched_sgl.c @@ -23,96 +23,33 @@ #define EXTRA_SIZE 4096 #define WD_WAIT_MS 1000 -static int __init_cache(struct wd_scheduler *sched, int data_fmt) +static int wd_sched_pre_uninit(struct wd_scheduler *sched, int data_fmt) { - int i; - int ret = -ENOMEM; + unsigned int flags = 0; struct q_info *qinfo; void *pool; + int i; - sched->msgs = calloc(sched->msg_cache_num, sizeof(*sched->msgs)); - if (!sched->msgs) { - WD_ERR("calloc for sched->msgs fail!\n"); - return ret; - } - sched->stat = calloc(sched->q_num, sizeof(*sched->stat)); - if (!sched->stat) { - WD_ERR("calloc for sched->stat fail!\n"); - goto err_with_msgs; - } qinfo = sched->qs[0].qinfo; - pool = qinfo->br.usr; - for (i = 0; i < sched->msg_cache_num; i++) { - if (data_fmt == WD_FLAT_BUF) { /* use pbuffer */ - sched->msgs[i].data_in = wd_alloc_blk(pool); - sched->msgs[i].data_out = wd_alloc_blk(pool); - if (!sched->msgs[i].data_in || !sched->msgs[i].data_out) { - dbg("not enough data ss_region memory " - "for cache %d (bs=%d)\n", i, sched->msg_data_size); - goto err_with_stat; - } - } else { /* use sgl */ - sched->msgs[i].data_in = wd_alloc_sgl(pool, sched->msg_data_size); - sched->msgs[i].data_out = wd_alloc_sgl(pool, sched->msg_data_size); - if (!sched->msgs[i].data_in || !sched->msgs[i].data_out) { - dbg("not enough data ss_region memory " - "for cache %d (bs=%d)\n", i, sched->msg_data_size); - goto err_with_stat; - } + flags = qinfo->dev_flags; + if (flags & WD_UACCE_DEV_PASID) { + if (sched->ss_region) { + free(sched->ss_region); + sched->ss_region = NULL; } + return 0; + } - if (sched->init_cache) - sched->init_cache(sched, i, data_fmt); + for (i = 0; i < sched->q_num; i++) { + wd_release_queue(&sched->qs[i]); + qinfo = sched->qs[i].qinfo; + if (data_fmt == WD_FLAT_BUF) + wd_blkpool_destroy(qinfo->br.usr); + else + wd_sglpool_destroy(qinfo->br.usr); } return 0; - -err_with_stat: - free(sched->stat); - sched->stat = NULL; -err_with_msgs: - free(sched->msgs); - sched->msgs = NULL; - return ret; -} - -static void __fini_cache(struct wd_scheduler *sched, int data_fmt) -{ - struct q_info *qinfo = sched->qs[0].qinfo; - unsigned int flags = qinfo->dev_flags; - void *pool; - int i; - - if (sched->stat) { - free(sched->stat); - sched->stat = NULL; - } - if (!(flags & WD_UACCE_DEV_PASID)) { - pool = qinfo->br.usr; - if (pool) { - if (data_fmt == WD_FLAT_BUF) { /* use pbuffer */ - for (i = 0; i < sched->msg_cache_num; i++) { - if (sched->msgs[i].data_in) - wd_free_blk(pool, sched->msgs[i].data_in); - if (sched->msgs[i].data_out) - wd_free_blk(pool, sched->msgs[i].data_out); - } - wd_blkpool_destroy(pool); - } else { /* use sgl */ - for (i = 0; i < sched->msg_cache_num; i++) { - if (sched->msgs[i].data_in) - wd_free_sgl(pool, sched->msgs[i].data_in); - if (sched->msgs[i].data_out) - wd_free_sgl(pool, sched->msgs[i].data_out); - } - wd_sglpool_destroy(pool); - } - } - } - if (sched->msgs) { - free(sched->msgs); - sched->msgs = NULL; - } } static int wd_sched_preinit(struct wd_scheduler *sched, int data_fmt) @@ -124,14 +61,6 @@ static int wd_sched_preinit(struct wd_scheduler *sched, int data_fmt) struct wd_sglpool_setup sp; void *pool; - for (i = 0; i < sched->q_num; i++) { - ret = wd_request_queue(&sched->qs[i]); - if (ret) { - WD_ERR("fail to request queue!\n"); - goto out_with_queues; - } - } - if (!sched->ss_region_size) sched->ss_region_size = EXTRA_SIZE + /* add 1 page extra */ sched->msg_cache_num * (sched->msg_data_size << 0x1); @@ -145,12 +74,22 @@ static int wd_sched_preinit(struct wd_scheduler *sched, int data_fmt) ret = -ENOMEM; goto out_with_queues; } - } else { - if (data_fmt == WD_FLAT_BUF) { /* use pbuffer*/ - memset(&mm_setup, 0, sizeof(mm_setup)); - mm_setup.block_size = sched->msg_data_size; - mm_setup.block_num = sched->msg_cache_num << 0x1; /* in and out */ - mm_setup.align_size = 128; + return 0; + } + + if (data_fmt == WD_FLAT_BUF) { /* use pbuffer*/ + memset(&mm_setup, 0, sizeof(mm_setup)); + mm_setup.block_size = sched->msg_data_size; + mm_setup.block_num = sched->msg_cache_num << 0x1; /* in and out */ + mm_setup.align_size = 128; + for (i = 0; i < sched->q_num; i++) { + ret = wd_request_queue(&sched->qs[i]); + if (ret) { + WD_ERR("fail to request queue!\n"); + goto out_with_queues; + } + + qinfo = sched->qs[i].qinfo; pool = wd_blkpool_create(&sched->qs[0], &mm_setup); if (!pool) { WD_ERR("%s(): create pool fail!\n", __func__); @@ -162,15 +101,18 @@ static int wd_sched_preinit(struct wd_scheduler *sched, int data_fmt) qinfo->br.iova_map = (void *)wd_blk_iova_map; qinfo->br.iova_unmap = (void *)wd_blk_iova_unmap; qinfo->br.usr = pool; - } else { /* use sgl*/ - memset(&sp, 0, sizeof(sp)); - sp.buf_size = sched->msg_data_size / 10; - sp.align_size = 64; - sp.sge_num_in_sgl = 60; - sp.buf_num_in_sgl = sp.sge_num_in_sgl; - sp.sgl_num = 3 * sched->msg_cache_num; - sp.buf_num = sp.buf_num_in_sgl * sp.sgl_num + sp.sgl_num * 2; - + } + } else { /* use sgl*/ + memset(&sp, 0, sizeof(sp)); + sp.buf_size = sched->msg_data_size / 10; + sp.align_size = 64; + sp.sge_num_in_sgl = 60; + sp.buf_num_in_sgl = sp.sge_num_in_sgl; + sp.sgl_num = 3 * sched->msg_cache_num; + sp.buf_num = sp.buf_num_in_sgl * sp.sgl_num + sp.sgl_num * 2; + + for (i = 0; i < sched->q_num; i++) { + qinfo = sched->qs[i].qinfo; pool = wd_sglpool_create(&sched->qs[0], &sp); if (!pool) { WD_ERR("%s(): create pool fail!\n", __func__); @@ -189,17 +131,132 @@ static int wd_sched_preinit(struct wd_scheduler *sched, int data_fmt) return 0; out_with_queues: + for (j = i-1; j >= 0; j--) { + wd_release_queue(&sched->qs[j]); + qinfo = sched->qs[j].qinfo; + if (data_fmt == WD_FLAT_BUF) + wd_blkpool_destroy(qinfo->br.usr); + else + wd_sglpool_destroy(qinfo->br.usr); + } + if (flags & WD_UACCE_DEV_PASID) { if (sched->ss_region) { free(sched->ss_region); sched->ss_region = NULL; } } - for (j = i-1; j >= 0; j--) - wd_release_queue(&sched->qs[j]); + return ret; } +static void __fini_cache(struct wd_scheduler *sched, int data_fmt) +{ + struct q_info *qinfo = sched->qs[0].qinfo; + unsigned int flags = qinfo->dev_flags; + void *pool; + int i, j; + + if (sched->stat) { + free(sched->stat); + sched->stat = NULL; + } + + if (sched->msgs) { + free(sched->msgs); + sched->msgs = NULL; + } + + if (!(flags & WD_UACCE_DEV_PASID)) { + for (j = 0; j < sched->q_num; j++) { + qinfo = sched->qs[j].qinfo; + pool = qinfo->br.usr; + if (!pool) + continue; + + if (data_fmt == WD_FLAT_BUF) { /* use pbuffer */ + for (i = 0; i < sched->msg_cache_num; i++) { + if (sched->msgs[i].data_in) + wd_free_blk(pool, sched->msgs[i].data_in); + if (sched->msgs[i].data_out) + wd_free_blk(pool, sched->msgs[i].data_out); + } + } else { /* use sgl */ + for (i = 0; i < sched->msg_cache_num; i++) { + if (sched->msgs[i].data_in) + wd_free_sgl(pool, sched->msgs[i].data_in); + if (sched->msgs[i].data_out) + wd_free_sgl(pool, sched->msgs[i].data_out); + } + } + } + } +} + +static int __init_cache(struct wd_scheduler *sched, int data_fmt) +{ + struct q_info *qinfo; + unsigned int flags; + int ret = -ENOMEM; + int i, j; + void *pool; + + sched->msgs = calloc(sched->msg_cache_num, sizeof(*sched->msgs)); + if (!sched->msgs) { + WD_ERR("calloc for sched->msgs fail!\n"); + return ret; + } + sched->stat = calloc(sched->q_num, sizeof(*sched->stat)); + if (!sched->stat) { + WD_ERR("calloc for sched->stat fail!\n"); + goto err_with_msgs; + } + qinfo = sched->qs[0].qinfo; + pool = qinfo->br.usr; + flags = qinfo->dev_flags; + if ((flags & WD_UACCE_DEV_PASID)) + return 0; + + for (i = 0; i < sched->q_num; i++) { + qinfo = sched->qs[i].qinfo; + pool = qinfo->br.usr; + for (j = 0; j < sched->msg_cache_num; j++) { + if (data_fmt == WD_FLAT_BUF) { /* use pbuffer */ + sched->msgs[j].data_in = wd_alloc_blk(pool); + sched->msgs[j].data_out = wd_alloc_blk(pool); + if (!sched->msgs[j].data_in || !sched->msgs[j].data_out) { + dbg("not enough data ss_region memory " + "for cache %d (bs=%d)\n", j, sched->msg_data_size); + goto err_with_stat; + } + } else { /* use sgl */ + sched->msgs[j].data_in = wd_alloc_sgl(pool, sched->msg_data_size); + sched->msgs[j].data_out = wd_alloc_sgl(pool, sched->msg_data_size); + if (!sched->msgs[j].data_in || !sched->msgs[j].data_out) { + dbg("not enough data ss_region memory " + "for cache %d (bs=%d)\n", j, sched->msg_data_size); + goto err_with_stat; + } + } + + if (sched->init_cache) + sched->init_cache(sched, j, data_fmt); + } + } + + return 0; + +err_with_stat: + free(sched->stat); + sched->stat = NULL; + __fini_cache(sched, data_fmt); +err_with_msgs: + if (sched->msgs) { + free(sched->msgs); + sched->msgs = NULL; + } + return ret; +} int wd_sched_init(struct wd_scheduler *sched, int data_fmt) { @@ -211,57 +268,22 @@ int wd_sched_init(struct wd_scheduler *sched, int data_fmt) if (ret < 0) return -EINVAL; - qinfo = sched->qs[0].qinfo; - flags = qinfo->dev_flags; - if (!(flags & WD_UACCE_DEV_PASID)) { - for (k = 1; k < sched->q_num; k++) { - ret = wd_share_reserved_memory(&sched->qs[0], - &sched->qs[k]); - if (ret) { - WD_ERR("fail to share queue reserved mem!\n"); - goto out_with_queues; - } - } - } - sched->cl = sched->msg_cache_num; ret = __init_cache(sched, data_fmt); if (ret) { WD_ERR("fail to init caches!\n"); - goto out_with_queues; + wd_sched_pre_uninit(sched, data_fmt); + return -EINVAL; } return 0; - -out_with_queues: - if (flags & WD_UACCE_DEV_PASID) { - if (sched->ss_region) { - free(sched->ss_region); - sched->ss_region = NULL; - } - } - for (j = sched->q_num - 1; j >= 0; j--) - wd_release_queue(&sched->qs[j]); - return ret; } void wd_sched_fini(struct wd_scheduler *sched, int data_fmt) { - int i; - struct q_info *qinfo = sched->qs[0].qinfo; - unsigned int flags = qinfo->dev_flags; - __fini_cache(sched, data_fmt); - if (flags & WD_UACCE_DEV_PASID) { - if (sched->ss_region) { - free(sched->ss_region); - sched->ss_region = NULL; - } - } - - for (i = sched->q_num - 1; i >= 0; i--) - wd_release_queue(&sched->qs[i]); + wd_sched_pre_uninit(sched, data_fmt); } static int __sync_send(struct wd_scheduler *sched) @@ -350,4 +372,4 @@ int wd_sched_work(struct wd_scheduler *sched, int remained) } return sched->cl; -} \ No newline at end of file +} diff --git a/v1/test/test_mm/test_wd_mem.c b/v1/test/test_mm/test_wd_mem.c index 09824b99..e2eec60e 100644 --- a/v1/test/test_mm/test_wd_mem.c +++ b/v1/test/test_mm/test_wd_mem.c @@ -208,10 +208,10 @@ void *mmt_sys_test_thread(void *data) return NULL; } - ret = wd_share_reserved_memory(pdata->qinfo1.q, &rsa_q); + ret = wd_request_queue(&pdata->qinfo1.q); if (ret) { wd_release_queue(&rsa_q); - MMT_PRT("Proc-%d, thrd-%d:share mem on rsa queue fail!\n", + MMT_PRT("Proc-%d, thrd-%d:rsa queue fail!\n", pid, thread_id); return NULL; } @@ -226,9 +226,9 @@ void *mmt_sys_test_thread(void *data) return NULL; } - ret = wd_share_reserved_memory(pdata->qinfo2.q, &zlib_q); + ret = wd_request_queue(&pdata->qinfo2.q); if (ret) { - MMT_PRT("Proc-%d, thrd-%d:share mem on zlib queue fail!\n", + MMT_PRT("Proc-%d, thrd-%d:zlib queue fail!\n", pid, thread_id); goto fail_release; diff --git a/v1/test/wd_sched.c b/v1/test/wd_sched.c index f5e46699..ce1d2604 100644 --- a/v1/test/wd_sched.c +++ b/v1/test/wd_sched.c @@ -22,94 +22,40 @@ #define EXTRA_SIZE 4096 #define WD_WAIT_MS 1000 -static int __init_cache(struct wd_scheduler *sched) +static int wd_sched_pre_uninit(struct wd_scheduler *sched) { - int i; - int ret = -ENOMEM; + unsigned int flags = 0; struct q_info *qinfo; void *pool; + int i; - sched->msgs = calloc(sched->msg_cache_num, sizeof(*sched->msgs)); - if (!sched->msgs) { - WD_ERR("calloc for sched->msgs fail!\n"); - return ret; - } - sched->stat = calloc(sched->q_num, sizeof(*sched->stat)); - if (!sched->stat) { - WD_ERR("calloc for sched->stat fail!\n"); - goto err_with_msgs; - } qinfo = sched->qs[0].qinfo; - pool = qinfo->br.usr; - for (i = 0; i < sched->msg_cache_num; i++) { - sched->msgs[i].data_in = wd_alloc_blk(pool); - sched->msgs[i].data_out = wd_alloc_blk(pool); - if (!sched->msgs[i].data_in || !sched->msgs[i].data_out) { - dbg("not enough data ss_region memory " - "for cache %d (bs=%d)\n", i, sched->msg_data_size); - goto err_with_stat; + flags = qinfo->dev_flags; + if (flags & WD_UACCE_DEV_PASID) { + if (sched->ss_region) { + free(sched->ss_region); + sched->ss_region = NULL; } + return 0; + } - if (sched->init_cache) - sched->init_cache(sched, i); + for (i = 0; i < sched->q_num; i++) { + wd_release_queue(&sched->qs[i]); + qinfo = sched->qs[i].qinfo; + wd_blkpool_destroy(qinfo->br.usr); } return 0; - -err_with_stat: - free(sched->stat); - sched->stat = NULL; -err_with_msgs: - free(sched->msgs); - sched->msgs = NULL; - return ret; -} - -static void __fini_cache(struct wd_scheduler *sched) -{ - struct q_info *qinfo = sched->qs[0].qinfo; - unsigned int flags = qinfo->dev_flags; - void *pool; - int i; - - if (sched->stat) { - free(sched->stat); - sched->stat = NULL; - } - if (!(flags & WD_UACCE_DEV_PASID)) { - pool = qinfo->br.usr; - if (pool) { - for (i = 0; i < sched->msg_cache_num; i++) { - if (sched->msgs[i].data_in) - wd_free_blk(pool, sched->msgs[i].data_in); - if (sched->msgs[i].data_out) - wd_free_blk(pool, sched->msgs[i].data_out); - } - wd_blkpool_destroy(pool); - } - } - if (sched->msgs) { - free(sched->msgs); - sched->msgs = NULL; - } } static int wd_sched_preinit(struct wd_scheduler *sched) { - int ret, i, j; + struct wd_blkpool_setup mm_setup; unsigned int flags = 0; struct q_info *qinfo; - struct wd_blkpool_setup mm_setup; + int ret, i, j; void *pool; - for (i = 0; i < sched->q_num; i++) { - ret = wd_request_queue(&sched->qs[i]); - if (ret) { - WD_ERR("fail to request queue!\n"); - goto out_with_queues; - } - } - if (!sched->ss_region_size) sched->ss_region_size = EXTRA_SIZE + /* add 1 page extra */ sched->msg_cache_num * (sched->msg_data_size << 0x1); @@ -120,18 +66,29 @@ static int wd_sched_preinit(struct wd_scheduler *sched) sched->ss_region = malloc(sched->ss_region_size); if (!sched->ss_region) { WD_ERR("fail to alloc sched ss region mem!\n"); + return -ENOMEM; + } + return 0; + } + + memset(&mm_setup, 0, sizeof(mm_setup)); + mm_setup.block_size = sched->msg_data_size; + mm_setup.block_num = sched->msg_cache_num << 0x1; /* in and out */ + mm_setup.align_size = 128; + for (i = 0; i < sched->q_num; i++) { + ret = wd_request_queue(&sched->qs[i]); + if (ret) { + WD_ERR("fail to request queue!\n"); ret = -ENOMEM; goto out_with_queues; } - } else { - memset(&mm_setup, 0, sizeof(mm_setup)); - mm_setup.block_size = sched->msg_data_size; - mm_setup.block_num = sched->msg_cache_num << 0x1; /* in and out */ - mm_setup.align_size = 128; - pool = wd_blkpool_create(&sched->qs[0], &mm_setup); + + qinfo = sched->qs[i].qinfo; + pool = wd_blkpool_create(&sched->qs[i], &mm_setup); if (!pool) { WD_ERR("%s(): create pool fail!\n", __func__); ret = -ENOMEM; + wd_release_queue(&sched->qs[i]); goto out_with_queues; } qinfo->br.alloc = (void *)wd_alloc_blk; @@ -144,79 +101,135 @@ static int wd_sched_preinit(struct wd_scheduler *sched) return 0; out_with_queues: + for (j = i-1; j >= 0; j--) { + wd_release_queue(&sched->qs[j]); + qinfo = sched->qs[j].qinfo; + wd_blkpool_destroy(qinfo->br.usr); + } + if (flags & WD_UACCE_DEV_PASID) { if (sched->ss_region) { free(sched->ss_region); sched->ss_region = NULL; } } - for (j = i-1; j >= 0; j--) - wd_release_queue(&sched->qs[j]); + return ret; } +static void __fini_cache(struct wd_scheduler *sched) +{ + struct q_info *qinfo = sched->qs[0].qinfo; + unsigned int flags = qinfo->dev_flags; + void *pool; + int i, j; -int wd_sched_init(struct wd_scheduler *sched) + if (sched->stat) { + free(sched->stat); + sched->stat = NULL; + } + + if (sched->msgs) { + free(sched->msgs); + sched->msgs = NULL; + } + + if (!(flags & WD_UACCE_DEV_PASID)) { + for (j = 0; j < sched->q_num; j++) { + qinfo = sched->qs[j].qinfo; + pool = qinfo->br.usr; + if (!pool) + continue; + + for (i = 0; i < sched->msg_cache_num; i++) { + if (sched->msgs[i].data_in) + wd_free_blk(pool, sched->msgs[i].data_in); + if (sched->msgs[i].data_out) + wd_free_blk(pool, sched->msgs[i].data_out); + } + } + } +} + +static int __init_cache(struct wd_scheduler *sched) { - int ret, j, k; - unsigned int flags; struct q_info *qinfo; + unsigned int flags; + int ret = -ENOMEM; + int i, j; + void *pool; - ret = wd_sched_preinit(sched); - if (ret < 0) - return -EINVAL; + sched->msgs = calloc(sched->msg_cache_num, sizeof(*sched->msgs)); + if (!sched->msgs) { + WD_ERR("calloc for sched->msgs fail!\n"); + return ret; + } + sched->stat = calloc(sched->q_num, sizeof(*sched->stat)); + if (!sched->stat) { + WD_ERR("calloc for sched->stat fail!\n"); + goto err_with_msgs; + } qinfo = sched->qs[0].qinfo; + pool = qinfo->br.usr; flags = qinfo->dev_flags; - if (!(flags & WD_UACCE_DEV_PASID)) { - for (k = 1; k < sched->q_num; k++) { - ret = wd_share_reserved_memory(&sched->qs[0], - &sched->qs[k]); - if (ret) { - WD_ERR("fail to share queue reserved mem!\n"); - goto out_with_queues; + if ((flags & WD_UACCE_DEV_PASID)) + return 0; + + for (i = 0; i < sched->q_num; i++) { + qinfo = sched->qs[i].qinfo; + pool = qinfo->br.usr; + for (j = 0; j < sched->msg_cache_num; j++) { + sched->msgs[j].data_in = wd_alloc_blk(pool); + sched->msgs[j].data_out = wd_alloc_blk(pool); + if (!sched->msgs[j].data_in || !sched->msgs[j].data_out) { + dbg("not enough data ss_region memory " + "for cache %d (bs=%d)\n", j, sched->msg_data_size); + goto err_with_alloc; } + + if (sched->init_cache) + sched->init_cache(sched, j); } } - sched->cl = sched->msg_cache_num; + return 0; + +err_with_alloc: + free(sched->stat); + sched->stat = NULL; + __fini_cache(sched); +err_with_msgs: + if (sched->msgs) { + free(sched->msgs); + sched->msgs = NULL; + } + return ret; +} + +int wd_sched_init(struct wd_scheduler *sched) +{ + int ret; + ret = wd_sched_preinit(sched); + if (ret < 0) + return -EINVAL; + + sched->cl = sched->msg_cache_num; ret = __init_cache(sched); if (ret) { WD_ERR("fail to init caches!\n"); - goto out_with_queues; + wd_sched_pre_uninit(sched); + return -EINVAL; } return 0; - -out_with_queues: - if (flags & WD_UACCE_DEV_PASID) { - if (sched->ss_region) { - free(sched->ss_region); - sched->ss_region = NULL; - } - } - for (j = sched->q_num - 1; j >= 0; j--) - wd_release_queue(&sched->qs[j]); - return ret; } void wd_sched_fini(struct wd_scheduler *sched) { - int i; - struct q_info *qinfo = sched->qs[0].qinfo; - unsigned int flags = qinfo->dev_flags; - __fini_cache(sched); - if (flags & WD_UACCE_DEV_PASID) { - if (sched->ss_region) { - free(sched->ss_region); - sched->ss_region = NULL; - } - } - - for (i = sched->q_num - 1; i >= 0; i--) - wd_release_queue(&sched->qs[i]); + wd_sched_pre_uninit(sched); } static int __sync_send(struct wd_scheduler *sched) -- 2.33.0

From: lizhi <lizhi206@huawei.com> Fix some issues of uninitialized variables. Signed-off-by: lizhi <lizhi206@huawei.com> Signed-off-by: Qi Tao <taoqi10@huawei.com> --- wd_aead.c | 3 ++- wd_agg.c | 3 ++- wd_cipher.c | 3 ++- wd_comp.c | 2 +- wd_dh.c | 2 +- wd_digest.c | 3 ++- wd_ecc.c | 3 ++- wd_rsa.c | 3 ++- 8 files changed, 14 insertions(+), 8 deletions(-) diff --git a/wd_aead.c b/wd_aead.c index fddf5f18..4ff7fd78 100644 --- a/wd_aead.c +++ b/wd_aead.c @@ -835,8 +835,9 @@ struct wd_aead_msg *wd_aead_get_msg(__u32 idx, __u32 tag) int wd_aead_poll_ctx(__u32 idx, __u32 expt, __u32 *count) { struct wd_ctx_config_internal *config = &wd_aead_setting.config; + struct wd_aead_msg resp_msg = {0}; struct wd_ctx_internal *ctx; - struct wd_aead_msg resp_msg, *msg; + struct wd_aead_msg *msg; struct wd_aead_req *req; __u64 recv_count = 0; __u32 tmp = expt; diff --git a/wd_agg.c b/wd_agg.c index ba2cb86a..ca81afb3 100644 --- a/wd_agg.c +++ b/wd_agg.c @@ -1512,8 +1512,9 @@ struct wd_agg_msg *wd_agg_get_msg(__u32 idx, __u32 tag) static int wd_agg_poll_ctx(__u32 idx, __u32 expt, __u32 *count) { struct wd_ctx_config_internal *config = &wd_agg_setting.config; - struct wd_agg_msg resp_msg, *msg; + struct wd_agg_msg resp_msg = {0}; struct wd_ctx_internal *ctx; + struct wd_agg_msg *msg; struct wd_agg_req *req; __u64 recv_count = 0; __u32 tmp = expt; diff --git a/wd_cipher.c b/wd_cipher.c index 86a9dcc9..6910628e 100644 --- a/wd_cipher.c +++ b/wd_cipher.c @@ -788,8 +788,9 @@ struct wd_cipher_msg *wd_cipher_get_msg(__u32 idx, __u32 tag) int wd_cipher_poll_ctx(__u32 idx, __u32 expt, __u32 *count) { struct wd_ctx_config_internal *config = &wd_cipher_setting.config; + struct wd_cipher_msg resp_msg = {0}; struct wd_ctx_internal *ctx; - struct wd_cipher_msg resp_msg, *msg; + struct wd_cipher_msg *msg; struct wd_cipher_req *req; __u64 recv_count = 0; __u32 tmp = expt; diff --git a/wd_comp.c b/wd_comp.c index 6a746316..647c320e 100644 --- a/wd_comp.c +++ b/wd_comp.c @@ -355,8 +355,8 @@ struct wd_comp_msg *wd_comp_get_msg(__u32 idx, __u32 tag) int wd_comp_poll_ctx(__u32 idx, __u32 expt, __u32 *count) { struct wd_ctx_config_internal *config = &wd_comp_setting.config; - struct wd_ctx_internal *ctx; struct wd_comp_msg resp_msg = {0}; + struct wd_ctx_internal *ctx; struct wd_comp_msg *msg; struct wd_comp_req *req; __u64 recv_count = 0; diff --git a/wd_dh.c b/wd_dh.c index 8fa4f4b6..abef811e 100644 --- a/wd_dh.c +++ b/wd_dh.c @@ -461,8 +461,8 @@ struct wd_dh_msg *wd_dh_get_msg(__u32 idx, __u32 tag) int wd_dh_poll_ctx(__u32 idx, __u32 expt, __u32 *count) { struct wd_ctx_config_internal *config = &wd_dh_setting.config; + struct wd_dh_msg rcv_msg = {0}; struct wd_ctx_internal *ctx; - struct wd_dh_msg rcv_msg; struct wd_dh_req *req; struct wd_dh_msg *msg; __u32 rcv_cnt = 0; diff --git a/wd_digest.c b/wd_digest.c index a709147a..4c1b0caa 100644 --- a/wd_digest.c +++ b/wd_digest.c @@ -739,8 +739,9 @@ struct wd_digest_msg *wd_digest_get_msg(__u32 idx, __u32 tag) int wd_digest_poll_ctx(__u32 idx, __u32 expt, __u32 *count) { struct wd_ctx_config_internal *config = &wd_digest_setting.config; + struct wd_digest_msg recv_msg = {0}; struct wd_ctx_internal *ctx; - struct wd_digest_msg recv_msg, *msg; + struct wd_digest_msg *msg; struct wd_digest_req *req; __u32 recv_cnt = 0; __u32 tmp = expt; diff --git a/wd_ecc.c b/wd_ecc.c index f3b734ce..d9ae6734 100644 --- a/wd_ecc.c +++ b/wd_ecc.c @@ -2349,8 +2349,9 @@ struct wd_ecc_msg *wd_ecc_get_msg(__u32 idx, __u32 tag) int wd_ecc_poll_ctx(__u32 idx, __u32 expt, __u32 *count) { struct wd_ctx_config_internal *config = &wd_ecc_setting.config; - struct wd_ecc_msg recv_msg, *msg; + struct wd_ecc_msg recv_msg = {0}; struct wd_ctx_internal *ctx; + struct wd_ecc_msg *msg; struct wd_ecc_req *req; __u32 rcv_cnt = 0; __u32 tmp = expt; diff --git a/wd_rsa.c b/wd_rsa.c index 8ac206a1..9fa01c52 100644 --- a/wd_rsa.c +++ b/wd_rsa.c @@ -521,9 +521,10 @@ struct wd_rsa_msg *wd_rsa_get_msg(__u32 idx, __u32 tag) int wd_rsa_poll_ctx(__u32 idx, __u32 expt, __u32 *count) { struct wd_ctx_config_internal *config = &wd_rsa_setting.config; + struct wd_rsa_msg recv_msg = {0}; struct wd_ctx_internal *ctx; struct wd_rsa_req *req; - struct wd_rsa_msg recv_msg, *msg; + struct wd_rsa_msg *msg; __u32 rcv_cnt = 0; __u32 tmp = expt; int ret; -- 2.33.0

From: lizhi <lizhi206@huawei.com> Fix incorrect nid configuration in the params fill. Signed-off-by: lizhi <lizhi206@huawei.com> Signed-off-by: Qi Tao <taoqi10@huawei.com> --- uadk_tool/benchmark/hpre_uadk_benchmark.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/uadk_tool/benchmark/hpre_uadk_benchmark.c b/uadk_tool/benchmark/hpre_uadk_benchmark.c index 70d81fef..b4a5d975 100644 --- a/uadk_tool/benchmark/hpre_uadk_benchmark.c +++ b/uadk_tool/benchmark/hpre_uadk_benchmark.c @@ -1139,7 +1139,7 @@ static int get_ecc_param_from_sample(struct hpre_ecc_setup *setup, setup->key_bits = key_bits; - if (setup->nid == 714 || key_bits == 256) { // NID_secp256k1 + if (setup->nid == 415 || key_bits == 256) { // NID_secp256r1 /* sm2 */ if (subtype == SM2_TYPE) { setup->priv_key = sm2_priv; @@ -1181,6 +1181,7 @@ static int get_ecc_param_from_sample(struct hpre_ecc_setup *setup, setup->sign_size = sizeof(sm2_sign_data); } else { + /* x448, x25519 and ecdh-256 can share same private key of ecdh_da_secp256k1*/ setup->priv_key = ecdh_da_secp256k1; setup->except_pub_key = ecdh_except_b_pubkey_secp256k1; setup->pub_key = ecdh_cp_pubkey_secp256k1; -- 2.33.0

From: Chenghai Huang <huangchenghai2@huawei.com> Using count cannot guarantee that the process is initialized only once. Repeated init and uninit will degrade performance. Therefore, use the destructor to uninit. Signed-off-by: Chenghai Huang <huangchenghai2@huawei.com> Signed-off-by: Qi Tao <taoqi10@huawei.com> --- wd_zlibwrapper.c | 41 ++++++++++------------------------------- 1 file changed, 10 insertions(+), 31 deletions(-) diff --git a/wd_zlibwrapper.c b/wd_zlibwrapper.c index 4dc6c193..330daa44 100644 --- a/wd_zlibwrapper.c +++ b/wd_zlibwrapper.c @@ -24,18 +24,13 @@ enum uadk_init_status { WD_ZLIB_INIT, }; -struct wd_zlibwrapper_config { - int count; - int status; -}; - static pthread_mutex_t wd_zlib_mutex = PTHREAD_MUTEX_INITIALIZER; -static struct wd_zlibwrapper_config zlib_config = {0}; +static int zlib_status; static void wd_zlib_unlock(void) { + zlib_status = WD_ZLIB_UNINIT; pthread_mutex_unlock(&wd_zlib_mutex); - zlib_config.status = WD_ZLIB_UNINIT; } static int wd_zlib_uadk_init(void) @@ -44,7 +39,7 @@ static int wd_zlib_uadk_init(void) struct wd_ctx_nums *ctx_set_num; int ret, i; - if (zlib_config.status == WD_ZLIB_INIT) + if (zlib_status == WD_ZLIB_INIT) return 0; ctx_set_num = calloc(WD_DIR_MAX, sizeof(*ctx_set_num)); @@ -63,7 +58,7 @@ static int wd_zlib_uadk_init(void) if (ret && ret != -WD_EEXIST) ret = Z_STREAM_ERROR; - zlib_config.status = WD_ZLIB_INIT; + zlib_status = WD_ZLIB_INIT; free(ctx_set_num); @@ -73,7 +68,7 @@ static int wd_zlib_uadk_init(void) static void wd_zlib_uadk_uninit(void) { wd_comp_uninit2(); - zlib_config.status = WD_ZLIB_UNINIT; + zlib_status = WD_ZLIB_UNINIT; } static int wd_zlib_analy_alg(int windowbits, int *alg, int *windowsize) @@ -158,16 +153,6 @@ static int wd_zlib_init(z_streamp strm, int level, int windowbits, enum wd_comp_ strm->total_out = 0; ret = wd_zlib_alloc_sess(strm, level, windowbits, type); - if (unlikely(ret < 0)) - goto out_uninit; - - __atomic_add_fetch(&zlib_config.count, 1, __ATOMIC_RELAXED); - pthread_mutex_unlock(&wd_zlib_mutex); - - return Z_OK; - -out_uninit: - wd_zlib_uadk_uninit(); out_unlock: pthread_mutex_unlock(&wd_zlib_mutex); @@ -184,17 +169,6 @@ static int wd_zlib_uninit(z_streamp strm) wd_zlib_free_sess(strm); - pthread_mutex_lock(&wd_zlib_mutex); - - ret = __atomic_sub_fetch(&zlib_config.count, 1, __ATOMIC_RELAXED); - if (ret != 0) - goto out_unlock; - - wd_zlib_uadk_uninit(); - -out_unlock: - pthread_mutex_unlock(&wd_zlib_mutex); - return Z_OK; } @@ -307,3 +281,8 @@ int wd_inflate_end(z_streamp strm) { return wd_zlib_uninit(strm); } + +__attribute__ ((destructor)) static void wd_zlibwrapper_destory(void) +{ + wd_zlib_uadk_uninit(); +} -- 2.33.0