June 2026 - Acc - mailweb.openeuler.org

[PATCH 0/4] uadk_provider: several improvements and fixes
by ZongYu Wu 23 Jun '26

23 Jun '26

From: Weili Qian <qianweili(a)huawei.com> *** BLURB HERE *** Weili Qian (3): uadk_provider: set rsa sign hash flag uadk_provider: add outsize check in uadk_asym_cipher_rsa_encrypt uadk_provider: remove soft field to match default provider structure size lizhi (1): uadk_provider: fix return UADK_P_FAIL when alloc sess fails in ec_alloc_sess src/uadk_prov_ec_kmgmt.c | 2 +- src/uadk_prov_rsa.c | 9 ++++-- src/uadk_prov_rsa.h | 1 - src/uadk_prov_rsa_enc.c | 35 ++++++++++++---------- src/uadk_prov_rsa_kmgmt.c | 6 ---- src/uadk_prov_rsa_sign.c | 61 ++++++++++++++++++++++++++++----------- 6 files changed, 72 insertions(+), 42 deletions(-) -- 2.43.0

1 4

[PATCH] uadk_provider: set rsa sign hash flag
by ZongYu Wu 18 Jun '26

18 Jun '26

From: Weili Qian <qianweili(a)huawei.com> Set rsa signature hash flag, this flag is cleared by their Init function, and set again by their Final function. Signed-off-by: Weili Qian <qianweili(a)huawei.com> --- src/uadk_prov_rsa_enc.c | 3 +++ src/uadk_prov_rsa_sign.c | 15 ++++++++++++++- 2 files changed, 17 insertions(+), 1 deletion(-) diff --git a/src/uadk_prov_rsa_enc.c b/src/uadk_prov_rsa_enc.c index c0da4c9..66d9fea 100644 --- a/src/uadk_prov_rsa_enc.c +++ b/src/uadk_prov_rsa_enc.c @@ -353,6 +353,9 @@ static int uadk_rsa_asym_init(void *vprsactx, void *vrsa, RSA_free(priv->rsa); priv->rsa = vrsa; priv->operation = operation; +# if OPENSSL_VERSION_NUMBER >= 0x30200000 + priv->implicit_rejection = 1; +#endif switch (uadk_rsa_test_flags(priv->rsa, RSA_FLAG_TYPE_MASK)) { case RSA_FLAG_TYPE_RSA: diff --git a/src/uadk_prov_rsa_sign.c b/src/uadk_prov_rsa_sign.c index e2b7073..249dcc7 100644 --- a/src/uadk_prov_rsa_sign.c +++ b/src/uadk_prov_rsa_sign.c @@ -35,7 +35,9 @@ struct PROV_RSA_SIG_CTX { char *propq; RSA *rsa; int operation; - +#if OPENSSL_VERSION_NUMBER >= 0x30400000L + unsigned int flag_sigalg : 1; +#endif /* * Flag to determine if the hash function can be changed (1) or not (0) * Because it's dangerous to change during a DigestSign or DigestVerify @@ -637,6 +639,9 @@ static int uadk_rsa_signverify_init(void *vprsactx, void *vrsa, /* Maximum for sign, auto for verify */ ctx->saltlen = RSA_PSS_SALTLEN_AUTO; ctx->min_saltlen = -1; + ctx->flag_allow_oneshot = 1; + ctx->flag_allow_final = 1; + ctx->flag_allow_update = 1; switch (uadk_rsa_test_flags(ctx->rsa, RSA_FLAG_TYPE_MASK)) { case RSA_FLAG_TYPE_RSA: @@ -1585,6 +1590,10 @@ static int uadk_signature_rsa_digest_sign_final(void *vprsactx, unsigned char *s */ if (!EVP_DigestFinal_ex(priv->mdctx, digest, &dlen)) return UADK_P_FAIL; + + priv->flag_allow_update = 0; + priv->flag_allow_oneshot = 0; + priv->flag_allow_final = 0; } priv->flag_allow_md = 1; @@ -1630,6 +1639,10 @@ static int uadk_signature_rsa_digest_verify_final(void *vprsactx, const unsigned if (!EVP_DigestFinal_ex(priv->mdctx, digest, &dlen)) return UADK_P_FAIL; + priv->flag_allow_update = 0; + priv->flag_allow_final = 0; + priv->flag_allow_oneshot = 0; + priv->flag_allow_md = 1; return uadk_signature_rsa_verify(vprsactx, sig, siglen, digest, (size_t)dlen); } -- 2.43.0

1 0

[PATCH 1/1] uadk_provider: fix aead fallback to software on exception
by ZongYu Wu 10 Jun '26

10 Jun '26

From: Zhushuai Yin <yinzhushuai(a)huawei.com> When the AEAD algorithm fails during the execution of a service, it fails to switch to software-based computation for processing. After the current modification, even if it fails, it can still switch to software-based computation for processing. Signed-off-by: Zhushuai Yin <yinzhushuai(a)huawei.com> --- src/uadk_prov_aead.c | 150 ++++++++++++++++++++++++++++--------------- 1 file changed, 99 insertions(+), 51 deletions(-) diff --git a/src/uadk_prov_aead.c b/src/uadk_prov_aead.c index 26eeb66..88ec8e4 100644 --- a/src/uadk_prov_aead.c +++ b/src/uadk_prov_aead.c @@ -434,21 +434,6 @@ static int do_aes_gcm_prepare(struct aead_priv_ctx *priv) return UADK_AEAD_SUCCESS; } -static void uadk_do_aead_async_prepare(struct aead_priv_ctx *priv, unsigned char *output, - const unsigned char *input, size_t inlen) -{ - priv->req.in_bytes = inlen; - /* AAD data will be input and output together with plaintext or ciphertext. */ - if (priv->req.assoc_bytes) { - memcpy(priv->data + priv->req.assoc_bytes, input, inlen); - priv->req.src = priv->data; - priv->req.dst = priv->data + AEAD_BLOCK_SIZE; - } else { - priv->req.src = (unsigned char *)input; - priv->req.dst = output; - } -} - static int uadk_do_aead_sync_inner(struct aead_priv_ctx *priv, unsigned char *out, const unsigned char *in, size_t inlen, enum wd_aead_msg_state state) @@ -511,14 +496,15 @@ static int uadk_do_aead_sync(struct aead_priv_ctx *priv, unsigned char *out, return UADK_AEAD_SUCCESS; } -static int uadk_do_aead_async(struct aead_priv_ctx *priv, struct async_op *op, - unsigned char *out, const unsigned char *in, size_t inlen) +static int uadk_do_aead_async_inner(struct aead_priv_ctx *priv, struct async_op *op, + unsigned char *out, const unsigned char *in, size_t inlen) { struct uadk_e_cb_info cb_param; int cnt = 0; int ret; - if (!priv->enc && priv->tag_set != SET_TAG) { + if ((priv->req.msg_state == AEAD_MSG_BLOCK || priv->req.msg_state == AEAD_MSG_END) + && !priv->enc && priv->tag_set != SET_TAG) { UADK_ERR("The tag for asynchronous decryption is not set.\n"); return UADK_AEAD_FAIL; } @@ -528,14 +514,19 @@ static int uadk_do_aead_async(struct aead_priv_ctx *priv, struct async_op *op, return UADK_AEAD_FAIL; } - uadk_do_aead_async_prepare(priv, out, in, inlen); - cb_param.op = op; cb_param.priv = &priv->req; priv->req.cb = uadk_prov_aead_cb; priv->req.cb_param = &cb_param; - priv->req.msg_state = AEAD_MSG_BLOCK; priv->req.state = POLL_ERROR; + priv->req.src = (unsigned char *)in; + priv->req.dst = out; + priv->req.in_bytes = inlen; + + if (unlikely(!priv->sess)) { + UADK_ERR("uadk session is NULL!\n"); + return UADK_AEAD_FAIL; + } ret = async_get_free_task(&op->idx); if (unlikely(!ret)) @@ -559,19 +550,17 @@ static int uadk_do_aead_async(struct aead_priv_ctx *priv, struct async_op *op, ret = async_pause_job(priv, op, ASYNC_TASK_AEAD); if (unlikely(!ret || priv->req.state)) { UADK_ERR("do aead async job failed, ret: %d, state: %u!\n", - ret, priv->req.state); + ret, priv->req.state); return UADK_AEAD_FAIL; } - if (priv->req.assoc_bytes) - memcpy(out, priv->req.dst + priv->req.assoc_bytes, inlen); - return ret; } static int uadk_prov_do_aes_gcm_first(struct aead_priv_ctx *priv, unsigned char *out, const unsigned char *in, size_t inlen) { + struct async_op op; int ret; if (inlen > MAX_AAD_LEN || !inlen) @@ -579,9 +568,20 @@ static int uadk_prov_do_aes_gcm_first(struct aead_priv_ctx *priv, unsigned char priv->req.assoc_bytes = inlen; - /* Asynchronous jobs use the block mode. */ if (priv->mode == ASYNC_MODE) { - memcpy(priv->data, in, inlen); + ret = async_setup_async_event_notification(&op); + if (unlikely(!ret)) { + UADK_ERR("failed to setup async event notification.\n"); + goto soft; + } + + priv->req.msg_state = AEAD_MSG_FIRST; + ret = uadk_do_aead_async_inner(priv, &op, out, in, inlen); + if (unlikely(ret < 0)) { + UADK_ERR("aead async first failed, switch to soft.\n"); + goto free_notification; + } + return UADK_AEAD_SUCCESS; } @@ -591,58 +591,105 @@ static int uadk_prov_do_aes_gcm_first(struct aead_priv_ctx *priv, unsigned char return UADK_AEAD_SUCCESS; +free_notification: + (void)async_clear_async_event_notification(); soft: UADK_ERR("aead failed to update aad, switch to soft.\n"); return SWITCH_TO_SOFT; } -static int uadk_prov_do_aes_gcm_update(struct aead_priv_ctx *priv, unsigned char *out, - const unsigned char *in, size_t inlen) +static int uadk_do_aead_async(struct aead_priv_ctx *priv, unsigned char *out, + const unsigned char *in, size_t inlen) { - struct async_op *op; + size_t nbytes, tail, processing_len, max_mid_len; + const unsigned char *in_block = in; + unsigned char *out_block = out; + struct async_op op; int ret; - if (priv->mode == ASYNC_MODE) { - op = malloc(sizeof(struct async_op)); - if (unlikely(!op)) - return UADK_AEAD_FAIL; + ret = async_setup_async_event_notification(&op); + if (unlikely(!ret)) { + UADK_ERR("failed to setup async event notification.\n"); + return UADK_AEAD_FAIL; + } - ret = async_setup_async_event_notification(op); - if (unlikely(!ret)) { - UADK_ERR("failed to setup async event notification.\n"); - goto free_op; - } + tail = inlen % AES_BLOCK_SIZE; + nbytes = inlen - tail; + max_mid_len = AEAD_BLOCK_SIZE - priv->req.assoc_bytes; - ret = uadk_do_aead_async(priv, op, out, in, inlen); + /* Middle packets processing */ + while (nbytes > 0) { + processing_len = nbytes > max_mid_len ? max_mid_len : nbytes; + processing_len -= (processing_len % AES_BLOCK_SIZE); + + priv->req.msg_state = AEAD_MSG_MIDDLE; + ret = uadk_do_aead_async_inner(priv, &op, out_block, in_block, + processing_len); if (unlikely(ret < 0)) { - UADK_ERR("uadk_do_aead_async failed ret = %d.\n", ret); + UADK_ERR("aead async middle failed!\n"); goto free_notification; } - - free(op); - return UADK_AEAD_SUCCESS; + nbytes -= processing_len; + in_block = in_block + processing_len; + out_block = out_block + processing_len; } - if (priv->stream_switch_flag == UADK_DO_SOFT) - return SWITCH_TO_SOFT; + /* Tail packet processing */ + if (tail) { + priv->req.msg_state = AEAD_MSG_END; + ret = uadk_do_aead_async_inner(priv, &op, out_block, in_block, tail); + if (unlikely(ret < 0)) { + UADK_ERR("aead async tail failed!\n"); + goto free_notification; + } + } - return uadk_do_aead_sync(priv, out, in, inlen); + return UADK_AEAD_SUCCESS; free_notification: (void)async_clear_async_event_notification(); -free_op: - free(op); + return UADK_AEAD_FAIL; } +static int uadk_prov_do_aes_gcm_update(struct aead_priv_ctx *priv, unsigned char *out, + const unsigned char *in, size_t inlen) +{ + if (priv->stream_switch_flag == UADK_DO_SOFT) + return SWITCH_TO_SOFT; + + if (priv->mode == ASYNC_MODE) + return uadk_do_aead_async(priv, out, in, inlen); + + return uadk_do_aead_sync(priv, out, in, inlen); +} + static int uadk_prov_do_aes_gcm_final(struct aead_priv_ctx *priv, unsigned char *out, const unsigned char *in, size_t inlen) { + struct async_op op; int ret; - if (priv->mode == ASYNC_MODE || !priv->req.assoc_bytes || - priv->req.msg_state == AEAD_MSG_END) + if (!priv->req.assoc_bytes || priv->req.msg_state == AEAD_MSG_END) + goto out; + + if (priv->mode == ASYNC_MODE) { + ret = async_setup_async_event_notification(&op); + if (unlikely(!ret)) { + UADK_ERR("failed to setup async event notification.\n"); + return UADK_AEAD_FAIL; + } + + priv->req.msg_state = AEAD_MSG_END; + ret = uadk_do_aead_async_inner(priv, &op, out, in, inlen); + if (unlikely(ret < 0)) { + UADK_ERR("aead async final failed!\n"); + (void)async_clear_async_event_notification(); + return UADK_AEAD_FAIL; + } + goto out; + } ret = uadk_do_aead_sync_inner(priv, out, in, inlen, AEAD_MSG_END); if (unlikely(ret < 0)) @@ -655,6 +702,7 @@ out: priv->tag_set = INIT_TAG; priv->mode = UNINIT_MODE; + return UADK_AEAD_SUCCESS; } -- 2.43.0

1 0

[PATCH] crypto: hisilicon/zip - add backlog support for zip
by ZongYu Wu 02 Jun '26

02 Jun '26

From: Chenghai Huang <huangchenghai2(a)huawei.com> Upstream: YES AR: AR20230706877748 Feature or Bugfix: Bugfix DTS: DTS2026041602458 Implement backlog mechanism to queue requests when hardware is busy, This prevents request failures during hardware congestion and provides a fallback function in the event of a hardware reset. Signed-off-by: Chenghai Huang <huangchenghai2(a)huawei.com> --- drivers/crypto/hisilicon/zip/zip_crypto.c | 313 ++++++++++++++-------- 1 file changed, 203 insertions(+), 110 deletions(-) diff --git a/drivers/crypto/hisilicon/zip/zip_crypto.c b/drivers/crypto/hisilicon/zip/zip_crypto.c index 108ad882393d..7603a07d7e55 100644 --- a/drivers/crypto/hisilicon/zip/zip_crypto.c +++ b/drivers/crypto/hisilicon/zip/zip_crypto.c @@ -29,6 +29,7 @@ #define HZIP_ALG_DEFLATE GENMASK(5, 4) #define HZIP_ALG_LZ4 BIT(8) +#define HZIP_INVAL_REQ_ID ((u16)0xFFFF) static DEFINE_MUTEX(zip_algs_lock); static unsigned int zip_available_devs; @@ -56,11 +57,11 @@ struct hisi_zip_req { dma_addr_t dma_src; dma_addr_t dma_dst; struct hisi_zip_qp_ctx *qp_ctx; + struct list_head list; u16 req_id; }; struct hisi_zip_req_q { - struct hisi_zip_req *q; unsigned long *req_bitmap; spinlock_t req_lock; u16 size; @@ -126,6 +127,9 @@ static int hisi_zip_fallback_do_work(struct crypto_comp *tfm, struct acomp_req * const char *algo; int ret; + if (!tfm) + return -EINVAL; + input = kmap_local_page(sg_page(acomp_req->src)) + acomp_req->src->offset; output = kmap_local_page(sg_page(acomp_req->dst)) + acomp_req->dst->offset; @@ -146,12 +150,10 @@ static int hisi_zip_fallback_do_work(struct crypto_comp *tfm, struct acomp_req * return ret; } -static struct hisi_zip_req *hisi_zip_create_req(struct hisi_zip_qp_ctx *qp_ctx, - struct acomp_req *req) +static int hisi_zip_create_req(struct hisi_zip_req *req) { + struct hisi_zip_qp_ctx *qp_ctx = req->qp_ctx; struct hisi_zip_req_q *req_q = &qp_ctx->req_q; - struct hisi_zip_req *q = req_q->q; - struct hisi_zip_req *req_cache; int req_id; spin_lock(&req_q->req_lock); @@ -160,28 +162,26 @@ static struct hisi_zip_req *hisi_zip_create_req(struct hisi_zip_qp_ctx *qp_ctx, if (req_id >= req_q->size) { spin_unlock(&req_q->req_lock); dev_dbg(&qp_ctx->qp->qm->pdev->dev, "req cache is full!\n"); - return ERR_PTR(-EAGAIN); + return -EBUSY; } set_bit(req_id, req_q->req_bitmap); spin_unlock(&req_q->req_lock); - req_cache = q + req_id; - req_cache->req_id = req_id; - req_cache->req = req; - req_cache->qp_ctx = qp_ctx; + req->req_id = req_id; - return req_cache; + return 0; } -static void hisi_zip_remove_req(struct hisi_zip_qp_ctx *qp_ctx, - struct hisi_zip_req *req) +static void hisi_zip_remove_req(struct hisi_zip_req *req) { - struct hisi_zip_req_q *req_q = &qp_ctx->req_q; + struct hisi_zip_req_q *req_q = &req->qp_ctx->req_q; spin_lock(&req_q->req_lock); clear_bit(req->req_id, req_q->req_bitmap); spin_unlock(&req_q->req_lock); + + req->req_id = HZIP_INVAL_REQ_ID; } static void hisi_zip_fill_addr(struct hisi_zip_sqe *sqe, struct hisi_zip_req *req) @@ -258,19 +258,21 @@ static void hisi_zip_fill_sqe(struct hisi_zip_ctx *ctx, struct hisi_zip_sqe *sqe ops->fill_sqe_type(sqe, ops->sqe_type); } -static int hisi_zip_do_work(struct hisi_zip_qp_ctx *qp_ctx, - struct hisi_zip_req *req) +static void hisi_zip_enqueue_backlog(struct hisi_zip_req *req) { + struct hisi_qp *qp = req->qp_ctx->qp; + + spin_lock_bh(&qp->backlog.lock); + list_add_tail(&req->list, &qp->backlog.list); + spin_unlock_bh(&qp->backlog.lock); +} + +static int hisi_zip_map_req_buffers(struct hisi_zip_req *req) +{ + struct hisi_zip_qp_ctx *qp_ctx = req->qp_ctx; struct hisi_acc_sgl_pool *pool = qp_ctx->sgl_pool; - struct hisi_zip_dfx *dfx = &qp_ctx->zip_dev->dfx; + struct device *dev = &qp_ctx->qp->qm->pdev->dev; struct acomp_req *a_req = req->req; - struct hisi_qp *qp = qp_ctx->qp; - struct device *dev = &qp->qm->pdev->dev; - struct hisi_zip_sqe zip_sqe; - int ret; - - if (unlikely(!a_req->src || !a_req->slen || !a_req->dst || !a_req->dlen)) - return -EINVAL; req->hw_src = hisi_acc_sg_buf_map_to_hw_sgl(dev, a_req->src, pool, req->req_id << 1, &req->dma_src, @@ -285,33 +287,114 @@ static int hisi_zip_do_work(struct hisi_zip_qp_ctx *qp_ctx, (req->req_id << 1) + 1, &req->dma_dst, DMA_FROM_DEVICE); if (IS_ERR(req->hw_dst)) { - ret = PTR_ERR(req->hw_dst); - dev_err(dev, "failed to map the dst buffer to hw sgl (%d)!\n", - ret); - goto err_unmap_input; + dev_err(dev, "failed to map the dst buffer to hw sgl (%ld)!\n", + PTR_ERR(req->hw_dst)); + hisi_acc_sg_buf_unmap(dev, a_req->src, req->hw_src, DMA_TO_DEVICE); + return PTR_ERR(req->hw_dst); } + return 0; +} + +static void hisi_zip_unmap_req_buffers(struct hisi_zip_req *req) +{ + struct device *dev = &req->qp_ctx->qp->qm->pdev->dev; + struct acomp_req *a_req = req->req; + + hisi_acc_sg_buf_unmap(dev, a_req->dst, req->hw_dst, DMA_FROM_DEVICE); + hisi_acc_sg_buf_unmap(dev, a_req->src, req->hw_src, DMA_TO_DEVICE); +} + +static int hisi_zip_do_work(struct hisi_zip_req *req) +{ + struct hisi_zip_qp_ctx *qp_ctx = req->qp_ctx; + struct hisi_zip_dfx *dfx = &qp_ctx->zip_dev->dfx; + struct hisi_qp *qp = qp_ctx->qp; + struct hisi_zip_sqe zip_sqe; + int ret; + hisi_zip_fill_sqe(qp_ctx->ctx, &zip_sqe, qp_ctx->req_type, req); /* send command to start a task */ - atomic64_inc(&dfx->send_cnt); ret = hisi_qp_send(qp, &zip_sqe); - if (unlikely(ret < 0)) { - atomic64_inc(&dfx->send_busy_cnt); - ret = -EAGAIN; - dev_dbg_ratelimited(dev, "failed to send request!\n"); - goto err_unmap_output; + if (likely(!ret)) { + atomic64_inc(&dfx->send_cnt); + return -EINPROGRESS; } - return -EINPROGRESS; + if (ret == -EBUSY) + atomic64_inc(&dfx->send_busy_cnt); -err_unmap_output: - hisi_acc_sg_buf_unmap(dev, a_req->dst, req->hw_dst, DMA_FROM_DEVICE); -err_unmap_input: - hisi_acc_sg_buf_unmap(dev, a_req->src, req->hw_src, DMA_TO_DEVICE); return ret; } +static void hisi_zip_send_backlog_soft(struct hisi_zip_qp_ctx *qp_ctx) +{ + struct hisi_zip_ctx *ctx = qp_ctx->ctx; + bool is_decomp = qp_ctx->qp->alg_type; + struct hisi_zip_req *req, *tmp; + int ret; + + list_for_each_entry_safe(req, tmp, &qp_ctx->qp->backlog.list, list) { + list_del(&req->list); + + if (req->req_id != HZIP_INVAL_REQ_ID) { + hisi_zip_unmap_req_buffers(req); + hisi_zip_remove_req(req); + } + + ret = hisi_zip_fallback_do_work(ctx->soft_tfm, req->req, + is_decomp); + + /* Wake up the busy thread first, then return the errno. */ + if (req->req->base.complete) { + acomp_request_complete(req->req, -EINPROGRESS); + acomp_request_complete(req->req, ret); + } + } +} + +static void hisi_zip_send_backlog(struct hisi_qp *qp) +{ + struct hisi_zip_req *req, *tmp; + struct hisi_zip_req_q *req_q; + int ret; + + spin_lock_bh(&qp->backlog.lock); + list_for_each_entry_safe(req, tmp, &qp->backlog.list, list) { + req_q = &req->qp_ctx->req_q; + if (req->req_id == HZIP_INVAL_REQ_ID) { + ret = hisi_zip_create_req(req); + if (ret) + continue; + + ret = hisi_zip_map_req_buffers(req); + if (unlikely(ret)) { + hisi_zip_remove_req(req); + hisi_zip_send_backlog_soft(req->qp_ctx); + goto unlock; + } + } + + ret = hisi_zip_do_work(req); + switch (ret) { + case -EINPROGRESS: + list_del(&req->list); + if (req->req->base.complete) + acomp_request_complete(req->req, -EINPROGRESS); + break; + case -EBUSY: + goto unlock; + default: + hisi_zip_send_backlog_soft(req->qp_ctx); + goto unlock; + } + } + +unlock: + spin_unlock_bh(&qp->backlog.lock); +} + static u32 hisi_zip_get_status(struct hisi_zip_sqe *sqe) { return sqe->dw3 & HZIP_BD_STATUS_M; @@ -344,75 +427,101 @@ static void hisi_zip_acomp_cb(struct hisi_qp *qp, void *data) err = -EIO; } - hisi_acc_sg_buf_unmap(dev, acomp_req->dst, req->hw_dst, DMA_FROM_DEVICE); - hisi_acc_sg_buf_unmap(dev, acomp_req->src, req->hw_src, DMA_TO_DEVICE); + hisi_zip_unmap_req_buffers(req); acomp_req->dlen = ops->get_dstlen(sqe); + hisi_zip_remove_req(req); if (acomp_req->base.complete) acomp_request_complete(acomp_req, err); - hisi_zip_remove_req(qp_ctx, req); + hisi_zip_send_backlog(qp); } -static int hisi_zip_acompress(struct acomp_req *acomp_req) +static int hisi_zip_do_comp(struct hisi_zip_req *req, bool is_decompress) { + struct acomp_req *acomp_req = req->req; struct hisi_zip_ctx *ctx = crypto_tfm_ctx(acomp_req->base.tfm); - struct hisi_zip_qp_ctx *qp_ctx = &ctx->qp_ctx[HZIP_QPC_COMP]; - struct hisi_zip_req *req; - struct device *dev; + struct hisi_qp *qp = req->qp_ctx->qp; int ret; - if (ctx->fallback) - return hisi_zip_fallback_do_work(ctx->soft_tfm, acomp_req, 0); + if (unlikely(!acomp_req->src || !acomp_req->slen || + !acomp_req->dst || !acomp_req->dlen)) + return -EINVAL; - dev = &qp_ctx->qp->qm->pdev->dev; + if (ctx->fallback) + return hisi_zip_fallback_do_work(ctx->soft_tfm, acomp_req, + is_decompress); + + /* Check whether any request is being queued */ + if ((acomp_req->base.flags & CRYPTO_TFM_REQ_MAY_BACKLOG) && + !list_empty(&qp->backlog.list)) { + req->req_id = HZIP_INVAL_REQ_ID; + hisi_zip_enqueue_backlog(req); + return -EBUSY; + } - req = hisi_zip_create_req(qp_ctx, acomp_req); - if (IS_ERR(req)) - return PTR_ERR(req); + ret = hisi_zip_create_req(req); + if (ret && (acomp_req->base.flags & CRYPTO_TFM_REQ_MAY_BACKLOG)) { + /* all req bitmaps are used add to backlog list */ + req->req_id = HZIP_INVAL_REQ_ID; + hisi_zip_enqueue_backlog(req); + return -EBUSY; + } else if (unlikely(ret)) { + return -ENOSPC; + } - ret = hisi_zip_do_work(qp_ctx, req); - if (unlikely(ret != -EINPROGRESS)) { - dev_info_ratelimited(dev, "failed to do compress (%d)!\n", ret); - hisi_zip_remove_req(qp_ctx, req); + ret = hisi_zip_map_req_buffers(req); + if (unlikely(ret)) + goto remove_req; + + ret = hisi_zip_do_work(req); + if (ret == -EBUSY && (acomp_req->base.flags & CRYPTO_TFM_REQ_MAY_BACKLOG)) { + /* hardwre busy add to backlog list */ + hisi_zip_enqueue_backlog(req); + } else if (unlikely(ret != -EINPROGRESS)) { + dev_info_ratelimited(&qp->qm->pdev->dev, + "failed to do %scompress (%d)!\n", + qp->alg_type ? "de" : "", ret); + ret = -ENOSPC; + goto unmap_req; } return ret; + +unmap_req: + hisi_zip_unmap_req_buffers(req); +remove_req: + hisi_zip_remove_req(req); + return ret; } -static int hisi_zip_adecompress(struct acomp_req *acomp_req) +static int hisi_zip_acompress(struct acomp_req *acomp_req) { struct hisi_zip_ctx *ctx = crypto_tfm_ctx(acomp_req->base.tfm); - struct hisi_zip_qp_ctx *qp_ctx = &ctx->qp_ctx[HZIP_QPC_DECOMP]; - struct hisi_zip_req *req; - struct device *dev; - int ret; - - if (ctx->fallback) - return hisi_zip_fallback_do_work(ctx->soft_tfm, acomp_req, 1); - - dev = &qp_ctx->qp->qm->pdev->dev; + struct hisi_zip_req *req = acomp_request_ctx(acomp_req); - req = hisi_zip_create_req(qp_ctx, acomp_req); - if (IS_ERR(req)) - return PTR_ERR(req); + req->req = acomp_req; + req->qp_ctx = &ctx->qp_ctx[HZIP_QPC_COMP]; + return hisi_zip_do_comp(req, HZIP_ALG_TYPE_COMP); +} - ret = hisi_zip_do_work(qp_ctx, req); - if (unlikely(ret != -EINPROGRESS)) { - dev_info_ratelimited(dev, "failed to do decompress (%d)!\n", - ret); - hisi_zip_remove_req(qp_ctx, req); - } +static int hisi_zip_adecompress(struct acomp_req *acomp_req) +{ + struct hisi_zip_ctx *ctx = crypto_tfm_ctx(acomp_req->base.tfm); + struct hisi_zip_req *req = acomp_request_ctx(acomp_req); - return ret; + req->req = acomp_req; + req->qp_ctx = &ctx->qp_ctx[HZIP_QPC_DECOMP]; + return hisi_zip_do_comp(req, HZIP_ALG_TYPE_DECOMP); } static int hisi_zip_decompress(struct acomp_req *acomp_req) { struct hisi_zip_ctx *ctx = crypto_tfm_ctx(acomp_req->base.tfm); - return hisi_zip_fallback_do_work(ctx->soft_tfm, acomp_req, 1); + return hisi_zip_fallback_do_work(ctx->soft_tfm, acomp_req, + HZIP_ALG_TYPE_DECOMP); } static const struct hisi_zip_sqe_ops hisi_zip_ops = { @@ -476,7 +585,7 @@ static int hisi_zip_create_req_q(struct hisi_zip_ctx *ctx) { u16 q_depth = ctx->qp_ctx[0].qp->sq_depth; struct hisi_zip_req_q *req_q; - int i, ret; + int i; for (i = 0; i < HZIP_CTX_Q_NUM; i++) { req_q = &ctx->qp_ctx[i].req_q; @@ -484,44 +593,21 @@ static int hisi_zip_create_req_q(struct hisi_zip_ctx *ctx) req_q->req_bitmap = bitmap_zalloc(req_q->size, GFP_KERNEL); if (!req_q->req_bitmap) { - ret = -ENOMEM; - if (i == 0) - return ret; - - goto err_free_comp_q; + bitmap_free(ctx->qp_ctx[HZIP_QPC_COMP].req_q.req_bitmap); + return -ENOMEM; } spin_lock_init(&req_q->req_lock); - - req_q->q = kcalloc(req_q->size, sizeof(struct hisi_zip_req), - GFP_KERNEL); - if (!req_q->q) { - ret = -ENOMEM; - if (i == 0) - goto err_free_comp_bitmap; - else - goto err_free_decomp_bitmap; - } } return 0; - -err_free_decomp_bitmap: - bitmap_free(ctx->qp_ctx[HZIP_QPC_DECOMP].req_q.req_bitmap); -err_free_comp_q: - kfree(ctx->qp_ctx[HZIP_QPC_COMP].req_q.q); -err_free_comp_bitmap: - bitmap_free(ctx->qp_ctx[HZIP_QPC_COMP].req_q.req_bitmap); - return ret; } static void hisi_zip_release_req_q(struct hisi_zip_ctx *ctx) { int i; - for (i = 0; i < HZIP_CTX_Q_NUM; i++) { - kfree(ctx->qp_ctx[i].req_q.q); + for (i = 0; i < HZIP_CTX_Q_NUM; i++) bitmap_free(ctx->qp_ctx[i].req_q.req_bitmap); - } } static int hisi_zip_create_sgl_pool(struct hisi_zip_ctx *ctx) @@ -571,7 +657,7 @@ static void hisi_zip_set_acomp_cb(struct hisi_zip_ctx *ctx, static int hisi_zip_fallback_init(struct hisi_zip_ctx *ctx, const char *alg_name) { - if (!IS_ERR_OR_NULL(ctx->soft_tfm)) + if (ctx->soft_tfm) return 0; if (!crypto_has_comp(alg_name, 0, 0)) @@ -580,7 +666,8 @@ static int hisi_zip_fallback_init(struct hisi_zip_ctx *ctx, const char *alg_name ctx->soft_tfm = crypto_alloc_comp(alg_name, 0, 0); if (IS_ERR_OR_NULL(ctx->soft_tfm)) { pr_err("could not alloc soft tfm %s\n", alg_name); - return PTR_ERR(ctx->soft_tfm); + ctx->soft_tfm = NULL; + return -ENOMEM; } return 0; @@ -588,7 +675,7 @@ static int hisi_zip_fallback_init(struct hisi_zip_ctx *ctx, const char *alg_name static void hisi_zip_fallback_uninit(struct hisi_zip_ctx *ctx) { - if (IS_ERR_OR_NULL(ctx->soft_tfm)) + if (!ctx->soft_tfm) return; crypto_free_comp(ctx->soft_tfm); @@ -599,8 +686,10 @@ static int hisi_zip_acomp_init(struct crypto_acomp *tfm) { const char *alg_name = crypto_tfm_alg_name(&tfm->base); struct hisi_zip_ctx *ctx = crypto_tfm_ctx(&tfm->base); + int ret, fallback_err; struct device *dev; - int ret; + + fallback_err = hisi_zip_fallback_init(ctx, alg_name); ret = hisi_zip_ctx_init(ctx, COMP_NAME_TO_TYPE(alg_name), tfm->base.node); if (ret) { @@ -631,8 +720,10 @@ static int hisi_zip_acomp_init(struct crypto_acomp *tfm) err_ctx_exit: hisi_zip_ctx_exit(ctx); switch_to_soft: - ctx->fallback = true; - return hisi_zip_fallback_init(ctx, alg_name); + if (!fallback_err) + ctx->fallback = true; + + return fallback_err; } static int hisi_zip_acomp_init_fb(struct crypto_acomp *tfm) @@ -672,6 +763,7 @@ static struct acomp_alg hisi_zip_acomp_deflate = { .exit = hisi_zip_acomp_exit, .compress = hisi_zip_acompress, .decompress = hisi_zip_adecompress, + .reqsize = sizeof(struct hisi_zip_req), .base = { .cra_name = "deflate", .cra_driver_name = "hisi-deflate-acomp", @@ -710,6 +802,7 @@ static struct acomp_alg hisi_zip_acomp_lz4 = { .exit = hisi_zip_acomp_exit, .compress = hisi_zip_acompress, .decompress = hisi_zip_decompress, + .reqsize = sizeof(struct hisi_zip_req), .base = { .cra_name = "lz4", .cra_driver_name = "hisi-lz4-acomp", -- 2.43.0

1 0