From: Longfang Liu <liulongfang@huawei.com> After the uadk framework updates the heterogeneous scheduling function, the internal implementation functions of the aead algorithm need to be adapted and modified. Signed-off-by: Longfang Liu <liulongfang@huawei.com> --- include/wd_internal.h | 1 + wd_aead.c | 158 ++++++++++++++++++++++-------------------- 2 files changed, 83 insertions(+), 76 deletions(-) diff --git a/include/wd_internal.h b/include/wd_internal.h index 59046ae..a67aaf5 100644 --- a/include/wd_internal.h +++ b/include/wd_internal.h @@ -66,6 +66,7 @@ struct wd_ctx_internal { __u16 sqn; pthread_spinlock_t lock; struct wd_alg_driver *drv; + void *extend_ops; void *drv_priv; }; diff --git a/wd_aead.c b/wd_aead.c index 43bda73..7ef7dca 100644 --- a/wd_aead.c +++ b/wd_aead.c @@ -32,7 +32,6 @@ struct wd_aead_setting { enum wd_status status; struct wd_ctx_config_internal config; struct wd_sched sched; - struct wd_alg_driver *driver; struct wd_async_msg_pool pool; void *priv; void *dlhandle; @@ -76,20 +75,16 @@ static void wd_aead_close_driver(int init_type) } if (wd_aead_setting.dlhandle) { - wd_release_drv(wd_aead_setting.driver); dlclose(wd_aead_setting.dlhandle); wd_aead_setting.dlhandle = NULL; } #else - wd_release_drv(wd_aead_setting.driver); hisi_sec2_remove(); #endif } static int wd_aead_open_driver(int init_type) { - struct wd_alg_driver *driver = NULL; - const char *alg_name = "gcm(aes)"; #ifndef WD_STATIC_DRV char lib_path[PATH_MAX]; int ret; @@ -123,14 +118,6 @@ static int wd_aead_open_driver(int init_type) if (init_type == WD_TYPE_V2) return WD_SUCCESS; #endif - driver = wd_request_drv(alg_name, false); - if (!driver) { - wd_aead_close_driver(WD_TYPE_V1); - WD_ERR("failed to get %s driver support\n", alg_name); - return -WD_EINVAL; - } - - wd_aead_setting.driver = driver; return WD_SUCCESS; } @@ -335,7 +322,7 @@ static struct wd_aead_sess *check_and_init_sess(struct wd_aead_sess_setup *setup sess->dalg = setup->dalg; sess->dmode = setup->dmode; - ret = wd_drv_alg_support(sess->alg_name, wd_aead_setting.driver); + ret = wd_drv_alg_support(sess->alg_name, &wd_aead_setting.config); if (!ret) { WD_ERR("failed to support this algorithm: %s!\n", sess->alg_name); free(sess); @@ -420,18 +407,38 @@ static void cleanup_session(struct wd_aead_sess *sess) static int wd_aead_sess_eops_init(struct wd_aead_sess *sess) { + struct wd_ctx_config_internal *config = &wd_aead_setting.config; + struct wd_aead_extend_ops *eops; + struct wd_alg_driver *drv; int ret; + __u32 i; - if (sess->eops.eops_aiv_init) { - if (!sess->eops.eops_aiv_uninit) { - WD_ERR("failed to get aead extend ops free in session!\n"); - return -WD_EINVAL; - } - ret = sess->eops.eops_aiv_init(wd_aead_setting.driver, &sess->mm_ops, - &sess->eops.params); - if (ret) { - WD_ERR("failed to init aead extend ops params in session!\n"); - return ret; + for (i = 0; i < config->ctx_num; i++) { + drv = config->ctxs[i].drv; + if (!drv->get_extend_ops) + continue; + + ret = drv->get_extend_ops(config->ctxs[i].extend_ops); + if (!ret && config->ctxs[i].extend_ops) { + eops = config->ctxs[i].extend_ops; + + if (!eops->eops_aiv_init) + continue; + + if (!sess->eops.eops_aiv_uninit) { + WD_ERR("failed to get aead extend ops free in session!\n"); + return -WD_EINVAL; + } + ret = sess->eops.eops_aiv_init(drv, &sess->mm_ops, + &sess->eops.params); + if (ret) { + WD_ERR("failed to init aead extend ops params in session!\n"); + return ret; + } + + memcpy(&sess->eops, eops, sizeof(*eops)); + sess->eops.params = drv; + break; } } @@ -440,8 +447,11 @@ static int wd_aead_sess_eops_init(struct wd_aead_sess *sess) static void wd_aead_sess_eops_uninit(struct wd_aead_sess *sess) { + struct wd_alg_driver *drv; + if (sess->eops.eops_aiv_uninit) { - sess->eops.eops_aiv_uninit(wd_aead_setting.driver, &sess->mm_ops, + drv = sess->eops.params; + sess->eops.eops_aiv_uninit(drv, &sess->mm_ops, sess->eops.params); sess->eops.params = NULL; } @@ -461,14 +471,6 @@ handle_t wd_aead_alloc_sess(struct wd_aead_sess_setup *setup) return (handle_t)0; } - if (wd_aead_setting.driver->get_extend_ops) { - ret = wd_aead_setting.driver->get_extend_ops(&sess->eops); - if (ret) { - WD_ERR("failed to get aead sess extend ops!\n"); - goto sess_err; - } - } - ret = wd_aead_sess_eops_init(sess); if (ret) { WD_ERR("failed to init aead sess extend eops!\n"); @@ -603,16 +605,9 @@ static int wd_aead_init_nolock(struct wd_ctx_config *config, struct wd_sched *sc if (ret < 0) goto out_clear_sched; - ret = wd_alg_init_driver(&wd_aead_setting.config, - wd_aead_setting.driver, - &wd_aead_setting.priv); - if (ret) - goto out_clear_pool; - + wd_aead_setting.priv = STATUS_ENABLE; return 0; -out_clear_pool: - wd_uninit_async_request_pool(&wd_aead_setting.pool); out_clear_sched: wd_clear_sched(&wd_aead_setting.sched); out_clear_ctx_config: @@ -621,6 +616,13 @@ out_clear_ctx_config: return ret; } +static void wd_aead_uninit_nolock(void) +{ + wd_uninit_async_request_pool(&wd_aead_setting.pool); + wd_clear_sched(&wd_aead_setting.sched); + wd_aead_setting.priv = NULL; +} + int wd_aead_init(struct wd_ctx_config *config, struct wd_sched *sched) { int ret; @@ -643,10 +645,21 @@ int wd_aead_init(struct wd_ctx_config *config, struct wd_sched *sched) if (ret) goto out_close_driver; + ret = wd_ctx_drv_config("gcm(aes)", &wd_aead_setting.config); + if (ret) + goto out_uninit_nolock; + + ret = wd_alg_init_driver_nw(&wd_aead_setting.config); + if (ret) + goto out_drv_deconfig; wd_alg_set_init(&wd_aead_setting.status); return 0; +out_drv_deconfig: + wd_ctx_drv_deconfig(&wd_aead_setting.config); +out_uninit_nolock: + wd_aead_uninit_nolock(); out_close_driver: wd_aead_close_driver(WD_TYPE_V1); out_clear_init: @@ -654,20 +667,14 @@ out_clear_init: return ret; } -static void wd_aead_uninit_nolock(void) -{ - wd_uninit_async_request_pool(&wd_aead_setting.pool); - wd_clear_sched(&wd_aead_setting.sched); - wd_alg_uninit_driver(&wd_aead_setting.config, - wd_aead_setting.driver, - &wd_aead_setting.priv); -} - void wd_aead_uninit(void) { if (!wd_aead_setting.priv) return; + wd_alg_uninit_driver_nw(&wd_aead_setting.config); + wd_ctx_drv_deconfig(&wd_aead_setting.config); + wd_aead_uninit_nolock(); wd_aead_close_driver(WD_TYPE_V1); wd_alg_clear_init(&wd_aead_setting.status); @@ -717,38 +724,26 @@ int wd_aead_init2_(char *alg, __u32 sched_type, int task_type, while (ret != 0) { memset(&wd_aead_setting.config, 0, sizeof(struct wd_ctx_config_internal)); - - /* Get alg driver and dev name */ - wd_aead_setting.driver = wd_alg_drv_bind(task_type, alg); - if (!wd_aead_setting.driver) { - WD_ERR("failed to bind %s driver.\n", alg); - goto out_dlopen; - } - + /* Init ctx param and prepare for ctx request */ aead_ctx_params.ctx_set_num = aead_ctx_num; - ret = wd_ctx_param_init(&aead_ctx_params, ctx_params, - wd_aead_setting.driver, WD_AEAD_TYPE, - WD_DIGEST_CIPHER_DECRYPTION + 1); + ret = wd_ctx_param_init_nw(&aead_ctx_params, ctx_params, + alg, task_type, WD_AEAD_TYPE, WD_DIGEST_CIPHER_DECRYPTION + 1); if (ret) { if (ret == -WD_EAGAIN) { - wd_disable_drv(wd_aead_setting.driver); - wd_alg_drv_unbind(wd_aead_setting.driver); continue; } - goto out_driver; + goto out_dlclose; } (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.task_type = task_type; wd_aead_init_attrs.ctx_params = &aead_ctx_params; wd_aead_init_attrs.alg_init = wd_aead_init_nolock; wd_aead_init_attrs.alg_poll_ctx = wd_aead_poll_ctx; ret = wd_alg_attrs_init(&wd_aead_init_attrs); if (ret) { if (ret == -WD_ENODEV) { - wd_disable_drv(wd_aead_setting.driver); - wd_alg_drv_unbind(wd_aead_setting.driver); wd_ctx_param_uninit(&aead_ctx_params); continue; } @@ -756,16 +751,27 @@ int wd_aead_init2_(char *alg, __u32 sched_type, int task_type, goto out_params_uninit; } } + ret = wd_ctx_drv_config(alg, &wd_aead_setting.config); + if (ret) + goto out_uninit_nolock; + + ret = wd_alg_init_driver_nw(&wd_aead_setting.config); + if (ret) + goto out_drv_deconfig; + wd_alg_set_init(&wd_aead_setting.status); wd_ctx_param_uninit(&aead_ctx_params); return 0; +out_drv_deconfig: + wd_ctx_drv_deconfig(&wd_aead_setting.config); +out_uninit_nolock: + wd_aead_uninit_nolock(); + wd_alg_attrs_uninit(&wd_aead_init_attrs); out_params_uninit: wd_ctx_param_uninit(&aead_ctx_params); -out_driver: - wd_alg_drv_unbind(wd_aead_setting.driver); -out_dlopen: +out_dlclose: wd_aead_close_driver(WD_TYPE_V2); out_uninit: wd_alg_clear_init(&wd_aead_setting.status); @@ -777,9 +783,9 @@ void wd_aead_uninit2(void) if (!wd_aead_setting.priv) return; + wd_ctx_drv_deconfig(&wd_aead_setting.config); wd_aead_uninit_nolock(); wd_alg_attrs_uninit(&wd_aead_init_attrs); - wd_alg_drv_unbind(wd_aead_setting.driver); wd_aead_close_driver(WD_TYPE_V2); wd_alg_clear_init(&wd_aead_setting.status); } @@ -862,8 +868,8 @@ static int send_recv_sync(struct wd_ctx_internal *ctx, struct wd_msg_handle msg_handle; int ret; - msg_handle.send = wd_aead_setting.driver->send; - msg_handle.recv = wd_aead_setting.driver->recv; + msg_handle.send = ctx->drv->send; + msg_handle.recv = ctx->drv->recv; pthread_spin_lock(&ctx->lock); ret = wd_handle_msg_sync(&msg_handle, ctx->ctx, msg, NULL, @@ -936,13 +942,13 @@ int wd_do_aead_async(handle_t h_sess, struct wd_aead_req *req) idx, (void **)&msg); if (unlikely(msg_id < 0)) { WD_ERR("failed to get msg from pool!\n"); - return msg_id; + return -WD_EBUSY; } fill_request_msg(msg, req, sess); msg->tag = msg_id; - ret = wd_aead_setting.driver->send(ctx->ctx, msg); + ret = ctx->drv->send(ctx->ctx, msg); if (unlikely(ret < 0)) { if (ret != -WD_EBUSY) WD_ERR("failed to send BD, hw is err!\n"); @@ -992,7 +998,7 @@ int wd_aead_poll_ctx(__u32 idx, __u32 expt, __u32 *count) ctx = config->ctxs + idx; do { - ret = wd_aead_setting.driver->recv(ctx->ctx, &resp_msg); + ret = ctx->drv->recv(ctx->ctx, &resp_msg); if (ret == -WD_EAGAIN) { return ret; } else if (ret < 0) { -- 2.43.0