From: Longfang Liu <liulongfang@huawei.com> Unify the software ctx and hardware ctx in uadk and merge them on the scheduler. Realize the function of software and hardware calculation together Signed-off-by: Longfang Liu <liulongfang@huawei.com> --- include/wd.h | 5 - include/wd_alg.h | 35 +- include/wd_alg_common.h | 41 ++- include/wd_internal.h | 23 +- include/wd_sched.h | 1 + include/wd_util.h | 16 +- wd_alg.c | 63 ++-- wd_util.c | 757 ++++++++++++++++++++++++++-------------- 8 files changed, 622 insertions(+), 319 deletions(-) diff --git a/include/wd.h b/include/wd.h index a468047..6329528 100644 --- a/include/wd.h +++ b/include/wd.h @@ -104,11 +104,6 @@ typedef void (*wd_log)(const char *format, ...); #define WD_IS_ERR(h) ((uintptr_t)(h) > \ (uintptr_t)(-1000)) -enum wd_buff_type { - WD_FLAT_BUF, - WD_SGL_BUF, -}; - enum wd_alg_type { WD_CIPHER, WD_DIGEST, diff --git a/include/wd_alg.h b/include/wd_alg.h index 885a5e3..05e022c 100644 --- a/include/wd_alg.h +++ b/include/wd_alg.h @@ -64,14 +64,23 @@ typedef unsigned char __u8; # define HWCAP2_RNG (1 << 16) #endif -enum alg_dev_type { - UADK_ALG_SOFT = 0x0, +enum alg_priority { + UADK_ALG_HW = 0x0, UADK_ALG_CE_INSTR = 0x1, UADK_ALG_SVE_INSTR = 0x2, - UADK_ALG_HW = 0x3 + UADK_ALG_SOFT = 0x3 }; -/* +enum alg_drv_type { + ALG_DRV_HW = 0x0, + ALG_DRV_CE_INS, + ALG_DRV_SVE_INS, + ALG_DRV_SOFT, + ALG_DRV_INS, + ALG_DRV_FB, +}; + +/** * @drv_name: name of the current device driver * @alg_name: name of the algorithm supported by the driver * @priority: priority of the type of algorithm supported by the driver @@ -110,6 +119,7 @@ struct wd_alg_driver { int priv_size; int *drv_data; handle_t fallback; + int init_state; int (*init)(void *conf, void *priv); void (*exit)(void *priv); @@ -134,7 +144,7 @@ struct hisi_dev_usage { int wd_alg_driver_register(struct wd_alg_driver *drv); void wd_alg_driver_unregister(struct wd_alg_driver *drv); -/* +/** * @alg_name: name of the algorithm supported by the driver * @drv_name: name of the current device driver * @available: Indicates whether the current driver still has resources available @@ -158,25 +168,24 @@ struct wd_alg_list { char alg_type[ALG_NAME_SIZE]; }; -/* +/** * wd_request_drv() - Apply for an algorithm driver. * @alg_name: task algorithm name. - * @hw_mask: the flag of shield hardware device drivers. + * @drv_type: the type of shield hardware device drivers. * * Returns the applied algorithm driver, non means error. */ -struct wd_alg_driver *wd_request_drv(const char *alg_name, bool hw_mask); +struct wd_alg_driver *wd_request_drv(const char *alg_name, int drv_type); void wd_release_drv(struct wd_alg_driver *drv); -/* +/** * wd_drv_alg_support() - Check the algorithms supported by the driver. * @alg_name: task algorithm name. - * @drv: a device driver that supports an algorithm. + * @param: a device queue parameters. * * Return check result. */ -bool wd_drv_alg_support(const char *alg_name, - struct wd_alg_driver *drv); +bool wd_drv_alg_support(const char *alg_name, void *param); /* * wd_enable_drv() - Re-enable use of the current device driver. @@ -191,7 +200,7 @@ int wd_get_alg_type(const char *alg_name, char *alg_type); struct wd_alg_list *wd_get_alg_head(void); #ifdef WD_STATIC_DRV -/* +/** * duplicate drivers will be skipped when it register to alg_list */ void hisi_sec2_probe(void); diff --git a/include/wd_alg_common.h b/include/wd_alg_common.h index a294877..0e5523f 100644 --- a/include/wd_alg_common.h +++ b/include/wd_alg_common.h @@ -42,6 +42,13 @@ extern "C" { /* Key size of digest */ #define MAX_HMAC_KEY_SIZE 128U +/* + * The maximum number of queue types + * required for similar algorithms + */ +#define MAX_CTX_OP_TYPE 4U +#define STATUS_ENABLE (void *)0x1 + enum alg_task_type { TASK_MIX = 0x0, TASK_HW, @@ -55,6 +62,11 @@ enum wd_ctx_mode { CTX_MODE_MAX, }; +enum wd_buff_type { + WD_FLAT_BUF, + WD_SGL_BUF, +}; + enum wd_init_type { WD_TYPE_V1, WD_TYPE_V2, @@ -69,7 +81,8 @@ enum wd_mem_type { /* * struct wd_ctx - Define one ctx and related type. - * @ctx: The ctx itself. + * @ctx: The ctx itself, the hardware queue is wd_ctx_h. + * The soft computing queue is wd_soft_ctx. * @op_type: Define the operation type of this specific ctx. * e.g. 0: compression; 1: decompression. * @ctx_mode: Define this ctx is used for synchronization of asynchronization @@ -79,9 +92,10 @@ struct wd_ctx { handle_t ctx; __u8 op_type; __u8 ctx_mode; + __u8 ctx_type; }; -/* +/** * struct wd_cap_config - Capabilities. * @ctx_msg_num: number of asynchronous msg pools that the user wants to allocate. * Optional, user can set ctx_msg_num based on the number of requests @@ -94,7 +108,7 @@ struct wd_cap_config { __u32 resv; }; -/* +/** * struct wd_ctx_config - Define a ctx set and its related attributes, which * will be used in the scope of current process. * @ctx_num: The ctx number in below ctx array. @@ -110,19 +124,34 @@ struct wd_ctx_config { struct wd_cap_config *cap; }; -/* +/* 0x0 mean calloc init value */ +enum wd_ctx_property { + UADK_CTX_HW = 0x0, + UADK_CTX_CE_INS = 0x1, + UADK_CTX_SVE_INS = 0x2, + UADK_CTX_SOFT = 0x3, + UADK_CTX_MAX +}; + +/** * struct wd_ctx_nums - Define the ctx sets numbers. * @sync_ctx_num: The ctx numbers which are used for sync mode for each * ctx sets. * @async_ctx_num: The ctx numbers which are used for async mode for each * ctx sets. + * @ctx_prop: Indicates the properties of the current queue + * @ctx_begin: The encoding starting position of the current device ctx + * @other_ctx: Other types of queues configured */ struct wd_ctx_nums { __u32 sync_ctx_num; __u32 async_ctx_num; + __u8 ctx_prop; + __u16 ctx_begin; + struct wd_ctx_nums *other_ctx; }; -/* +/** * struct wd_ctx_params - Define the ctx sets params which are used for init * algorithms. * @op_type_num: Used for index of ctx_set_num, the order is the same as @@ -140,7 +169,7 @@ struct wd_ctx_params { }; /* - * struct wd_comp_sched - Define a scheduler. + * struct wd_sched - Define a scheduler. * @name: Name of this scheduler. * @sched_policy: Method for scheduler to perform scheduling * @sched_init: inited the scheduler input parameters. diff --git a/include/wd_internal.h b/include/wd_internal.h index d899555..59046ae 100644 --- a/include/wd_internal.h +++ b/include/wd_internal.h @@ -17,6 +17,7 @@ extern "C" { #define DEVICE_REGION_MAX 16 #define DECIMAL_NUMBER 10 #define MAX_FD_NUM 65535 +#define MAX_SOFT_QUEUE_LENGTH 1024U struct wd_ctx_h { int fd; @@ -29,8 +30,24 @@ struct wd_ctx_h { void *priv; }; +struct wd_soft_sqe { + __u8 used; + __u8 result; + __u8 complete; + __u32 id; +}; + +/** + * default queue length set to 1024 + */ struct wd_soft_ctx { int fd; + pthread_spinlock_t slock; + __u32 head; + struct wd_soft_sqe qfifo[MAX_SOFT_QUEUE_LENGTH]; + pthread_spinlock_t rlock; + __u32 tail; + __u32 run_num; void *priv; }; @@ -41,11 +58,15 @@ struct wd_ce_ctx { }; struct wd_ctx_internal { - handle_t ctx; __u8 op_type; __u8 ctx_mode; + __u8 ctx_type; + __u8 ctx_used; + handle_t ctx; // if ctx is first will cause problem __u16 sqn; pthread_spinlock_t lock; + struct wd_alg_driver *drv; + void *drv_priv; }; struct wd_ctx_config_internal { diff --git a/include/wd_sched.h b/include/wd_sched.h index 5baecd3..71949f9 100644 --- a/include/wd_sched.h +++ b/include/wd_sched.h @@ -35,6 +35,7 @@ struct sched_params { __u32 begin; __u32 end; __u32 dev_id; + int ctx_prop; }; typedef int (*user_poll_func)(__u32 pos, __u32 expect, __u32 *count); diff --git a/include/wd_util.h b/include/wd_util.h index 14985e2..3be75d3 100644 --- a/include/wd_util.h +++ b/include/wd_util.h @@ -126,13 +126,14 @@ struct wd_msg_handle { struct wd_init_attrs { __u32 sched_type; + __u32 task_type; char alg[CRYPTO_MAX_ALG_NAME]; - struct wd_alg_driver *driver; struct wd_sched *sched; struct wd_ctx_params *ctx_params; struct wd_ctx_config *ctx_config; wd_alg_init alg_init; wd_alg_poll_ctx alg_poll_ctx; + struct wd_alg_driver *driver; //stub for old code }; /* @@ -173,6 +174,9 @@ void wd_clear_ctx_config(struct wd_ctx_config_internal *in); */ void wd_memset_zero(void *data, __u32 size); +int wd_ctx_drv_config(char *alg_name, struct wd_ctx_config_internal *ctx_config); +void wd_ctx_drv_deconfig(struct wd_ctx_config_internal *ctx_config); + /* * wd_init_async_request_pool() - Init async message pools. * @pool: Pointer of message pool. @@ -452,6 +456,10 @@ static inline void wd_alg_clear_init(enum wd_status *status) * * Return 0 if succeed and other error number if fail. */ +int wd_ctx_param_init_nw(struct wd_ctx_params *ctx_params, + struct wd_ctx_params *user_ctx_params, + char *alg, int task_type, enum wd_type type, + int max_op_type); int wd_ctx_param_init(struct wd_ctx_params *ctx_params, struct wd_ctx_params *user_ctx_params, struct wd_alg_driver *driver, @@ -472,12 +480,12 @@ void wd_alg_attrs_uninit(struct wd_init_attrs *attrs); /** * wd_alg_drv_bind() - Request the ctxs and initialize the sched_domain * with the given devices list, ctxs number and numa mask. - * @task_type: the type of task specified by the current algorithm. + * @ctx_type: the type of ctx specified by the current algorithm. * @alg_name: the name of the algorithm specified by the task. * * Return device driver if succeed and other NULL if fail. */ -struct wd_alg_driver *wd_alg_drv_bind(int task_type, const char *alg_name); +struct wd_alg_driver *wd_alg_drv_bind(__u8 ctx_prop, char *alg_name); void wd_alg_drv_unbind(struct wd_alg_driver *drv); /** @@ -489,6 +497,8 @@ void wd_alg_drv_unbind(struct wd_alg_driver *drv); * * Return 0 if succeed and other error number if fail. */ +int wd_alg_init_driver_nw(struct wd_ctx_config_internal *config); +void wd_alg_uninit_driver_nw(struct wd_ctx_config_internal *config); int wd_alg_init_driver(struct wd_ctx_config_internal *config, struct wd_alg_driver *driver, void **drv_priv); void wd_alg_uninit_driver(struct wd_ctx_config_internal *config, diff --git a/wd_alg.c b/wd_alg.c index a1a0a79..582a4a7 100644 --- a/wd_alg.c +++ b/wd_alg.c @@ -12,7 +12,7 @@ #include <sys/auxv.h> #include "wd.h" -#include "wd_alg.h" +#include "wd_alg_common.h" #define SYS_CLASS_DIR "/sys/class/uacce" #define SVA_FILE_NAME "flags" @@ -337,21 +337,26 @@ struct wd_alg_list *wd_get_alg_head(void) return &alg_list_head; } -bool wd_drv_alg_support(const char *alg_name, - struct wd_alg_driver *drv) +bool wd_drv_alg_support(const char *alg_name, void *param) { + struct wd_ctx_config_internal *config = param; struct wd_alg_list *head = &alg_list_head; struct wd_alg_list *pnext = head->next; + struct wd_alg_driver *drv; + __u32 i; - if (!alg_name || !drv) + if (!alg_name || !config) return false; - while (pnext) { - if (!strcmp(alg_name, pnext->alg_name) && - !strcmp(drv->drv_name, pnext->drv_name)) { - return true; + for (i = 0; i < config->ctx_num; i++) { + drv = config->ctxs[i].drv; + while (pnext) { + if (!strcmp(alg_name, pnext->alg_name) && + !strcmp(drv->drv_name, pnext->drv_name)) { + return true; + } + pnext = pnext->next; } - pnext = pnext->next; } return false; @@ -398,7 +403,7 @@ void wd_disable_drv(struct wd_alg_driver *drv) pthread_mutex_unlock(&mutex); } -struct wd_alg_driver *wd_request_drv(const char *alg_name, bool hw_mask) +struct wd_alg_driver *wd_request_drv(const char *alg_name, int drv_type) { struct wd_alg_list *head = &alg_list_head; struct wd_alg_list *pnext = head->next; @@ -419,18 +424,32 @@ struct wd_alg_driver *wd_request_drv(const char *alg_name, bool hw_mask) /* Check the list to get an best driver */ pthread_mutex_lock(&mutex); while (pnext) { - /* hw_mask true mean not to used hardware dev */ - if ((hw_mask && pnext->drv->calc_type == UADK_ALG_HW) || - (!hw_mask && pnext->drv->calc_type != UADK_ALG_HW)) { - pnext = pnext->next; - continue; - } - - if (!strcmp(alg_name, pnext->alg_name) && pnext->available && - pnext->drv->priority > tmp_priority) { - tmp_priority = pnext->drv->priority; - select_node = pnext; - drv = pnext->drv; + if (!strcmp(alg_name, pnext->alg_name) && pnext->available) { + /* HW driver mean to used hardware dev */ + if (drv_type == ALG_DRV_HW && pnext->drv->calc_type == UADK_ALG_HW) + select_node = pnext; + /* CE driver mean to used CE dev */ + else if (drv_type == ALG_DRV_CE_INS && pnext->drv->calc_type == UADK_ALG_CE_INSTR) + select_node = pnext; + /* SVE driver mean to used SVE dev */ + else if (drv_type == ALG_DRV_SVE_INS && pnext->drv->calc_type == UADK_ALG_SVE_INSTR) + select_node = pnext; + /* INS driver mean to used CE and SVE dev */ + else if (drv_type == ALG_DRV_INS && (pnext->drv->calc_type == UADK_ALG_CE_INSTR || + pnext->drv->calc_type == UADK_ALG_SVE_INSTR)) + select_node = pnext; + /* Soft driver mean to used Soft, CE and SVE dev */ + else if (drv_type == ALG_DRV_SOFT && pnext->drv->calc_type != UADK_ALG_HW) + select_node = pnext; + /* Fallback driver mean to used Soft or CE dev */ + else if (drv_type == ALG_DRV_FB && (pnext->drv->calc_type == UADK_ALG_SOFT || + pnext->drv->calc_type == UADK_ALG_CE_INSTR)) + select_node = pnext; + + if (select_node && select_node->drv->priority > tmp_priority) { + drv = select_node->drv; + tmp_priority = select_node->drv->priority; + } } pnext = pnext->next; } diff --git a/wd_util.c b/wd_util.c index 0dc9a67..a23152c 100644 --- a/wd_util.c +++ b/wd_util.c @@ -216,6 +216,7 @@ static void clone_ctx_to_internal(struct wd_ctx *ctx, ctx_in->ctx = ctx->ctx; ctx_in->op_type = ctx->op_type; ctx_in->ctx_mode = ctx->ctx_mode; + ctx_in->ctx_type = ctx->ctx_type; } static int wd_shm_create(struct wd_ctx_config_internal *in) @@ -285,9 +286,8 @@ int wd_init_ctx_config(struct wd_ctx_config_internal *in, for (i = 0; i < cfg->ctx_num; i++) { if (!cfg->ctxs[i].ctx) { - WD_ERR("invalid: ctx is NULL!\n"); - ret = -WD_EINVAL; - goto err_out; + WD_ERR("invalid: ctx<%u> is NULL!\n", i); + break; } clone_ctx_to_internal(cfg->ctxs + i, ctxs + i); ret = pthread_spin_init(&ctxs[i].lock, PTHREAD_PROCESS_SHARED); @@ -1847,7 +1847,7 @@ int wd_check_ctx(struct wd_ctx_config_internal *config, __u8 mode, __u32 idx) } ctx = config->ctxs + idx; - if (ctx->ctx_mode != mode) { + if (ctx->ctx_type == UADK_CTX_HW && ctx->ctx_mode != mode) { WD_ERR("invalid: ctx(%u) mode is %hhu!\n", idx, ctx->ctx_mode); return -WD_EINVAL; } @@ -1929,18 +1929,50 @@ int wd_handle_msg_sync(struct wd_msg_handle *msg_handle, handle_t ctx, int wd_init_param_check(struct wd_ctx_config *config, struct wd_sched *sched) { if (!config || !config->ctxs || !config->ctxs[0].ctx) { - WD_ERR("invalid: config or config->ctxs is NULL!\n"); + WD_ERR("invalid: wd_ctx_config is NULL!\n"); return -WD_EINVAL; } if (!sched) { - WD_ERR("invalid: sched is NULL!\n"); + WD_ERR("invalid: wd_sched is NULL!\n"); return -WD_EINVAL; } return 0; } +int wd_alg_try_init(enum wd_status *status) +{ + enum wd_status expected; + __u32 count = 0; + bool ret; + + /* + * Here is aimed to protect the security of the initialization interface + * in the multi-thread scenario. Only one thread can get the WD_INITING + * status to initialize algorithm. Other thread will wait for the result. + * And the algorithm initialization interfaces is a liner process. + * So the initing thread will return a result to notify other thread go on. + */ + do { + expected = WD_UNINIT; + ret = __atomic_compare_exchange_n(status, &expected, WD_INITING, true, + __ATOMIC_RELAXED, __ATOMIC_RELAXED); + if (expected == WD_INIT) { + WD_ERR("The algorithm has been initialized!\n"); + return -WD_EEXIST; + } + usleep(WD_INIT_SLEEP_UTIME); + + if (US2S(WD_INIT_SLEEP_UTIME * ++count) >= WD_INIT_RETRY_TIMEOUT) { + WD_ERR("The algorithm initialize wait timeout!\n"); + return -WD_ETIMEDOUT; + } + } while (!ret); + + return 0; +} + static int wd_alg_init_fallback(struct wd_alg_driver *fb_driver) { if (!fb_driver->init) { @@ -1948,6 +1980,7 @@ static int wd_alg_init_fallback(struct wd_alg_driver *fb_driver) return -WD_EINVAL; } + WD_ERR("debug: call function: %s!\n", __func__); fb_driver->init(NULL, NULL); return 0; @@ -1963,12 +1996,20 @@ static void wd_alg_uninit_fallback(struct wd_alg_driver *fb_driver) fb_driver->exit(NULL); } -int wd_alg_init_driver(struct wd_ctx_config_internal *config, - struct wd_alg_driver *driver, void **drv_priv) +static int wd_ctx_init_driver(struct wd_ctx_config_internal *config, + struct wd_ctx_internal *ctx_config) { - void *priv; + struct wd_alg_driver *driver = ctx_config->drv; + void *priv = ctx_config->drv_priv; int ret; + if (!driver) + return 0; + + /* Prevent repeated initialization */ + if (driver->init_state) + return 0; + if (!driver->priv_size) { WD_ERR("invalid: driver priv ctx size is zero!\n"); return -WD_EINVAL; @@ -1985,6 +2026,7 @@ int wd_alg_init_driver(struct wd_ctx_config_internal *config, ret = -WD_EINVAL; goto err_alloc; } + driver->init_state = 1; ret = driver->init(config, priv); if (ret < 0) { @@ -2000,21 +2042,30 @@ int wd_alg_init_driver(struct wd_ctx_config_internal *config, WD_ERR("soft alg driver init failed.\n"); } } - *drv_priv = priv; return 0; err_alloc: free(priv); + ctx_config->drv_priv = NULL; return ret; } -void wd_alg_uninit_driver(struct wd_ctx_config_internal *config, - struct wd_alg_driver *driver, void **drv_priv) +static void wd_ctx_uninit_driver(struct wd_ctx_config_internal *config, + struct wd_ctx_internal *ctx_config) { - void *priv = *drv_priv; + struct wd_alg_driver *driver = ctx_config->drv; + void *priv = ctx_config->drv_priv; + + if (!driver) + return; + + /* Prevent repeated uninitialization */ + if (!driver->init_state) + return; driver->exit(priv); + driver->init_state = 0; /* Ctx config just need clear once */ wd_clear_ctx_config(config); @@ -2024,10 +2075,53 @@ void wd_alg_uninit_driver(struct wd_ctx_config_internal *config, if (priv) { free(priv); driver->drv_data = NULL; - *drv_priv = NULL; + ctx_config->drv_priv = NULL; } } +int wd_alg_init_driver(struct wd_ctx_config_internal *config, + struct wd_alg_driver *driver, void **drv_priv) +{ + return 0; +} + +int wd_alg_init_driver_nw(struct wd_ctx_config_internal *config) +{ + __u32 i, j; + int ret; + + WD_ERR("debug: call function: %s!\n", __func__); + for (i = 0; i < config->ctx_num; i++) { + if (!config->ctxs[i].ctx) + continue; + ret = wd_ctx_init_driver(config, &config->ctxs[i]); + if (ret) + goto init_err; + } + + return 0; + +init_err: + for (j = 0; j < i; j++) + wd_ctx_uninit_driver(config, &config->ctxs[j]); + + return ret; +} + +void wd_alg_uninit_driver(struct wd_ctx_config_internal *config, + struct wd_alg_driver *driver, void **drv_priv) +{ +} + +void wd_alg_uninit_driver_nw(struct wd_ctx_config_internal *config) +{ + __u32 i; + + for (i = 0; i < config->ctx_num; i++) + wd_ctx_uninit_driver(config, &config->ctxs[i]); + +} + void wd_dlclose_drv(void *dlh_list) { struct drv_lib_list *dlhead = (struct drv_lib_list *)dlh_list; @@ -2178,6 +2272,61 @@ int wd_ctx_param_init(struct wd_ctx_params *ctx_params, numa_free_nodemask(ctx_params->bmp); return ret; } + } else { + /* environment variable is not set, try to use user_ctx_params first */ + if (user_ctx_params) { + copy_bitmask_to_bitmask(user_ctx_params->bmp, ctx_params->bmp); + if (user_ctx_params->op_type_num > (__u32)max_op_type) { + WD_ERR("fail to check user op type numbers.\n"); + numa_free_nodemask(ctx_params->bmp); + return -WD_EINVAL; + } + ctx_params->cap = user_ctx_params->cap; + ctx_params->ctx_set_num = user_ctx_params->ctx_set_num; + ctx_params->op_type_num = user_ctx_params->op_type_num; + + return 0; + } + } + + /* user_ctx_params is also not set, use defalut queue_num max_op_type */ + numa_bitmask_setall(ctx_params->bmp); + for (i = 0; i < max_op_type; i++) { + ctx_params->ctx_set_num[i].sync_ctx_num = max_op_type; + ctx_params->ctx_set_num[i].async_ctx_num = max_op_type; + } + + ctx_params->op_type_num = max_op_type; + + return 0; +} + +int wd_ctx_param_init_nw(struct wd_ctx_params *ctx_params, + struct wd_ctx_params *user_ctx_params, + char *alg, int task_type, enum wd_type type, + int max_op_type) +{ + const char *env_name = wd_env_name[type]; + const char *var_s; + int i, ret; + + ctx_params->bmp = numa_allocate_nodemask(); + if (!ctx_params->bmp) { + WD_ERR("fail to allocate nodemask.\n"); + return -WD_ENOMEM; + } + + /* Only hw driver support environment variable */ + var_s = secure_getenv(env_name); + if (var_s && strlen(var_s) && task_type <= TASK_HW) { + /* environment variable has the highest priority */ + ret = wd_env_set_ctx_nums(alg, env_name, var_s, + ctx_params, max_op_type); + if (ret) { + WD_ERR("fail to init ctx nums from %s!\n", env_name); + numa_free_nodemask(ctx_params->bmp); + return ret; + } } else { /* environment variable is not set, try to use user_ctx_params first */ if (user_ctx_params) { @@ -2540,48 +2689,57 @@ free_path: return (void *)head; } -struct wd_alg_driver *wd_alg_drv_bind(int task_type, const char *alg_name) +struct wd_alg_driver *wd_alg_drv_bind(__u8 ctx_prop, char *alg_name) { - struct wd_alg_driver *set_driver = NULL; + struct wd_alg_driver *fb_drv; struct wd_alg_driver *drv; - /* Get alg driver and dev name */ - switch (task_type) { - case TASK_INSTR: - drv = wd_request_drv(alg_name, true); + /* Get alg driver from ctx type and alg name */ + switch (ctx_prop) { + case UADK_CTX_HW: + drv = wd_request_drv(alg_name, ALG_DRV_HW); if (!drv) { - WD_ERR("no soft %s driver support\n", alg_name); + WD_ERR("no HW %s driver support\n", alg_name); return NULL; } - set_driver = drv; - set_driver->fallback = 0; + + fb_drv = wd_request_drv(alg_name, ALG_DRV_SOFT); + if (!fb_drv) + drv->fallback = 0; + else + drv->fallback = (handle_t)fb_drv; + break; - case TASK_HW: - case TASK_MIX: - drv = wd_request_drv(alg_name, false); + case UADK_CTX_CE_INS: + drv = wd_request_drv(alg_name, ALG_DRV_CE_INS); if (!drv) { - WD_ERR("no HW %s driver support\n", alg_name); + WD_ERR("no CE instr soft %s driver support\n", alg_name); return NULL; } - set_driver = drv; - set_driver->fallback = 0; - if (task_type == TASK_MIX) { - drv = wd_request_drv(alg_name, true); - if (!drv) { - set_driver->fallback = 0; - WD_ERR("no soft %s driver support\n", alg_name); - } else { - set_driver->fallback = (handle_t)drv; - WD_ERR("successful to get soft driver\n"); - } + drv->fallback = 0; + break; + case UADK_CTX_SVE_INS: + drv = wd_request_drv(alg_name, ALG_DRV_SVE_INS); + if (!drv) { + WD_ERR("no SVE instr soft %s driver support\n", alg_name); + return NULL; } + drv->fallback = 0; + break; + case UADK_CTX_SOFT: + drv = wd_request_drv(alg_name, ALG_DRV_SOFT); + if (!drv) { + WD_ERR("no instr soft %s driver support\n", alg_name); + return NULL; + } + drv->fallback = 0; break; default: - WD_ERR("task type error.\n"); - return NULL; + WD_ERR("ctx type error: %d.\n", ctx_prop); + return WD_ERR_PTR(-WD_ENODEV); } - return set_driver; + return drv; } void wd_alg_drv_unbind(struct wd_alg_driver *drv) @@ -2597,45 +2755,100 @@ void wd_alg_drv_unbind(struct wd_alg_driver *drv) wd_release_drv(drv); } -int wd_alg_try_init(enum wd_status *status) +static __u32 wd_ctxs_idx_init(struct wd_init_attrs *attrs, int numa_cnt, int task_type) { - enum wd_status expected; + struct wd_ctx_params *ctx_params = attrs->ctx_params; + int end = ctx_params->op_type_num; + struct wd_ctx_nums *ptr_ctx; __u32 count = 0; - bool ret; + int i, uidx; - do { - expected = WD_UNINIT; - ret = __atomic_compare_exchange_n(status, &expected, WD_INITING, true, - __ATOMIC_RELAXED, __ATOMIC_RELAXED); - if (expected == WD_INIT) { - WD_ERR("The algorithm has been initialized!\n"); - return -WD_EEXIST; - } - usleep(WD_INIT_SLEEP_UTIME); + if (ctx_params->op_type_num > MAX_CTX_OP_TYPE) { + WD_ERR("invalid: max ctx op type<%u> is wrong!\n", ctx_params->op_type_num); + return 0; + } - if (US2S(WD_INIT_SLEEP_UTIME * ++count) >= WD_INIT_RETRY_TIMEOUT) { - WD_ERR("The algorithm initialize wait timeout!\n"); - return -WD_ETIMEDOUT; + for (uidx = 0; uidx < UADK_CTX_MAX; uidx++) { + /* If it is a soft computing task, do not use HW queue */ + if (task_type == TASK_INSTR && uidx == UADK_CTX_HW) + continue; + for (i = 0; i < end; i++) { + ptr_ctx = &ctx_params->ctx_set_num[i]; + while (ptr_ctx) { + if (ptr_ctx->ctx_prop == uidx) { + ptr_ctx->ctx_begin = count; + if (uidx == UADK_CTX_HW) { + count += ptr_ctx->sync_ctx_num * numa_cnt; + count += ptr_ctx->async_ctx_num * numa_cnt; + } else { + count += ptr_ctx->sync_ctx_num; + count += ptr_ctx->async_ctx_num; + } + WD_ERR("optype<%d>, prop<%u>, begin<%u>, synx<%u>, async<%u>\n", + i, ptr_ctx->ctx_prop, ptr_ctx->ctx_begin, ptr_ctx->sync_ctx_num, ptr_ctx->async_ctx_num); + } + ptr_ctx = ptr_ctx->other_ctx; + } } - } while (!ret); + } - return 0; + return count; } -static __u32 wd_get_ctx_numbers(struct wd_ctx_params ctx_params, int end) +static struct wd_ctx_nums *wd_get_ctx_ptr(struct wd_ctx_params *ctx_params, + __u32 op_type, int ctx_prop) { - __u32 count = 0; - int i; + struct wd_ctx_nums *ptr_ctx; + + if (op_type > ctx_params->op_type_num) + return NULL; - for (i = 0; i < end; i++) { - count += ctx_params.ctx_set_num[i].sync_ctx_num; - count += ctx_params.ctx_set_num[i].async_ctx_num; + ptr_ctx = &ctx_params->ctx_set_num[op_type]; + while (ptr_ctx) { + if (ptr_ctx->ctx_prop == ctx_prop) + return ptr_ctx; + ptr_ctx = ptr_ctx->other_ctx; } - return count; + return NULL; +} + +void wd_ctx_drv_deconfig(struct wd_ctx_config_internal *ctx_config) +{ + __u32 i; + + // wd_dlclose_drv after this + for (i = 0; i < ctx_config->ctx_num; i++) + wd_alg_drv_unbind(ctx_config->ctxs[i].drv); + +} + +int wd_ctx_drv_config(char *alg_name, struct wd_ctx_config_internal *ctx_config) +{ + __u32 i, j; + + // wd_dlopen_drv before this + WD_ERR("debug: call function: %s!\n", __func__); + for (i = 0; i < ctx_config->ctx_num; i++) { + ctx_config->ctxs[i].drv = wd_alg_drv_bind(ctx_config->ctxs[i].ctx_type, alg_name); + if (WD_IS_ERR(ctx_config->ctxs[i].drv)) { + continue; + } else if (!ctx_config->ctxs[i].drv) { + WD_ERR("failed to bind %s driver.\n", alg_name); + goto bind_err; + } + } + + return 0; + +bind_err: + for (j = 0; j < i; j++) { + wd_alg_drv_unbind(ctx_config->ctxs[j].drv); + } + return -WD_EINVAL; } -static struct uacce_dev_list *wd_get_usable_list(struct uacce_dev_list *list, struct bitmask *bmp) +struct uacce_dev_list *wd_get_usable_list(struct uacce_dev_list *list, struct bitmask *bmp) { struct uacce_dev_list *p, *node, *result = NULL; struct uacce_dev *dev; @@ -2685,7 +2898,7 @@ out_free_list: return result; } -static int wd_init_ctx_set(struct wd_init_attrs *attrs, struct uacce_dev_list *list, +static int wd_init_hw_ctx_set(struct wd_init_attrs *attrs, struct uacce_dev_list *list, __u32 idx, int numa_id, __u32 op_type) { struct wd_ctx_nums ctx_nums = attrs->ctx_params->ctx_set_num[op_type]; @@ -2729,6 +2942,7 @@ static int wd_init_ctx_set(struct wd_init_attrs *attrs, struct uacce_dev_list *l ctx_config->ctxs[i].ctx_mode = ((i - idx) < ctx_nums.sync_ctx_num) ? CTX_MODE_SYNC : CTX_MODE_ASYNC; + ctx_config->ctxs[i].ctx_type = UADK_CTX_HW; } return 0; @@ -2762,6 +2976,7 @@ static int wd_instance_sched_set(struct wd_init_attrs *attrs, struct wd_ctx_nums sparams.dev_id = dev_id; sparams.mode = i; sparams.begin = idx + ctx_nums.sync_ctx_num * i; + sparams.ctx_prop = UADK_CTX_HW; end = idx - 1 + ctx_nums.sync_ctx_num + ctx_nums.async_ctx_num * i; if (end < 0 || sparams.begin > (__u32)end) continue; @@ -2776,7 +2991,7 @@ out: return ret; } -static int wd_init_ctx_and_sched(struct wd_init_attrs *attrs, struct bitmask *bmp, +static int wd_hw_ctx_and_sched(struct wd_init_attrs *attrs, struct bitmask *bmp, struct uacce_dev_list *list) { struct wd_ctx_params *ctx_params = attrs->ctx_params; @@ -2790,7 +3005,7 @@ static int wd_init_ctx_and_sched(struct wd_init_attrs *attrs, struct bitmask *bm continue; for (j = 0; j < op_type_num; j++) { ctx_nums = ctx_params->ctx_set_num[j]; - ret = wd_init_ctx_set(attrs, list, idx, i, j); + ret = wd_init_hw_ctx_set(attrs, list, idx, i, j); if (ret == -WD_ENOPROC) continue; else if (ret) @@ -2821,30 +3036,118 @@ static void wd_init_device_nodemask(struct uacce_dev_list *list, struct bitmask } } -static int wd_alg_ctx_init(struct wd_init_attrs *attrs) +static int wd_alg_other_ctx_init(struct wd_init_attrs *attrs, int ctx_prop) +{ + struct wd_ctx_config *ctx_config = attrs->ctx_config; + struct wd_ctx_params *ctx_params = attrs->ctx_params; + struct wd_ctx_nums *ptr_ctxs; + struct wd_soft_ctx *sfctx; + struct sched_params sparams; + __u32 begin, end, ctx_num; + int sync_type, ret; + __u32 i, j, k; + + WD_ERR("debug: call function: %s!\n", __func__); + for (i = 0; i < ctx_params->op_type_num; i++) { + ptr_ctxs = wd_get_ctx_ptr(ctx_params, i, ctx_prop); + if (!ptr_ctxs) + continue; + + for (sync_type = CTX_MODE_SYNC; sync_type < CTX_MODE_MAX; sync_type++) { + if (sync_type == CTX_MODE_SYNC) { + ctx_num = ptr_ctxs->sync_ctx_num; + begin = ptr_ctxs->ctx_begin; + } else { + ctx_num = ptr_ctxs->async_ctx_num; + begin = ptr_ctxs->ctx_begin + ptr_ctxs->sync_ctx_num; + } + if (ctx_num == 0) + continue; + + end = begin + ctx_num; + for (j = begin; j < end; j++) { + ctx_config->ctxs[j].op_type = i; + ctx_config->ctxs[j].ctx_mode = sync_type; + ctx_config->ctxs[j].ctx_type = ctx_prop; + sfctx = calloc(1, sizeof(struct wd_soft_ctx)); + if (!sfctx) { + WD_ERR("failed to alloc ctx!\n"); + goto ctx_err; + } + ctx_config->ctxs[j].ctx = (handle_t)sfctx; + pthread_spin_init(&sfctx->slock, PTHREAD_PROCESS_SHARED); + pthread_spin_init(&sfctx->rlock, PTHREAD_PROCESS_SHARED); + } + + memset(&sparams, 0x0, sizeof(struct sched_params)); + sparams.begin = begin; + sparams.end = end - 1; + sparams.mode = sync_type; + sparams.numa_id = 0; + sparams.ctx_prop = ctx_prop; + ret = wd_sched_rr_instance(attrs->sched, &sparams); + if (ret) { + WD_ERR("fail to instance scheduler.\n"); + goto ctx_err; + } + } + } + + return WD_SUCCESS; + +ctx_err: + for (k = j; k >= begin; k--) { + free((struct wd_soft_ctx *)ctx_config->ctxs[k].ctx); + ctx_config->ctxs[k].ctx = 0; + } + + return -WD_ENOMEM; +} + +static int wd_alg_other_init(struct wd_init_attrs *attrs) +{ + struct wd_ctx_config *ctx_config = attrs->ctx_config; + struct wd_ctx_params *ctx_params = attrs->ctx_params; + __u32 ctx_set_num, op_type_num; + + WD_ERR("debug: call function: %s!\n", __func__); + op_type_num = ctx_params->op_type_num; + ctx_set_num = wd_ctxs_idx_init(attrs, 1, attrs->task_type); + if (!ctx_set_num || !op_type_num) { + WD_ERR("invalid: ctx_set_num is %u, op_type_num is %u!\n", + ctx_set_num, op_type_num); + return -WD_EINVAL; + } + + ctx_config->ctx_num = ctx_set_num; + ctx_config->ctxs = calloc(ctx_config->ctx_num, sizeof(struct wd_ctx)); + if (!ctx_config->ctxs) { + WD_ERR("failed to alloc ctxs!\n"); + return -WD_ENOMEM; + } + + return 0; +} + +static int wd_alg_hw_ctx_init(struct wd_init_attrs *attrs) { struct wd_ctx_config *ctx_config = attrs->ctx_config; struct wd_ctx_params *ctx_params = attrs->ctx_params; struct bitmask *used_bmp = ctx_params->bmp; struct uacce_dev_list *list, *used_list = NULL; + char alg_type[CRYPTO_MAX_ALG_NAME]; __u32 ctx_set_num, op_type_num; int numa_cnt, ret; - list = wd_get_accel_list(attrs->alg); + WD_ERR("debug: call function: %s!\n", __func__); + wd_get_alg_type(attrs->alg, alg_type); + + list = wd_get_accel_list(alg_type); if (!list) { WD_ERR("failed to get devices for alg: %s\n", attrs->alg); return -WD_ENODEV; } - op_type_num = ctx_params->op_type_num; - ctx_set_num = wd_get_ctx_numbers(*ctx_params, op_type_num); - if (!ctx_set_num || !op_type_num) { - WD_ERR("invalid: ctx_set_num is %u, op_type_num is %u!\n", - ctx_set_num, op_type_num); - ret = -WD_EINVAL; - goto out_freelist; - } - /* * Not every numa has a device. Therefore, the first thing is to * filter the devices in the selected numa node, and the second @@ -2858,7 +3161,6 @@ static int wd_alg_ctx_init(struct wd_init_attrs *attrs) } wd_init_device_nodemask(used_list, used_bmp); - numa_cnt = numa_bitmask_weight(used_bmp); if (!numa_cnt) { ret = numa_cnt; @@ -2866,7 +3168,17 @@ static int wd_alg_ctx_init(struct wd_init_attrs *attrs) goto out_freeusedlist; } - ctx_config->ctx_num = ctx_set_num * numa_cnt; + op_type_num = ctx_params->op_type_num; + ctx_set_num = wd_ctxs_idx_init(attrs, numa_cnt, attrs->task_type); + WD_ERR("ctx sum num is: %u, op_type num is: %u!\n", ctx_set_num, op_type_num); + if (!ctx_set_num || !op_type_num) { + WD_ERR("invalid: ctx_set_num is %u, op_type_num is %u!\n", + ctx_set_num, op_type_num); + ret = -WD_EINVAL; + goto out_freelist; + } + + ctx_config->ctx_num = ctx_set_num; ctx_config->ctxs = calloc(ctx_config->ctx_num, sizeof(struct wd_ctx)); if (!ctx_config->ctxs) { ret = -WD_ENOMEM; @@ -2874,7 +3186,7 @@ static int wd_alg_ctx_init(struct wd_init_attrs *attrs) goto out_freeusedlist; } - ret = wd_init_ctx_and_sched(attrs, used_bmp, used_list); + ret = wd_hw_ctx_and_sched(attrs, used_bmp, used_list); if (ret) free(ctx_config->ctxs); @@ -2886,224 +3198,145 @@ out_freelist: return ret; } -static int wd_alg_ce_ctx_init(struct wd_init_attrs *attrs) -{ - struct wd_ctx_config *ctx_config = attrs->ctx_config; - struct wd_ce_ctx *ctx; - - ctx_config->ctx_num = 1; - ctx_config->ctxs = calloc(ctx_config->ctx_num, sizeof(struct wd_ctx)); - if (!ctx_config->ctxs) { - WD_ERR("failed to alloc ctxs!\n"); - return -WD_ENOMEM; - } - - ctx = calloc(1, sizeof(struct wd_ce_ctx)); - if (!ctx) { - free(ctx_config->ctxs); - return -WD_ENOMEM; - } - ctx->fd = -1; - ctx_config->ctxs[0].ctx = (handle_t)ctx; - - return WD_SUCCESS; -} - -static void wd_alg_ce_ctx_uninit(struct wd_ctx_config *ctx_config) +static void wd_alg_ctxs_uninit(struct wd_ctx_config *ctx_config) { __u32 i; for (i = 0; i < ctx_config->ctx_num; i++) { if (ctx_config->ctxs[i].ctx) { - free((struct wd_ce_ctx *)ctx_config->ctxs[i].ctx); + if (ctx_config->ctxs[i].ctx_type == UADK_CTX_HW) + wd_release_ctx(ctx_config->ctxs[i].ctx); + else + free((struct wd_soft_ctx *)ctx_config->ctxs[i].ctx); ctx_config->ctxs[i].ctx = 0; } } - free(ctx_config->ctxs); -} - -static void wd_alg_ctx_uninit(struct wd_ctx_config *ctx_config) -{ - __u32 i; - - for (i = 0; i < ctx_config->ctx_num; i++) { - if (ctx_config->ctxs[i].ctx) { - wd_release_ctx(ctx_config->ctxs[i].ctx); - ctx_config->ctxs[i].ctx = 0; - } + if (ctx_config->ctxs) { + free(ctx_config->ctxs); + ctx_config->ctxs = 0; } - - free(ctx_config->ctxs); -} - -static int wd_alg_init_sve_ctx(struct wd_ctx_config *ctx_config) -{ - struct wd_soft_ctx *ctx_sync, *ctx_async; - - ctx_config->ctx_num = WD_SOFT_CTX_NUM; - ctx_config->ctxs = calloc(ctx_config->ctx_num, sizeof(struct wd_ctx)); - if (!ctx_config->ctxs) - return -WD_ENOMEM; - - ctx_sync = calloc(1, sizeof(struct wd_soft_ctx)); - if (!ctx_sync) - goto free_ctxs; - - ctx_sync->fd = -1; - ctx_config->ctxs[WD_SOFT_SYNC_CTX].op_type = 0; - ctx_config->ctxs[WD_SOFT_SYNC_CTX].ctx_mode = CTX_MODE_SYNC; - ctx_config->ctxs[WD_SOFT_SYNC_CTX].ctx = (handle_t)ctx_sync; - - ctx_async = calloc(1, sizeof(struct wd_soft_ctx)); - if (!ctx_async) - goto free_ctx_sync; - - ctx_async->fd = -1; - ctx_config->ctxs[WD_SOFT_ASYNC_CTX].op_type = 0; - ctx_config->ctxs[WD_SOFT_ASYNC_CTX].ctx_mode = CTX_MODE_ASYNC; - ctx_config->ctxs[WD_SOFT_ASYNC_CTX].ctx = (handle_t)ctx_async; - - return 0; - -free_ctx_sync: - free(ctx_sync); -free_ctxs: - free(ctx_config->ctxs); - return -WD_ENOMEM; -} - -static void wd_alg_uninit_sve_ctx(struct wd_ctx_config *ctx_config) -{ - free((struct wd_soft_ctx *)ctx_config->ctxs[WD_SOFT_ASYNC_CTX].ctx); - free((struct wd_soft_ctx *)ctx_config->ctxs[WD_SOFT_SYNC_CTX].ctx); - free(ctx_config->ctxs); } int wd_alg_attrs_init(struct wd_init_attrs *attrs) { wd_alg_poll_ctx alg_poll_func = attrs->alg_poll_ctx; wd_alg_init alg_init_func = attrs->alg_init; - __u32 sched_type = attrs->sched_type; struct wd_ctx_config *ctx_config = NULL; struct wd_sched *alg_sched = NULL; - char alg_type[CRYPTO_MAX_ALG_NAME]; - int driver_type = UADK_ALG_HW; - const char *alg = attrs->alg; - int ret = -WD_EINVAL; + struct wd_alg_driver *drv = NULL; + char *alg_name = attrs->alg; + __u32 op_type_num; + int ret = 0; if (!attrs->ctx_params) return -WD_EINVAL; - if (attrs->driver) - driver_type = attrs->driver->calc_type; - - switch (driver_type) { - case UADK_ALG_SOFT: - case UADK_ALG_CE_INSTR: - ctx_config = calloc(1, sizeof(*ctx_config)); - if (!ctx_config) { - WD_ERR("fail to alloc ctx config\n"); - return -WD_ENOMEM; - } - attrs->ctx_config = ctx_config; + WD_ERR("debug: call function: %s!\n", __func__); + ctx_config = calloc(1, sizeof(*ctx_config)); + if (!ctx_config) { + WD_ERR("fail to alloc ctx config\n"); + return -WD_ENOMEM; + } + attrs->ctx_config = ctx_config; - /* Use default sched_type to alloc scheduler */ - alg_sched = wd_sched_rr_alloc(SCHED_POLICY_NONE, 1, 1, alg_poll_func); - if (!alg_sched) { - WD_ERR("fail to alloc scheduler\n"); - goto out_ctx_config; - } + /* Get op_type_num */ + op_type_num = attrs->ctx_params->op_type_num; + if (!op_type_num) + goto out_ctx_config; - attrs->sched = alg_sched; + /* Use default sched_type to alloc scheduler */ + if (attrs->sched_type == SCHED_POLICY_DEV) + alg_sched = wd_sched_rr_alloc(attrs->sched_type, attrs->ctx_params->op_type_num, + DEVICE_REGION_MAX, alg_poll_func); + else + alg_sched = wd_sched_rr_alloc(attrs->sched_type, attrs->ctx_params->op_type_num, + numa_max_node() + 1, alg_poll_func); + if (!alg_sched) { + WD_ERR("fail to alloc scheduler\n"); + goto out_ctx_config; + } + attrs->sched = alg_sched; - ret = wd_alg_ce_ctx_init(attrs); + /* Initialize queues according to task type */ + switch (attrs->task_type) { + case TASK_HW: + ret = wd_alg_hw_ctx_init(attrs); if (ret) { - WD_ERR("fail to init ce ctx\n"); + WD_ERR("fail to init HW ctx\n"); goto out_freesched; } - ret = alg_init_func(ctx_config, alg_sched); - if (ret) - goto out_pre_init; - break; - case UADK_ALG_SVE_INSTR: - /* Use default sched_type to alloc scheduler */ - alg_sched = wd_sched_rr_alloc(SCHED_POLICY_SINGLE, 1, 1, alg_poll_func); - if (!alg_sched) { - WD_ERR("fail to alloc scheduler\n"); - return -WD_EINVAL; - } - attrs->sched = alg_sched; - - ctx_config = calloc(1, sizeof(*ctx_config)); - if (!ctx_config) { - WD_ERR("fail to alloc ctx config\n"); - goto out_freesched; - } - attrs->ctx_config = ctx_config; - - ret = wd_alg_init_sve_ctx(ctx_config); - if (ret) { - WD_ERR("fail to init sve ctx!\n"); - goto out_freesched; - } - - ctx_config->cap = attrs->ctx_params->cap; - ret = alg_init_func(ctx_config, alg_sched); + case TASK_MIX: + ret = wd_alg_hw_ctx_init(attrs); if (ret) { - wd_alg_uninit_sve_ctx(ctx_config); + WD_ERR("fail to init mix HW ctx\n"); goto out_freesched; } - break; - case UADK_ALG_HW: - if (wd_get_alg_type(alg, alg_type)) - return -WD_EINVAL; - (void)strcpy(attrs->alg, alg_type); - - ctx_config = calloc(1, sizeof(*ctx_config)); - if (!ctx_config) { - WD_ERR("fail to alloc ctx config\n"); - return -WD_ENOMEM; - } - attrs->ctx_config = ctx_config; - if (sched_type == SCHED_POLICY_DEV) - alg_sched = wd_sched_rr_alloc(sched_type, attrs->ctx_params->op_type_num, - DEVICE_REGION_MAX, alg_poll_func); - else - alg_sched = wd_sched_rr_alloc(sched_type, attrs->ctx_params->op_type_num, - numa_max_node() + 1, alg_poll_func); - if (!alg_sched) { - WD_ERR("fail to instance scheduler\n"); - goto out_ctx_config; + WD_ERR("debug: call function: %s!\n", __func__); + drv = wd_request_drv(alg_name, ALG_DRV_SOFT); + if (drv == NULL) { + WD_ERR("fail to find soft driver.\n"); + break; + } else if (drv->calc_type == UADK_ALG_CE_INSTR) { + ret = wd_alg_other_ctx_init(attrs, UADK_CTX_CE_INS); + if (ret) { + WD_ERR("fail to init ce ctx\n"); + goto out_ctx_init; + } + } else if (drv->calc_type == UADK_ALG_SVE_INSTR) { + ret = wd_alg_other_ctx_init(attrs, UADK_CTX_SVE_INS); + if (ret) { + WD_ERR("fail to init sve ctx\n"); + goto out_ctx_init; + } } - attrs->sched = alg_sched; - ret = wd_alg_ctx_init(attrs); + break; + /* Only pure soft queues */ + case TASK_INSTR: + ret = wd_alg_other_init(attrs); if (ret) { - WD_ERR("fail to init ctx\n"); + WD_ERR("fail to init other ctx.\n"); goto out_freesched; } - ctx_config->cap = attrs->ctx_params->cap; - ret = alg_init_func(ctx_config, alg_sched); - if (ret) - goto out_pre_init; + drv = wd_request_drv(alg_name, ALG_DRV_SOFT); + if (drv == NULL) { + WD_ERR("fail to find soft driver.\n"); + goto out_ctx_init; + } else if (drv->calc_type == UADK_ALG_CE_INSTR) { + ret = wd_alg_other_ctx_init(attrs, UADK_CTX_CE_INS); + if (ret) { + WD_ERR("fail to init ce ctx\n"); + goto out_ctx_init; + } + } else if (drv->calc_type == UADK_ALG_SVE_INSTR) { + ret = wd_alg_other_ctx_init(attrs, UADK_CTX_SVE_INS); + if (ret) { + WD_ERR("fail to init sve ctx\n"); + goto out_ctx_init; + } + } break; default: - WD_ERR("driver type error: %d\n", driver_type); + WD_ERR("driver type error: %d\n", drv->calc_type); return -WD_EINVAL; } + ctx_config->cap = attrs->ctx_params->cap; + ret = alg_init_func(ctx_config, alg_sched); + if (ret) + goto out_ctx_init; + + WD_ERR("---->ctx nums: %u\n", ctx_config->ctx_num); + return 0; -out_pre_init: - if (driver_type == UADK_ALG_CE_INSTR || driver_type == UADK_ALG_SOFT) - wd_alg_ce_ctx_uninit(ctx_config); - else - wd_alg_ctx_uninit(ctx_config); +out_ctx_init: + wd_alg_ctxs_uninit(ctx_config); out_freesched: wd_sched_rr_release(alg_sched); out_ctx_config: @@ -3116,27 +3349,13 @@ void wd_alg_attrs_uninit(struct wd_init_attrs *attrs) { struct wd_ctx_config *ctx_config = attrs->ctx_config; struct wd_sched *alg_sched = attrs->sched; - int driver_type = attrs->driver->calc_type; if (!ctx_config) { wd_sched_rr_release(alg_sched); return; } - switch (driver_type) { - case UADK_ALG_SOFT: - case UADK_ALG_CE_INSTR: - wd_alg_ce_ctx_uninit(ctx_config); - break; - case UADK_ALG_SVE_INSTR: - wd_alg_uninit_sve_ctx(ctx_config); - break; - case UADK_ALG_HW: - wd_alg_ctx_uninit(ctx_config); - break; - default: - break; - } + wd_alg_ctxs_uninit(ctx_config); free(ctx_config); wd_sched_rr_release(alg_sched); -- 2.43.0

From: Longfang Liu <liulongfang@huawei.com> After adapting the new heterogeneous hybrid acceleration function. The initialization of the device driver requires adaptation updates. In addition, the instruction acceleration algorithm driver needs to fully adapt to the synchronous and asynchronous mode of the uadk framework. Signed-off-by: Longfang Liu <liulongfang@huawei.com> --- Makefile.am | 2 +- drv/hisi_comp.c | 3 ++ drv/hisi_dae_common.c | 3 ++ drv/hisi_hpre.c | 65 +++++++++++-------------------------- drv/hisi_sec.c | 3 ++ drv/hisi_udma.c | 3 ++ drv/isa_ce_sm3.c | 18 +++++++++- drv/isa_ce_sm4.c | 19 ++++++++++- include/drv/wd_digest_drv.h | 2 ++ include/drv/wd_ecc_drv.h | 2 +- include/wd_util.h | 4 +++ wd_ecc.c | 3 +- wd_util.c | 64 ++++++++++++++++++++++++++++++++++++ 13 files changed, 139 insertions(+), 52 deletions(-) diff --git a/Makefile.am b/Makefile.am index b38c5ce..e59fdb9 100644 --- a/Makefile.am +++ b/Makefile.am @@ -101,7 +101,7 @@ libhisi_hpre_la_SOURCES=drv/hisi_hpre.c drv/hisi_qm_udrv.c \ if ARCH_ARM64 libisa_ce_la_SOURCES=arm_arch_ce.h drv/isa_ce_sm3.c drv/isa_ce_sm3_armv8.S isa_ce_sm3.h \ - drv/isa_ce_sm4.c drv/isa_ce_sm4_armv8.S drv/isa_ce_sm4.h + drv/isa_ce_sm4.c drv/isa_ce_sm4_armv8.S drv/isa_ce_sm4.h wd_util.c wd_util.h libisa_sve_la_SOURCES=drv/hash_mb/hash_mb.c wd_digest_drv.h drv/hash_mb/hash_mb.h \ drv/hash_mb/sm3_sve_common.S drv/hash_mb/sm3_mb_asimd_x1.S \ diff --git a/drv/hisi_comp.c b/drv/hisi_comp.c index be16b83..50643d0 100644 --- a/drv/hisi_comp.c +++ b/drv/hisi_comp.c @@ -1431,6 +1431,9 @@ static int hisi_zip_init(void *conf, void *priv) memcpy(&zip_ctx->config, config, sizeof(struct wd_ctx_config_internal)); /* allocate qp for each context */ for (i = 0; i < config->ctx_num; i++) { + if (config->ctxs[i].ctx_type != UADK_CTX_HW || + !config->ctxs[i].ctx) + continue; h_ctx = config->ctxs[i].ctx; qm_priv.sqe_size = sizeof(struct hisi_zip_sqe); qm_priv.op_type = config->ctxs[i].op_type; diff --git a/drv/hisi_dae_common.c b/drv/hisi_dae_common.c index 216e424..74dc84f 100644 --- a/drv/hisi_dae_common.c +++ b/drv/hisi_dae_common.c @@ -327,6 +327,9 @@ int dae_init(void *conf, void *priv) qm_priv.sqe_size = sizeof(struct dae_sqe); /* Allocate qp for each context */ for (i = 0; i < config->ctx_num; i++) { + if (config->ctxs[i].ctx_type != UADK_CTX_HW || + !config->ctxs[i].ctx) + continue; h_ctx = config->ctxs[i].ctx; qm_priv.qp_mode = config->ctxs[i].ctx_mode; /* Setting the epoll en to 0 for ASYNC ctx */ diff --git a/drv/hisi_hpre.c b/drv/hisi_hpre.c index 7da8407..d8f3b53 100644 --- a/drv/hisi_hpre.c +++ b/drv/hisi_hpre.c @@ -133,9 +133,6 @@ struct hisi_hpre_ctx { struct wd_ctx_config_internal config; struct wd_mm_ops *mm_ops; handle_t rsv_mem_ctx; -}; - -struct hpre_ecc_ctx { __u32 enable_hpcore; }; @@ -656,6 +653,9 @@ static int hpre_init_qm_priv(struct wd_ctx_config_internal *config, qm_priv->sqe_size = sizeof(struct hisi_hpre_sqe); for (i = 0; i < config->ctx_num; i++) { + if (config->ctxs[i].ctx_type != UADK_CTX_HW || + !config->ctxs[i].ctx) + continue; h_ctx = config->ctxs[i].ctx; qm_priv->qp_mode = config->ctxs[i].ctx_mode; /* Setting the epoll en to 0 for ASYNC ctx */ @@ -1577,7 +1577,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; + struct hisi_hpre_ctx *hpre_ctx = (struct hisi_hpre_ctx *)msg->drv_cfg; int ret = -WD_EINVAL; switch (msg->req.op_type) { @@ -1590,11 +1590,11 @@ static int ecc_prepare_in(struct wd_ecc_msg *msg, ret = ecc_prepare_dh_gen_in(msg, hw_msg, data); break; case WD_ECXDH_GEN_KEY: - hw_msg->bd_rsv2 = ecc_ctx->enable_hpcore; + hw_msg->bd_rsv2 = hpre_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; + hw_msg->bd_rsv2 = hpre_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)) @@ -2817,39 +2817,6 @@ static int hpre_rsa_get_usage(void *param) return -WD_EACCES; } -static int ecc_sess_eops_init(struct wd_alg_driver *drv, 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(struct wd_alg_driver *drv, void *params) -{ - if (!params) { - WD_ERR("invalid: extend ops uninit params is NULL!\n"); - return; - } - - free(params); -} - static bool is_valid_hw_type(void *drv_priv) { struct hisi_hpre_ctx *hpre_ctx; @@ -2866,21 +2833,27 @@ static bool is_valid_hw_type(void *drv_priv) } static void ecc_sess_eops_params_cfg(struct wd_ecc_sess_setup *setup, - struct wd_ecc_curve *cv, void *drv_priv, void *params) + struct wd_ecc_curve *cv, void *priv) { __u8 data[SECP256R1_PARAM_SIZE] = SECG_P256_R1_PARAM; - struct hpre_ecc_ctx *ecc_ctx = params; + struct hisi_hpre_ctx *hpre_ctx; + struct hisi_qp *qp; __u32 key_size; int ret; - if (!is_valid_hw_type(drv_priv)) + if (unlikely(!priv)) return; - if (!ecc_ctx) { + hpre_ctx = (struct hisi_hpre_ctx *)priv; + if (!hpre_ctx) { WD_INFO("Info: eops config exits, but params is NULL!\n"); return; } + 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; + if (strcmp(setup->alg, "ecdh")) return; @@ -2890,7 +2863,7 @@ static void ecc_sess_eops_params_cfg(struct wd_ecc_sess_setup *setup, ret = memcmp(data, cv->p.data, SECP256R1_PARAM_SIZE); if (!ret) - ecc_ctx->enable_hpcore = 1; + hpre_ctx->enable_hpcore = 1; } static int hpre_ecc_get_extend_ops(void *ops) @@ -2901,9 +2874,9 @@ static int hpre_ecc_get_extend_ops(void *ops) return -WD_EINVAL; ecc_ops->params = NULL; - ecc_ops->sess_init = ecc_sess_eops_init; + ecc_ops->sess_init = NULL; ecc_ops->eops_params_cfg = ecc_sess_eops_params_cfg; - ecc_ops->sess_uninit = ecc_sess_eops_uninit; + ecc_ops->sess_uninit = NULL; return WD_SUCCESS; } diff --git a/drv/hisi_sec.c b/drv/hisi_sec.c index fb9de2c..c2f73b1 100644 --- a/drv/hisi_sec.c +++ b/drv/hisi_sec.c @@ -3906,6 +3906,9 @@ static int hisi_sec_init(void *conf, void *priv) qm_priv.sqe_size = sizeof(struct hisi_sec_sqe); /* allocate qp for each context */ for (i = 0; i < config->ctx_num; i++) { + if (config->ctxs[i].ctx_type != UADK_CTX_HW || + !config->ctxs[i].ctx) + continue; h_ctx = config->ctxs[i].ctx; /* setting the type is 0 for sqc_type */ qm_priv.op_type = 0; diff --git a/drv/hisi_udma.c b/drv/hisi_udma.c index 5c8a743..62b83e7 100644 --- a/drv/hisi_udma.c +++ b/drv/hisi_udma.c @@ -461,6 +461,9 @@ static int udma_init(void *conf, void *priv) qm_priv.sqe_size = sizeof(struct udma_sqe); /* Allocate qp for each context */ for (i = 0; i < config->ctx_num; i++) { + if (config->ctxs[i].ctx_type != UADK_CTX_HW || + !config->ctxs[i].ctx) + continue; h_ctx = config->ctxs[i].ctx; qm_priv.qp_mode = config->ctxs[i].ctx_mode; /* Setting the epoll en to 0 for ASYNC ctx */ diff --git a/drv/isa_ce_sm3.c b/drv/isa_ce_sm3.c index 0ebaba5..9dbd0a8 100644 --- a/drv/isa_ce_sm3.c +++ b/drv/isa_ce_sm3.c @@ -17,7 +17,6 @@ #include "drv/isa_ce_sm3.h" #include "drv/wd_digest_drv.h" #include "wd_digest.h" -#include "wd_util.h" #define SM3_ALIGN_MASK 63U @@ -338,6 +337,7 @@ static int do_hmac_sm3_ce(struct wd_digest_msg *msg, __u8 *out_hmac) static int sm3_ce_drv_send(handle_t ctx, void *digest_msg) { + struct wd_soft_ctx *sfctx = (struct wd_soft_ctx *)ctx; struct wd_digest_msg *msg = (struct wd_digest_msg *)digest_msg; __u8 digest[SM3_DIGEST_SIZE] = {0}; int ret; @@ -347,6 +347,10 @@ static int sm3_ce_drv_send(handle_t ctx, void *digest_msg) return -WD_EINVAL; } + ret = wd_queue_is_busy(sfctx); + if (ret) + return ret; + if (msg->data_fmt == WD_SGL_BUF) { WD_ERR("invalid: SM3 CE driver do not support sgl data format!\n"); return -WD_EINVAL; @@ -368,11 +372,23 @@ static int sm3_ce_drv_send(handle_t ctx, void *digest_msg) ret = -WD_EINVAL; } + ret = wd_get_sqe_from_queue(sfctx, msg->tag); + if (ret) + return ret; + return ret; } static int sm3_ce_drv_recv(handle_t ctx, void *digest_msg) { + struct wd_soft_ctx *sfctx = (struct wd_soft_ctx *)ctx; + struct wd_digest_msg *msg = (struct wd_digest_msg *)digest_msg; + int ret; + + ret = wd_put_sqe_to_queue(sfctx, &msg->tag, &msg->result); + if (ret) + return ret; + return WD_SUCCESS; } diff --git a/drv/isa_ce_sm4.c b/drv/isa_ce_sm4.c index 504ef73..4c42693 100644 --- a/drv/isa_ce_sm4.c +++ b/drv/isa_ce_sm4.c @@ -324,15 +324,20 @@ static int sm4_xts_decrypt(struct wd_cipher_msg *msg, const struct SM4_KEY *rkey static int isa_ce_cipher_send(handle_t ctx, void *wd_msg) { + struct wd_soft_ctx *sfctx = (struct wd_soft_ctx *)ctx; struct wd_cipher_msg *msg = wd_msg; struct SM4_KEY rkey; int ret = 0; - if (!msg) { + if (!msg || !ctx) { WD_ERR("invalid: input sm4 msg is NULL!\n"); return -WD_EINVAL; } + ret = wd_queue_is_busy(sfctx); + if (ret) + return ret; + if (msg->data_fmt == WD_SGL_BUF) { WD_ERR("invalid: SM4 CE driver do not support sgl data format!\n"); return -WD_EINVAL; @@ -385,11 +390,23 @@ static int isa_ce_cipher_send(handle_t ctx, void *wd_msg) return -WD_EINVAL; } + ret = wd_get_sqe_from_queue(sfctx, msg->tag); + if (ret) + return ret; + return ret; } static int isa_ce_cipher_recv(handle_t ctx, void *wd_msg) { + struct wd_soft_ctx *sfctx = (struct wd_soft_ctx *)ctx; + struct wd_cipher_msg *msg = wd_msg; + int ret; + + ret = wd_put_sqe_to_queue(sfctx, &msg->tag, &msg->result); + if (ret) + return ret; + return 0; } diff --git a/include/drv/wd_digest_drv.h b/include/drv/wd_digest_drv.h index 12398f2..2711ab1 100644 --- a/include/drv/wd_digest_drv.h +++ b/include/drv/wd_digest_drv.h @@ -3,6 +3,8 @@ #ifndef __WD_DIGEST_DRV_H #define __WD_DIGEST_DRV_H +#include <asm/types.h> + #include "../wd_digest.h" #include "../wd_util.h" diff --git a/include/drv/wd_ecc_drv.h b/include/drv/wd_ecc_drv.h index 98ff28c..899f593 100644 --- a/include/drv/wd_ecc_drv.h +++ b/include/drv/wd_ecc_drv.h @@ -182,7 +182,7 @@ 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 *drv_priv, void *params); + struct wd_ecc_curve *cv, void *priv); int (*sess_init)(struct wd_alg_driver *drv, void **params); void (*sess_uninit)(struct wd_alg_driver *drv, void *params); }; diff --git a/include/wd_util.h b/include/wd_util.h index 3be75d3..f226122 100644 --- a/include/wd_util.h +++ b/include/wd_util.h @@ -565,6 +565,10 @@ static inline void wd_ctx_spin_unlock(struct wd_ctx_internal *ctx, int type) int wd_mem_ops_init(handle_t h_ctx, struct wd_mm_ops *mm_ops, int mem_type); +int wd_queue_is_busy(struct wd_soft_ctx *sctx); +int wd_get_sqe_from_queue(struct wd_soft_ctx *sctx, __u32 tag_id); +int wd_put_sqe_to_queue(struct wd_soft_ctx *sctx, __u32 *tag_id, __u8 *result); + #ifdef __cplusplus } #endif diff --git a/wd_ecc.c b/wd_ecc.c index 900f36c..b7e5481 100644 --- a/wd_ecc.c +++ b/wd_ecc.c @@ -1205,8 +1205,7 @@ 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, - wd_ecc_setting.priv, sess->eops.params); + sess->eops.eops_params_cfg(setup, sess->key.cv, wd_ecc_setting.priv); } } diff --git a/wd_util.c b/wd_util.c index 8e8260e..19bfcce 100644 --- a/wd_util.c +++ b/wd_util.c @@ -3363,3 +3363,67 @@ void wd_alg_attrs_uninit(struct wd_init_attrs *attrs) free(ctx_config); wd_sched_rr_release(alg_sched); } + +int wd_queue_is_busy(struct wd_soft_ctx *sctx) +{ + /* The queue is not used */ + if (sctx->run_num >= MAX_SOFT_QUEUE_LENGTH - 1) + return -WD_EBUSY; + + return 0; +} + +int wd_get_sqe_from_queue(struct wd_soft_ctx *sctx, __u32 tag_id) +{ + struct wd_soft_sqe *sqe = NULL; + + pthread_spin_lock(&sctx->slock); + sqe = &sctx->qfifo[sctx->head]; + if (!sqe->used && !sqe->complete) { // find the next not used sqe + sctx->head++; + if (unlikely(sctx->head == MAX_SOFT_QUEUE_LENGTH)) + sctx->head = 0; + + sqe->used = 1; + sqe->complete = 1; + sqe->id = tag_id; + sqe->result = 0; + __atomic_fetch_add(&sctx->run_num, 0x1, __ATOMIC_ACQUIRE); + pthread_spin_unlock(&sctx->slock); + } else { + pthread_spin_unlock(&sctx->slock); + return -WD_EBUSY; + } + + return 0; +} + +int wd_put_sqe_to_queue(struct wd_soft_ctx *sctx, __u32 *tag_id, __u8 *result) +{ + struct wd_soft_sqe *sqe = NULL; + + /* The queue is not used */ + if (sctx->run_num < 1) + return -WD_EAGAIN; + + if (pthread_spin_trylock(&sctx->rlock)) + return -WD_EAGAIN; + sqe = &sctx->qfifo[sctx->tail]; + if (sqe->used && sqe->complete) { // find a used sqe + sctx->tail++; + if (unlikely(sctx->tail == MAX_SOFT_QUEUE_LENGTH)) + sctx->tail = 0; + + *tag_id = sqe->id; + *result = sqe->result; + sqe->used = 0x0; + sqe->complete = 0x0; + __atomic_fetch_sub(&sctx->run_num, 0x1, __ATOMIC_ACQUIRE); + pthread_spin_unlock(&sctx->rlock); + } else { + pthread_spin_unlock(&sctx->rlock); + return -WD_EAGAIN; + } + + return 0; +} -- 2.43.0

From: Longfang Liu <liulongfang@huawei.com> After the uadk framework updates the heterogeneous scheduling function, the internal implementation functions of the hash-agg algorithm need to be adapted and modified. Signed-off-by: Longfang Liu <liulongfang@huawei.com> --- wd_agg.c | 173 +++++++++++++++++++++++++++++++++---------------------- 1 file changed, 103 insertions(+), 70 deletions(-) diff --git a/wd_agg.c b/wd_agg.c index 66e9e0f..ebc6e31 100644 --- a/wd_agg.c +++ b/wd_agg.c @@ -32,7 +32,6 @@ struct wd_agg_setting { struct wd_ctx_config_internal config; struct wd_sched sched; struct wd_async_msg_pool pool; - struct wd_alg_driver *driver; void *priv; void *dlhandle; void *dlh_list; @@ -78,7 +77,6 @@ static void wd_agg_close_driver(void) wd_dlclose_drv(wd_agg_setting.dlh_list); wd_agg_setting.dlh_list = NULL; #else - wd_release_drv(wd_agg_setting.driver); hisi_dae_remove(); #endif } @@ -354,29 +352,71 @@ out_key: static int wd_agg_init_sess_priv(struct wd_agg_sess *sess, struct wd_agg_sess_setup *setup) { - int ret; + struct wd_ctx_config_internal *config = &wd_agg_setting.config; + struct wd_alg_driver *drv; + struct wd_agg_ops *eops; + int ret, valid = 0; + __u32 i; - if (sess->ops.sess_init) { - if (!sess->ops.sess_uninit) { - WD_ERR("failed to get session uninit ops!\n"); - return -WD_EINVAL; - } - ret = sess->ops.sess_init(setup, &sess->priv); - if (ret) { - WD_ERR("failed to init session priv!\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) { + valid++; + eops = config->ctxs[i].extend_ops; + + if (eops->sess_init) { + if (!eops->sess_uninit) { + WD_ERR("failed to get session uninit ops!\n"); + return -WD_EINVAL; + } + ret = eops->sess_init(setup, &sess->priv); + if (ret) { + WD_ERR("failed to init session priv!\n"); + return ret; + } + } + + if (eops->get_row_size) { + ret = eops->get_row_size(drv, sess->priv); + if (ret <= 0) { + if (eops->sess_uninit) + eops->sess_uninit(drv, sess->priv); + WD_ERR("failed to get hash table row size: %d!\n", ret); + return ret; + } + /* This needs to be executed only once. */ + sess->hash_table.table_row_size = ret; + } } } - if (sess->ops.get_row_size) { - ret = sess->ops.get_row_size(wd_agg_setting.driver, sess->priv); - if (ret <= 0) { - 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 -WD_EINVAL; - } - sess->hash_table.table_row_size = ret; + if (!valid) { + WD_ERR("failed to get agg extend ops!\n"); + return -WD_EINVAL; + } + + return WD_SUCCESS; +} + +static int wd_agg_uninit_sess_priv(struct wd_agg_sess *sess) +{ + struct wd_ctx_config_internal *config = &wd_agg_setting.config; + struct wd_agg_ops *eops; + __u32 i; + int ret; + + for (i = 0; i < config->ctx_num; i++) { + /* At this point, extends_ops has completed its initialization. */ + eops = config->ctxs[i].extend_ops; + if (!eops) + continue; + + if (eops->sess_uninit) + eops->sess_uninit(config->ctxs[i].drv, sess->priv); } return WD_SUCCESS; @@ -401,7 +441,7 @@ handle_t wd_agg_alloc_sess(struct wd_agg_sess_setup *setup) sess->agg_conf.out_cols_num = out_agg_cols_num; sess->alg_name = wd_agg_alg_name; - ret = wd_drv_alg_support(sess->alg_name, wd_agg_setting.driver); + ret = wd_drv_alg_support(sess->alg_name, &wd_agg_setting.config); if (!ret) { WD_ERR("failed to support agg algorithm: %s!\n", sess->alg_name); goto free_sess; @@ -415,14 +455,6 @@ handle_t wd_agg_alloc_sess(struct wd_agg_sess_setup *setup) goto free_sess; } - if (wd_agg_setting.driver->get_extend_ops) { - ret = wd_agg_setting.driver->get_extend_ops(&sess->ops); - if (ret) { - WD_ERR("failed to get agg extend ops!\n"); - goto free_key; - } - } - ret = wd_agg_init_sess_priv(sess, setup); if (ret) goto free_key; @@ -436,8 +468,7 @@ handle_t wd_agg_alloc_sess(struct wd_agg_sess_setup *setup) return (handle_t)sess; uninit_priv: - if (sess->ops.sess_uninit) - sess->ops.sess_uninit(wd_agg_setting.driver, sess->priv); + wd_agg_uninit_sess_priv(sess); free_key: free(sess->sched_key); free_sess: @@ -458,8 +489,7 @@ void wd_agg_free_sess(handle_t h_sess) free(sess->agg_conf.cols_info); free(sess->key_conf.data_size); - if (sess->ops.sess_uninit) - sess->ops.sess_uninit(wd_agg_setting.driver, sess->priv); + wd_agg_uninit_sess_priv(sess); if (sess->sched_key) free(sess->sched_key); @@ -509,8 +539,11 @@ static int wd_agg_check_sess_state(struct wd_agg_sess *sess, enum wd_agg_sess_st int wd_agg_set_hash_table(handle_t h_sess, struct wd_dae_hash_table *info) { struct wd_agg_sess *sess = (struct wd_agg_sess *)h_sess; + struct wd_ctx_config_internal *config = &wd_agg_setting.config; struct wd_dae_hash_table *hash_table, *rehash_table; enum wd_agg_sess_state expected; + struct wd_agg_ops *eops; + __u32 i; int ret; if (!sess || !info) { @@ -551,17 +584,23 @@ int wd_agg_set_hash_table(handle_t h_sess, struct wd_dae_hash_table *info) memcpy(rehash_table, hash_table, sizeof(struct wd_dae_hash_table)); memcpy(hash_table, info, sizeof(struct wd_dae_hash_table)); - if (sess->ops.hash_table_init) { - ret = sess->ops.hash_table_init(wd_agg_setting.driver, hash_table, sess->priv); - if (ret) { + for (i = 0; i < config->ctx_num; i++) { + /* At this point, extends_ops has completed its initialization process. */ + eops = config->ctxs[i].extend_ops; + if (!eops) + continue; + + /* Any single execution successful, exit immediately. */ + if (eops->hash_table_init) { + ret = eops->hash_table_init(config->ctxs[i].drv, hash_table, sess->priv); + if (!ret) + return WD_SUCCESS; + memcpy(hash_table, rehash_table, sizeof(struct wd_dae_hash_table)); memset(rehash_table, 0, sizeof(struct wd_dae_hash_table)); - goto out; } } - return WD_SUCCESS; - out: __atomic_store_n(&sess->state, expected, __ATOMIC_RELEASE); return ret; @@ -595,15 +634,10 @@ static int wd_agg_alg_init(struct wd_ctx_config *config, struct wd_sched *sched) if (ret < 0) goto out_clear_sched; - ret = wd_alg_init_driver(&wd_agg_setting.config, wd_agg_setting.driver, - &wd_agg_setting.priv); - if (ret) - goto out_clear_pool; + wd_agg_setting.priv = STATUS_ENABLE; return WD_SUCCESS; -out_clear_pool: - wd_uninit_async_request_pool(&wd_agg_setting.pool); out_clear_sched: wd_clear_sched(&wd_agg_setting.sched); out_clear_ctx_config: @@ -621,12 +655,9 @@ static int wd_agg_alg_uninit(void) /* Uninit async request pool */ wd_uninit_async_request_pool(&wd_agg_setting.pool); - /* Unset config, sched, driver */ wd_clear_sched(&wd_agg_setting.sched); - - wd_alg_uninit_driver(&wd_agg_setting.config, wd_agg_setting.driver, - &wd_agg_setting.priv); + wd_agg_setting.priv = NULL; return WD_SUCCESS; } @@ -664,20 +695,12 @@ int wd_agg_init(char *alg, __u32 sched_type, int task_type, struct wd_ctx_params while (ret != 0) { memset(&wd_agg_setting.config, 0, sizeof(struct wd_ctx_config_internal)); - /* Get alg driver and dev name */ - wd_agg_setting.driver = wd_alg_drv_bind(task_type, alg); - if (!wd_agg_setting.driver) { - WD_ERR("failed to bind %s driver.\n", alg); - goto out_dlopen; - } - + /* Init ctx param and prepare for ctx request */ agg_ctx_params.ctx_set_num = &agg_ctx_num; - ret = wd_ctx_param_init(&agg_ctx_params, ctx_params, wd_agg_setting.driver, + ret = wd_ctx_param_init_nw(&agg_ctx_params, ctx_params, alg, task_type, WD_AGG_TYPE, 1); if (ret) { if (ret == -WD_EAGAIN) { - wd_disable_drv(wd_agg_setting.driver); - wd_alg_drv_unbind(wd_agg_setting.driver); continue; } goto out_driver; @@ -685,15 +708,13 @@ int wd_agg_init(char *alg, __u32 sched_type, int task_type, struct wd_ctx_params (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.task_type = task_type; wd_agg_init_attrs.ctx_params = &agg_ctx_params; wd_agg_init_attrs.alg_init = wd_agg_alg_init; wd_agg_init_attrs.alg_poll_ctx = wd_agg_poll_ctx; ret = wd_alg_attrs_init(&wd_agg_init_attrs); if (ret) { if (ret == -WD_ENODEV) { - wd_disable_drv(wd_agg_setting.driver); - wd_alg_drv_unbind(wd_agg_setting.driver); wd_ctx_param_uninit(&agg_ctx_params); continue; } @@ -701,17 +722,27 @@ int wd_agg_init(char *alg, __u32 sched_type, int task_type, struct wd_ctx_params goto out_params_uninit; } } + ret = wd_ctx_drv_config(alg, &wd_agg_setting.config); + if (ret) + goto out_uninit_nolock; + + ret = wd_alg_init_driver_nw(&wd_agg_setting.config); + if (ret) + goto out_drv_deconfig; wd_alg_set_init(&wd_agg_setting.status); wd_ctx_param_uninit(&agg_ctx_params); return WD_SUCCESS; +out_drv_deconfig: + wd_ctx_drv_deconfig(&wd_agg_setting.config); +out_uninit_nolock: + wd_agg_alg_uninit(); + wd_alg_attrs_uninit(&wd_agg_init_attrs); out_params_uninit: wd_ctx_param_uninit(&agg_ctx_params); out_driver: - wd_alg_drv_unbind(wd_agg_setting.driver); -out_dlopen: wd_agg_close_driver(); out_uninit: wd_alg_clear_init(&wd_agg_setting.status); @@ -726,8 +757,10 @@ void wd_agg_uninit(void) if (ret) return; + wd_alg_uninit_driver_nw(&wd_agg_setting.config); + wd_ctx_drv_deconfig(&wd_agg_setting.config); wd_alg_attrs_uninit(&wd_agg_init_attrs); - wd_alg_drv_unbind(wd_agg_setting.driver); + wd_agg_close_driver(); wd_alg_clear_init(&wd_agg_setting.status); } @@ -1099,8 +1132,8 @@ static int wd_agg_sync_job(struct wd_agg_sess *sess, struct wd_agg_req *req, wd_dfx_msg_cnt(config, WD_CTX_CNT_NUM, idx); ctx = config->ctxs + idx; - msg_handle.send = wd_agg_setting.driver->send; - msg_handle.recv = wd_agg_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, config->epoll_en); @@ -1204,7 +1237,7 @@ static int wd_agg_async_job(struct wd_agg_sess *sess, struct wd_agg_req *req, bo else fill_request_msg_output(msg, req, sess, false); msg->tag = msg_id; - ret = wd_agg_setting.driver->send(ctx->ctx, msg); + ret = ctx->drv->send(ctx->ctx, msg); if (unlikely(ret < 0)) { if (ret != -WD_EBUSY) WD_ERR("wd agg async send err!\n"); @@ -1543,7 +1576,7 @@ static int wd_agg_poll_ctx(__u32 idx, __u32 expt, __u32 *count) ctx = config->ctxs + idx; do { - ret = wd_agg_setting.driver->recv(ctx->ctx, &resp_msg); + ret = ctx->drv->recv(ctx->ctx, &resp_msg); if (ret == -WD_EAGAIN) { return ret; } else if (unlikely(ret < 0)) { -- 2.43.0

From: Longfang Liu <liulongfang@huawei.com> After the uadk framework updates the heterogeneous scheduling function, the internal implementation functions of the comp algorithm need to be adapted and modified. Signed-off-by: Longfang Liu <liulongfang@huawei.com> --- include/drv/wd_comp_drv.h | 1 + include/wd_comp.h | 3 +- wd_comp.c | 91 ++++++++++++++++++--------------------- 3 files changed, 46 insertions(+), 49 deletions(-) diff --git a/include/drv/wd_comp_drv.h b/include/drv/wd_comp_drv.h index 2311d79..93df870 100644 --- a/include/drv/wd_comp_drv.h +++ b/include/drv/wd_comp_drv.h @@ -7,6 +7,7 @@ #include <pthread.h> #include <linux/types.h> +#include "../wd_alg_common.h" #include "../wd_comp.h" #include "../wd_util.h" diff --git a/include/wd_comp.h b/include/wd_comp.h index 5d09536..8579f93 100644 --- a/include/wd_comp.h +++ b/include/wd_comp.h @@ -135,7 +135,8 @@ void wd_comp_uninit(void); * * Return 0 if succeed and others if fail. */ -int wd_comp_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_params *ctx_params); +int wd_comp_init2_(const char *alg, __u32 sched_type, int task_type, + struct wd_ctx_params *ctx_params); #define wd_comp_init2(alg, sched_type, task_type) \ wd_comp_init2_(alg, sched_type, task_type, NULL) diff --git a/wd_comp.c b/wd_comp.c index be08ee8..596979b 100644 --- a/wd_comp.c +++ b/wd_comp.c @@ -50,7 +50,6 @@ struct wd_comp_setting { struct wd_ctx_config_internal config; struct wd_sched sched; struct wd_async_msg_pool pool; - struct wd_alg_driver *driver; void *priv; void *dlhandle; void *dlh_list; @@ -69,20 +68,16 @@ static void wd_comp_close_driver(int init_type) } if (wd_comp_setting.dlhandle) { - wd_release_drv(wd_comp_setting.driver); dlclose(wd_comp_setting.dlhandle); wd_comp_setting.dlhandle = NULL; } #else - wd_release_drv(wd_comp_setting.driver); hisi_zip_remove(); #endif } static int wd_comp_open_driver(int init_type) { - struct wd_alg_driver *driver = NULL; - const char *alg_name = "zlib"; #ifndef WD_STATIC_DRV char lib_path[PATH_MAX]; int ret; @@ -116,14 +111,6 @@ static int wd_comp_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_comp_close_driver(WD_TYPE_V1); - WD_ERR("failed to get %s driver support\n", alg_name); - return -WD_EINVAL; - } - - wd_comp_setting.driver = driver; return WD_SUCCESS; } @@ -152,8 +139,7 @@ static int wd_comp_init_nolock(struct wd_ctx_config *config, struct wd_sched *sc { int ret; - ret = wd_set_epoll_en("WD_COMP_EPOLL_EN", - &wd_comp_setting.config.epoll_en); + ret = wd_set_epoll_en("WD_COMP_EPOLL_EN", &wd_comp_setting.config.epoll_en); if (ret < 0) return ret; @@ -172,16 +158,10 @@ static int wd_comp_init_nolock(struct wd_ctx_config *config, struct wd_sched *sc if (ret < 0) goto out_clear_sched; - ret = wd_alg_init_driver(&wd_comp_setting.config, - wd_comp_setting.driver, - &wd_comp_setting.priv); - if (ret) - goto out_clear_pool; + wd_comp_setting.priv = STATUS_ENABLE; return 0; -out_clear_pool: - wd_uninit_async_request_pool(&wd_comp_setting.pool); out_clear_sched: wd_clear_sched(&wd_comp_setting.sched); out_clear_ctx_config: @@ -202,9 +182,7 @@ static int wd_comp_uninit_nolock(void) /* Unset config, sched, driver */ wd_clear_sched(&wd_comp_setting.sched); - wd_alg_uninit_driver(&wd_comp_setting.config, - wd_comp_setting.driver, - &wd_comp_setting.priv); + wd_comp_setting.priv = NULL; return 0; } @@ -231,10 +209,22 @@ int wd_comp_init(struct wd_ctx_config *config, struct wd_sched *sched) if (ret) goto out_clear_driver; + ret = wd_ctx_drv_config("zlib", &wd_comp_setting.config); + if (ret) + goto out_uninit_nolock; + + ret = wd_alg_init_driver_nw(&wd_comp_setting.config); + if (ret) + goto out_drv_deconfig; + wd_alg_set_init(&wd_comp_setting.status); return 0; +out_drv_deconfig: + wd_ctx_drv_deconfig(&wd_comp_setting.config); +out_uninit_nolock: + wd_comp_uninit_nolock(); out_clear_driver: wd_comp_close_driver(WD_TYPE_V1); out_clear_init: @@ -246,6 +236,9 @@ void wd_comp_uninit(void) { int ret; + wd_alg_uninit_driver_nw(&wd_comp_setting.config); + wd_ctx_drv_deconfig(&wd_comp_setting.config); + ret = wd_comp_uninit_nolock(); if (ret) return; @@ -254,7 +247,8 @@ void wd_comp_uninit(void) wd_alg_clear_init(&wd_comp_setting.status); } -int wd_comp_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_params *ctx_params) +int wd_comp_init2_(const char *alg, __u32 sched_type, int task_type, + struct wd_ctx_params *ctx_params) { struct wd_ctx_nums comp_ctx_num[WD_DIR_MAX] = {0}; struct wd_ctx_params comp_ctx_params = {0}; @@ -286,36 +280,26 @@ int wd_comp_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_par while (ret != 0) { memset(&wd_comp_setting.config, 0, sizeof(struct wd_ctx_config_internal)); - /* Get alg driver and dev name */ - wd_comp_setting.driver = wd_alg_drv_bind(task_type, alg); - if (!wd_comp_setting.driver) { - WD_ERR("failed to bind %s driver.\n", alg); - goto out_dlclose; - } - + /* Init ctx param and prepare for ctx request */ comp_ctx_params.ctx_set_num = comp_ctx_num; - ret = wd_ctx_param_init(&comp_ctx_params, ctx_params, - wd_comp_setting.driver, WD_COMP_TYPE, WD_DIR_MAX); + ret = wd_ctx_param_init_nw(&comp_ctx_params, ctx_params, + alg, task_type, WD_COMP_TYPE, WD_DIR_MAX); if (ret) { if (ret == -WD_EAGAIN) { - wd_disable_drv(wd_comp_setting.driver); - wd_alg_drv_unbind(wd_comp_setting.driver); continue; } - goto out_unbind_drv; + goto out_dlclose; } (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.task_type = task_type; wd_comp_init_attrs.ctx_params = &comp_ctx_params; wd_comp_init_attrs.alg_init = wd_comp_init_nolock; wd_comp_init_attrs.alg_poll_ctx = wd_comp_poll_ctx; ret = wd_alg_attrs_init(&wd_comp_init_attrs); if (ret) { if (ret == -WD_ENODEV) { - wd_disable_drv(wd_comp_setting.driver); - wd_alg_drv_unbind(wd_comp_setting.driver); wd_ctx_param_uninit(&comp_ctx_params); continue; } @@ -324,15 +308,26 @@ int wd_comp_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_par } } + ret = wd_ctx_drv_config(alg, &wd_comp_setting.config); + if (ret) + goto out_uninit_nolock; + + ret = wd_alg_init_driver_nw(&wd_comp_setting.config); + if (ret) + goto out_drv_deconfig; + wd_alg_set_init(&wd_comp_setting.status); wd_ctx_param_uninit(&comp_ctx_params); return 0; +out_drv_deconfig: + wd_ctx_drv_deconfig(&wd_comp_setting.config); +out_uninit_nolock: + wd_comp_uninit_nolock(); + wd_alg_attrs_uninit(&wd_comp_init_attrs); out_params_uninit: wd_ctx_param_uninit(&comp_ctx_params); -out_unbind_drv: - wd_alg_drv_unbind(wd_comp_setting.driver); out_dlclose: wd_comp_close_driver(WD_TYPE_V2); out_uninit: @@ -344,12 +339,12 @@ void wd_comp_uninit2(void) { int ret; + wd_ctx_drv_deconfig(&wd_comp_setting.config); ret = wd_comp_uninit_nolock(); if (ret) return; wd_alg_attrs_uninit(&wd_comp_init_attrs); - wd_alg_drv_unbind(wd_comp_setting.driver); wd_comp_close_driver(WD_TYPE_V2); wd_alg_clear_init(&wd_comp_setting.status); } @@ -384,7 +379,7 @@ int wd_comp_poll_ctx(__u32 idx, __u32 expt, __u32 *count) ctx = config->ctxs + idx; do { - ret = wd_comp_setting.driver->recv(ctx->ctx, &resp_msg); + ret = ctx->drv->recv(ctx->ctx, &resp_msg); if (unlikely(ret < 0)) { if (ret == -WD_HW_EACCESS) WD_ERR("wd comp recv hw error!\n"); @@ -683,8 +678,8 @@ static int wd_comp_sync_job(struct wd_comp_sess *sess, wd_dfx_msg_cnt(config, WD_CTX_CNT_NUM, idx); ctx = config->ctxs + idx; - msg_handle.send = wd_comp_setting.driver->send; - msg_handle.recv = wd_comp_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, @@ -946,7 +941,7 @@ int wd_do_comp_async(handle_t h_sess, struct wd_comp_req *req) msg->tag = tag; msg->stream_mode = WD_COMP_STATELESS; - ret = wd_comp_setting.driver->send(ctx->ctx, msg); + ret = ctx->drv->send(ctx->ctx, msg); if (unlikely(ret < 0)) { if (ret != -WD_EBUSY) WD_ERR("wd comp send error, ret = %d!\n", ret); -- 2.43.0

From: Longfang Liu <liulongfang@huawei.com> After the uadk framework updates the heterogeneous scheduling function, the internal implementation functions of the digest algorithm need to be adapted and modified. Signed-off-by: Longfang Liu <liulongfang@huawei.com> --- wd_digest.c | 106 +++++++++++++++++++++++++--------------------------- 1 file changed, 50 insertions(+), 56 deletions(-) diff --git a/wd_digest.c b/wd_digest.c index 763eae5..fc42796 100644 --- a/wd_digest.c +++ b/wd_digest.c @@ -40,7 +40,6 @@ struct wd_digest_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; @@ -86,20 +85,16 @@ static void wd_digest_close_driver(int init_type) } if (wd_digest_setting.dlhandle) { - wd_release_drv(wd_digest_setting.driver); dlclose(wd_digest_setting.dlhandle); wd_digest_setting.dlhandle = NULL; } #else - wd_release_drv(wd_digest_setting.driver); hisi_sec2_remove(); #endif } static int wd_digest_open_driver(int init_type) { - struct wd_alg_driver *driver = NULL; - const char *alg_name = "sm3"; #ifndef WD_STATIC_DRV char lib_path[PATH_MAX]; int ret; @@ -133,14 +128,6 @@ static int wd_digest_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_digest_close_driver(WD_TYPE_V1); - WD_ERR("failed to get %s driver support\n", alg_name); - return -WD_EINVAL; - } - - wd_digest_setting.driver = driver; return WD_SUCCESS; } @@ -238,7 +225,7 @@ handle_t wd_digest_alloc_sess(struct wd_digest_sess_setup *setup) sess->alg_name = wd_digest_alg_name[setup->alg]; sess->alg = setup->alg; sess->mode = setup->mode; - ret = wd_drv_alg_support(sess->alg_name, wd_digest_setting.driver); + ret = wd_drv_alg_support(sess->alg_name, &wd_digest_setting.config); if (!ret) { WD_ERR("failed to support this algorithm: %s!\n", sess->alg_name); goto err_sess; @@ -312,16 +299,10 @@ static int wd_digest_init_nolock(struct wd_ctx_config *config, if (ret < 0) goto out_clear_sched; - ret = wd_alg_init_driver(&wd_digest_setting.config, - wd_digest_setting.driver, - &wd_digest_setting.priv); - if (ret) - goto out_clear_pool; + wd_digest_setting.priv = STATUS_ENABLE; return 0; -out_clear_pool: - wd_uninit_async_request_pool(&wd_digest_setting.pool); out_clear_sched: wd_clear_sched(&wd_digest_setting.sched); out_clear_ctx_config: @@ -330,6 +311,13 @@ out_clear_ctx_config: return ret; } +static void wd_digest_uninit_nolock(void) +{ + wd_uninit_async_request_pool(&wd_digest_setting.pool); + wd_clear_sched(&wd_digest_setting.sched); + wd_digest_setting.priv = NULL; +} + int wd_digest_init(struct wd_ctx_config *config, struct wd_sched *sched) { int ret; @@ -352,10 +340,22 @@ int wd_digest_init(struct wd_ctx_config *config, struct wd_sched *sched) if (ret) goto out_close_driver; + ret = wd_ctx_drv_config("sm3", &wd_digest_setting.config); + if (ret) + goto out_uninit_nolock; + + ret = wd_alg_init_driver_nw(&wd_digest_setting.config); + if (ret) + goto out_drv_deconfig; + wd_alg_set_init(&wd_digest_setting.status); return 0; +out_drv_deconfig: + wd_ctx_drv_deconfig(&wd_digest_setting.config); +out_uninit_nolock: + wd_digest_uninit_nolock(); out_close_driver: wd_digest_close_driver(WD_TYPE_V1); out_clear_init: @@ -363,20 +363,14 @@ out_clear_init: return ret; } -static void wd_digest_uninit_nolock(void) -{ - wd_uninit_async_request_pool(&wd_digest_setting.pool); - wd_clear_sched(&wd_digest_setting.sched); - wd_alg_uninit_driver(&wd_digest_setting.config, - wd_digest_setting.driver, - &wd_digest_setting.priv); -} - void wd_digest_uninit(void) { if (!wd_digest_setting.priv) return; + wd_alg_uninit_driver_nw(&wd_digest_setting.config); + wd_ctx_drv_deconfig(&wd_digest_setting.config); + wd_digest_uninit_nolock(); wd_digest_close_driver(WD_TYPE_V1); wd_alg_clear_init(&wd_digest_setting.status); @@ -424,36 +418,26 @@ int wd_digest_init2_(char *alg, __u32 sched_type, int task_type, while (ret != 0) { memset(&wd_digest_setting.config, 0, sizeof(struct wd_ctx_config_internal)); - /* Get alg driver and dev name */ - wd_digest_setting.driver = wd_alg_drv_bind(task_type, alg); - if (!wd_digest_setting.driver) { - WD_ERR("failed to bind %s driver.\n", alg); - goto out_dlopen; - } - + /* Init ctx param and prepare for ctx request */ digest_ctx_params.ctx_set_num = &digest_ctx_num; - ret = wd_ctx_param_init(&digest_ctx_params, ctx_params, - wd_digest_setting.driver, WD_DIGEST_TYPE, 1); + ret = wd_ctx_param_init_nw(&digest_ctx_params, ctx_params, + alg, task_type, WD_DIGEST_TYPE, 1); if (ret) { if (ret == -WD_EAGAIN) { - wd_disable_drv(wd_digest_setting.driver); - wd_alg_drv_unbind(wd_digest_setting.driver); continue; } - goto out_driver; + goto out_dlclose; } (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.task_type = task_type; wd_digest_init_attrs.ctx_params = &digest_ctx_params; wd_digest_init_attrs.alg_init = wd_digest_init_nolock; wd_digest_init_attrs.alg_poll_ctx = wd_digest_poll_ctx; ret = wd_alg_attrs_init(&wd_digest_init_attrs); if (ret) { if (ret == -WD_ENODEV) { - wd_disable_drv(wd_digest_setting.driver); - wd_alg_drv_unbind(wd_digest_setting.driver); wd_ctx_param_uninit(&digest_ctx_params); continue; } @@ -461,16 +445,27 @@ int wd_digest_init2_(char *alg, __u32 sched_type, int task_type, goto out_params_uninit; } } + ret = wd_ctx_drv_config(alg, &wd_digest_setting.config); + if (ret) + goto out_uninit_nolock; + + ret = wd_alg_init_driver_nw(&wd_digest_setting.config); + if (ret) + goto out_drv_deconfig; + wd_alg_set_init(&wd_digest_setting.status); wd_ctx_param_uninit(&digest_ctx_params); return 0; +out_drv_deconfig: + wd_ctx_drv_deconfig(&wd_digest_setting.config); +out_uninit_nolock: + wd_digest_uninit_nolock(); + wd_alg_attrs_uninit(&wd_digest_init_attrs); out_params_uninit: wd_ctx_param_uninit(&digest_ctx_params); -out_driver: - wd_alg_drv_unbind(wd_digest_setting.driver); -out_dlopen: +out_dlclose: wd_digest_close_driver(WD_TYPE_V2); out_uninit: wd_alg_clear_init(&wd_digest_setting.status); @@ -482,9 +477,9 @@ void wd_digest_uninit2(void) if (!wd_digest_setting.priv) return; + wd_ctx_drv_deconfig(&wd_digest_setting.config); wd_digest_uninit_nolock(); wd_alg_attrs_uninit(&wd_digest_init_attrs); - wd_alg_drv_unbind(wd_digest_setting.driver); wd_digest_close_driver(WD_TYPE_V2); wd_alg_clear_init(&wd_digest_setting.status); } @@ -643,13 +638,13 @@ static int send_recv_sync(struct wd_ctx_internal *ctx, struct wd_digest_sess *ds struct wd_msg_handle msg_handle; int ret; - msg_handle.send = wd_digest_setting.driver->send; - msg_handle.recv = wd_digest_setting.driver->recv; + msg_handle.send = ctx->drv->send; + msg_handle.recv = ctx->drv->recv; - wd_ctx_spin_lock(ctx, wd_digest_setting.driver->calc_type); + wd_ctx_spin_lock(ctx, UADK_ALG_HW); ret = wd_handle_msg_sync(&msg_handle, ctx->ctx, msg, NULL, wd_digest_setting.config.epoll_en); - wd_ctx_spin_unlock(ctx, wd_digest_setting.driver->calc_type); + wd_ctx_spin_unlock(ctx, UADK_ALG_HW); if (unlikely(ret)) return ret; @@ -742,7 +737,7 @@ int wd_do_digest_async(handle_t h_sess, struct wd_digest_req *req) fill_request_msg(msg, req, dsess); msg->tag = msg_id; - ret = wd_digest_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"); @@ -792,8 +787,7 @@ int wd_digest_poll_ctx(__u32 idx, __u32 expt, __u32 *count) ctx = config->ctxs + idx; do { - ret = wd_digest_setting.driver->recv(ctx->ctx, - &recv_msg); + ret = ctx->drv->recv(ctx->ctx, &recv_msg); if (ret == -WD_EAGAIN) { return ret; } else if (ret < 0) { -- 2.43.0

From: Longfang Liu <liulongfang@huawei.com> After the uadk framework updates the heterogeneous scheduling function, the internal implementation functions of the rsa algorithm need to be adapted and modified. Signed-off-by: Longfang Liu <liulongfang@huawei.com> --- wd_rsa.c | 87 ++++++++++++++++++++++++++------------------------------ 1 file changed, 40 insertions(+), 47 deletions(-) diff --git a/wd_rsa.c b/wd_rsa.c index 3e4d70d..1104c2a 100644 --- a/wd_rsa.c +++ b/wd_rsa.c @@ -76,7 +76,6 @@ static struct wd_rsa_setting { struct wd_ctx_config_internal config; struct wd_sched sched; struct wd_async_msg_pool pool; - struct wd_alg_driver *driver; void *priv; void *dlhandle; void *dlh_list; @@ -97,19 +96,15 @@ static void wd_rsa_close_driver(int init_type) if (!wd_rsa_setting.dlhandle) return; - wd_release_drv(wd_rsa_setting.driver); dlclose(wd_rsa_setting.dlhandle); wd_rsa_setting.dlhandle = NULL; #else - wd_release_drv(wd_rsa_setting.driver); hisi_hpre_remove(); #endif } static int wd_rsa_open_driver(int init_type) { - struct wd_alg_driver *driver = NULL; - const char *alg_name = "rsa"; #ifndef WD_STATIC_DRV char lib_path[PATH_MAX]; int ret; @@ -143,14 +138,6 @@ static int wd_rsa_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_rsa_close_driver(WD_TYPE_V1); - WD_ERR("failed to get %s driver support!\n", alg_name); - return -WD_EINVAL; - } - - wd_rsa_setting.driver = driver; return WD_SUCCESS; } @@ -184,16 +171,10 @@ static int wd_rsa_common_init(struct wd_ctx_config *config, struct wd_sched *sch if (ret < 0) goto out_clear_sched; - ret = wd_alg_init_driver(&wd_rsa_setting.config, - wd_rsa_setting.driver, - &wd_rsa_setting.priv); - if (ret) - goto out_clear_pool; + wd_rsa_setting.priv = STATUS_ENABLE; return WD_SUCCESS; -out_clear_pool: - wd_uninit_async_request_pool(&wd_rsa_setting.pool); out_clear_sched: wd_clear_sched(&wd_rsa_setting.sched); out_clear_ctx_config: @@ -213,9 +194,7 @@ static int wd_rsa_common_uninit(void) /* unset config, sched, driver */ wd_clear_sched(&wd_rsa_setting.sched); - wd_alg_uninit_driver(&wd_rsa_setting.config, - wd_rsa_setting.driver, - &wd_rsa_setting.priv); + wd_rsa_setting.priv = NULL; return WD_SUCCESS; } @@ -242,10 +221,22 @@ int wd_rsa_init(struct wd_ctx_config *config, struct wd_sched *sched) if (ret) goto out_close_driver; + ret = wd_ctx_drv_config("rsa", &wd_rsa_setting.config); + if (ret) + goto out_uninit_nolock; + + ret = wd_alg_init_driver_nw(&wd_rsa_setting.config); + if (ret) + goto out_drv_deconfig; + wd_alg_set_init(&wd_rsa_setting.status); return WD_SUCCESS; +out_drv_deconfig: + wd_ctx_drv_deconfig(&wd_rsa_setting.config); +out_uninit_nolock: + wd_rsa_common_uninit(); out_close_driver: wd_rsa_close_driver(WD_TYPE_V1); out_clear_init: @@ -257,6 +248,8 @@ void wd_rsa_uninit(void) { int ret; + wd_alg_uninit_driver_nw(&wd_rsa_setting.config); + wd_ctx_drv_deconfig(&wd_rsa_setting.config); ret = wd_rsa_common_uninit(); if (ret) return; @@ -295,37 +288,26 @@ int wd_rsa_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_para while (ret) { memset(&wd_rsa_setting.config, 0, sizeof(struct wd_ctx_config_internal)); - /* Get alg driver and dev name */ - wd_rsa_setting.driver = wd_alg_drv_bind(task_type, alg); - if (!wd_rsa_setting.driver) { - WD_ERR("failed to bind a valid driver!\n"); - ret = -WD_EINVAL; - goto out_dlopen; - } - + /* Init ctx param and prepare for ctx request */ rsa_ctx_params.ctx_set_num = rsa_ctx_num; - ret = wd_ctx_param_init(&rsa_ctx_params, ctx_params, - wd_rsa_setting.driver, WD_RSA_TYPE, WD_RSA_GENKEY); + ret = wd_ctx_param_init_nw(&rsa_ctx_params, ctx_params, + alg, task_type, WD_RSA_TYPE, WD_RSA_GENKEY); if (ret) { - if (ret == -WD_EAGAIN) { - wd_disable_drv(wd_rsa_setting.driver); - wd_alg_drv_unbind(wd_rsa_setting.driver); + if (ret == -WD_EAGAIN) continue; - } + goto out_driver; } (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.task_type = task_type; wd_rsa_init_attrs.ctx_params = &rsa_ctx_params; wd_rsa_init_attrs.alg_init = wd_rsa_common_init; wd_rsa_init_attrs.alg_poll_ctx = wd_rsa_poll_ctx; ret = wd_alg_attrs_init(&wd_rsa_init_attrs); if (ret) { if (ret == -WD_ENODEV) { - wd_disable_drv(wd_rsa_setting.driver); - wd_alg_drv_unbind(wd_rsa_setting.driver); wd_ctx_param_uninit(&rsa_ctx_params); continue; } @@ -334,16 +316,27 @@ int wd_rsa_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_para } } + ret = wd_ctx_drv_config(alg, &wd_rsa_setting.config); + if (ret) + goto out_uninit_nolock; + + ret = wd_alg_init_driver_nw(&wd_rsa_setting.config); + if (ret) + goto out_drv_deconfig; + wd_alg_set_init(&wd_rsa_setting.status); wd_ctx_param_uninit(&rsa_ctx_params); return WD_SUCCESS; +out_drv_deconfig: + wd_ctx_drv_deconfig(&wd_rsa_setting.config); +out_uninit_nolock: + wd_rsa_common_uninit(); + wd_alg_attrs_uninit(&wd_rsa_init_attrs); out_params_uninit: wd_ctx_param_uninit(&rsa_ctx_params); out_driver: - wd_alg_drv_unbind(wd_rsa_setting.driver); -out_dlopen: wd_rsa_close_driver(WD_TYPE_V2); out_clear_init: wd_alg_clear_init(&wd_rsa_setting.status); @@ -354,12 +347,12 @@ void wd_rsa_uninit2(void) { int ret; + wd_ctx_drv_deconfig(&wd_rsa_setting.config); ret = wd_rsa_common_uninit(); if (ret) return; wd_alg_attrs_uninit(&wd_rsa_init_attrs); - wd_alg_drv_unbind(wd_rsa_setting.driver); wd_rsa_close_driver(WD_TYPE_V2); wd_alg_clear_init(&wd_rsa_setting.status); } @@ -449,8 +442,8 @@ int wd_do_rsa_sync(handle_t h_sess, struct wd_rsa_req *req) if (unlikely(ret)) return ret; - msg_handle.send = wd_rsa_setting.driver->send; - msg_handle.recv = wd_rsa_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, &balance, @@ -500,7 +493,7 @@ int wd_do_rsa_async(handle_t sess, struct wd_rsa_req *req) goto fail_with_msg; msg->tag = mid; - ret = wd_rsa_setting.driver->send(ctx->ctx, msg); + ret = ctx->drv->send(ctx->ctx, msg); if (unlikely(ret)) { if (ret != -WD_EBUSY) WD_ERR("failed to send rsa BD, hw is err!\n"); @@ -550,7 +543,7 @@ int wd_rsa_poll_ctx(__u32 idx, __u32 expt, __u32 *count) ctx = config->ctxs + idx; do { - ret = wd_rsa_setting.driver->recv(ctx->ctx, &recv_msg); + ret = ctx->drv->recv(ctx->ctx, &recv_msg); if (ret == -WD_EAGAIN) { return ret; } else if (ret < 0) { -- 2.43.0

From: Longfang Liu <liulongfang@huawei.com> After the uadk framework updates the heterogeneous scheduling function, the internal implementation functions of the hash-join and gather algorithm need to be adapted and modified. Signed-off-by: Longfang Liu <liulongfang@huawei.com> --- wd_join_gather.c | 124 ++++++++++++++++++++++++++--------------------- 1 file changed, 69 insertions(+), 55 deletions(-) diff --git a/wd_join_gather.c b/wd_join_gather.c index 86190c4..52cd5f9 100644 --- a/wd_join_gather.c +++ b/wd_join_gather.c @@ -32,7 +32,6 @@ struct wd_join_gather_setting { struct wd_ctx_config_internal config; struct wd_sched sched; struct wd_async_msg_pool pool; - struct wd_alg_driver *driver; void *priv; void *dlhandle; void *dlh_list; @@ -79,7 +78,6 @@ static void wd_join_gather_close_driver(void) wd_dlclose_drv(wd_join_gather_setting.dlh_list); wd_join_gather_setting.dlh_list = NULL; #else - wd_release_drv(wd_join_gather_setting.driver); hisi_dae_join_gather_remove(); #endif } @@ -406,33 +404,64 @@ free_join: static void wd_join_gather_uninit_sess(struct wd_join_gather_sess *sess) { + struct wd_ctx_config_internal *config = &wd_join_gather_setting.config; + struct wd_join_gather_ops *eops; + __u32 i; + if (sess->gather_conf.batch_row_size) free(sess->gather_conf.batch_row_size); - if (sess->ops.sess_uninit) - sess->ops.sess_uninit(sess->priv); + for (i = 0; i < config->ctx_num; i++) { + /* At this point, extends_ops has completed its initialization. */ + eops = config->ctxs[i].extend_ops; + if (!eops) + continue; + + if (eops->sess_uninit) + eops->sess_uninit(sess->priv); + } } static int wd_join_gather_init_sess(struct wd_join_gather_sess *sess, struct wd_join_gather_sess_setup *setup) { - __u32 array_size; + struct wd_ctx_config_internal *config = &wd_join_gather_setting.config; + struct wd_join_gather_ops *eops = NULL; + struct wd_alg_driver *drv; + __u32 i, array_size; int ret; - if (sess->ops.sess_init) { - if (!sess->ops.sess_uninit) { + 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; + break; + } + } + if (!eops) { + WD_ERR("failed to get extend ops!\n"); + return -WD_EINVAL; + } + + memcpy(&sess->ops, eops, sizeof(*eops)); + if (eops->sess_init) { + if (!eops->sess_uninit) { WD_ERR("failed to get session uninit ops!\n"); return -WD_EINVAL; } - ret = sess->ops.sess_init(setup, &sess->priv); + ret = eops->sess_init(setup, &sess->priv); if (ret) { WD_ERR("failed to init session priv!\n"); return ret; } } - if (sess->ops.get_table_row_size && setup->alg != WD_GATHER) { - ret = sess->ops.get_table_row_size(sess->priv); + if (eops->get_table_row_size && setup->alg != WD_GATHER) { + ret = eops->get_table_row_size(sess->priv); if (ret <= 0) { WD_ERR("failed to get hash table row size: %d!\n", ret); goto uninit; @@ -440,13 +469,13 @@ static int wd_join_gather_init_sess(struct wd_join_gather_sess *sess, sess->hash_table.table_row_size = ret; } - if (sess->ops.get_batch_row_size && setup->alg != WD_JOIN) { + if (eops->get_batch_row_size && setup->alg != WD_JOIN) { array_size = setup->gather_table_num * sizeof(__u32); sess->gather_conf.batch_row_size = malloc(array_size); if (!sess->gather_conf.batch_row_size) goto uninit; - ret = sess->ops.get_batch_row_size(sess->priv, + ret = eops->get_batch_row_size(sess->priv, sess->gather_conf.batch_row_size, array_size); if (ret) { @@ -460,8 +489,8 @@ static int wd_join_gather_init_sess(struct wd_join_gather_sess *sess, free_batch: free(sess->gather_conf.batch_row_size); uninit: - if (sess->ops.sess_uninit) - sess->ops.sess_uninit(sess->priv); + if (eops->sess_uninit) + eops->sess_uninit(sess->priv); return -WD_EINVAL; } @@ -485,7 +514,7 @@ handle_t wd_join_gather_alloc_sess(struct wd_join_gather_sess_setup *setup) sess->index_type = setup->index_type; sess->join_conf.key_output_enable = setup->join_table.key_output_enable; - ret = wd_drv_alg_support(wd_join_gather_alg[sess->alg], wd_join_gather_setting.driver); + ret = wd_drv_alg_support(wd_join_gather_alg[sess->alg], &wd_join_gather_setting.config); if (!ret) { WD_ERR("failed to check driver alg: %s!\n", wd_join_gather_alg[sess->alg]); goto free_sess; @@ -499,14 +528,6 @@ handle_t wd_join_gather_alloc_sess(struct wd_join_gather_sess_setup *setup) goto free_sess; } - if (wd_join_gather_setting.driver->get_extend_ops) { - ret = wd_join_gather_setting.driver->get_extend_ops(&sess->ops); - if (ret) { - WD_ERR("failed to get join gather extend ops!\n"); - goto free_key; - } - } - ret = wd_join_gather_init_sess(sess, setup); if (ret) goto free_key; @@ -697,16 +718,10 @@ static int wd_join_gather_alg_init(struct wd_ctx_config *config, struct wd_sched if (ret < 0) goto out_clear_sched; - ret = wd_alg_init_driver(&wd_join_gather_setting.config, - wd_join_gather_setting.driver, - &wd_join_gather_setting.priv); - if (ret) - goto out_clear_pool; + wd_join_gather_setting.priv = STATUS_ENABLE; return WD_SUCCESS; -out_clear_pool: - wd_uninit_async_request_pool(&wd_join_gather_setting.pool); out_clear_sched: wd_clear_sched(&wd_join_gather_setting.sched); out_clear_ctx_config: @@ -728,9 +743,7 @@ static int wd_join_gather_alg_uninit(void) /* Unset config, sched, driver */ wd_clear_sched(&wd_join_gather_setting.sched); - wd_alg_uninit_driver(&wd_join_gather_setting.config, - wd_join_gather_setting.driver, - &wd_join_gather_setting.priv); + wd_join_gather_setting.priv = NULL; return WD_SUCCESS; } @@ -769,21 +782,12 @@ int wd_join_gather_init(char *alg, __u32 sched_type, int task_type, while (ret != 0) { memset(&wd_join_gather_setting.config, 0, sizeof(struct wd_ctx_config_internal)); - /* Get alg driver and dev name */ - wd_join_gather_setting.driver = wd_alg_drv_bind(task_type, alg); - if (!wd_join_gather_setting.driver) { - WD_ERR("failed to bind %s driver.\n", alg); - goto out_dlopen; - } - + /* Init ctx param and prepare for ctx request */ join_gather_ctx_params.ctx_set_num = &join_gather_ctx_num; - ret = wd_ctx_param_init(&join_gather_ctx_params, ctx_params, - wd_join_gather_setting.driver, - WD_JOIN_GATHER_TYPE, 1); + ret = wd_ctx_param_init_nw(&join_gather_ctx_params, ctx_params, + alg, task_type, WD_JOIN_GATHER_TYPE, 1); if (ret) { if (ret == -WD_EAGAIN) { - wd_disable_drv(wd_join_gather_setting.driver); - wd_alg_drv_unbind(wd_join_gather_setting.driver); continue; } goto out_driver; @@ -791,15 +795,13 @@ int wd_join_gather_init(char *alg, __u32 sched_type, int task_type, (void)strcpy(wd_join_gather_init_attrs.alg, alg); wd_join_gather_init_attrs.sched_type = sched_type; - wd_join_gather_init_attrs.driver = wd_join_gather_setting.driver; + wd_join_gather_init_attrs.task_type = task_type; wd_join_gather_init_attrs.ctx_params = &join_gather_ctx_params; wd_join_gather_init_attrs.alg_init = wd_join_gather_alg_init; wd_join_gather_init_attrs.alg_poll_ctx = wd_join_gather_poll_ctx; ret = wd_alg_attrs_init(&wd_join_gather_init_attrs); if (ret) { if (ret == -WD_ENODEV) { - wd_disable_drv(wd_join_gather_setting.driver); - wd_alg_drv_unbind(wd_join_gather_setting.driver); wd_ctx_param_uninit(&join_gather_ctx_params); continue; } @@ -807,17 +809,27 @@ int wd_join_gather_init(char *alg, __u32 sched_type, int task_type, goto out_params_uninit; } } + ret = wd_ctx_drv_config(alg, &wd_join_gather_setting.config); + if (ret) + goto out_uninit_nolock; + + ret = wd_alg_init_driver_nw(&wd_join_gather_setting.config); + if (ret) + goto out_drv_deconfig; wd_alg_set_init(&wd_join_gather_setting.status); wd_ctx_param_uninit(&join_gather_ctx_params); return WD_SUCCESS; +out_drv_deconfig: + wd_ctx_drv_deconfig(&wd_join_gather_setting.config); +out_uninit_nolock: + wd_join_gather_alg_uninit(); + wd_alg_attrs_uninit(&wd_join_gather_init_attrs); out_params_uninit: wd_ctx_param_uninit(&join_gather_ctx_params); out_driver: - wd_alg_drv_unbind(wd_join_gather_setting.driver); -out_dlopen: wd_join_gather_close_driver(); out_uninit: wd_alg_clear_init(&wd_join_gather_setting.status); @@ -832,8 +844,10 @@ void wd_join_gather_uninit(void) if (ret) return; + wd_alg_uninit_driver_nw(&wd_join_gather_setting.config); + wd_ctx_drv_deconfig(&wd_join_gather_setting.config); wd_alg_attrs_uninit(&wd_join_gather_init_attrs); - wd_alg_drv_unbind(wd_join_gather_setting.driver); + wd_join_gather_close_driver(); wd_alg_clear_init(&wd_join_gather_setting.status); } @@ -1213,8 +1227,8 @@ static int wd_join_gather_sync_job(struct wd_join_gather_sess *sess, wd_dfx_msg_cnt(config, WD_CTX_CNT_NUM, idx); ctx = config->ctxs + idx; - msg_handle.send = setting->driver->send; - msg_handle.recv = 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, @@ -1313,7 +1327,7 @@ static int wd_join_gather_async_job(struct wd_join_gather_sess *sess, fill_join_gather_msg(msg, req, sess); msg->tag = msg_id; - ret = wd_join_gather_setting.driver->send(ctx->ctx, msg); + ret = ctx->drv->send(ctx->ctx, msg); if (ret < 0) { if (ret != -WD_EBUSY) WD_ERR("wd join gather async send err!\n"); @@ -1783,7 +1797,7 @@ static int wd_join_gather_poll_ctx(__u32 idx, __u32 expt, __u32 *count) ctx = config->ctxs + idx; do { - ret = wd_join_gather_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

From: Longfang Liu <liulongfang@huawei.com> After adapting to uadk's heterogeneous scheduling framework, all uadk algorithms have completed functional adaptation. After the adaptation is completed, the old functions need to be deleted. Signed-off-by: Longfang Liu <liulongfang@huawei.com> --- include/wd_util.h | 15 ++------ wd_aead.c | 8 ++--- wd_agg.c | 6 ++-- wd_cipher.c | 8 ++--- wd_comp.c | 8 ++--- wd_dh.c | 8 ++--- wd_digest.c | 8 ++--- wd_ecc.c | 8 ++--- wd_join_gather.c | 6 ++-- wd_rsa.c | 8 ++--- wd_udma.c | 6 ++-- wd_util.c | 91 ++++------------------------------------------- 12 files changed, 47 insertions(+), 133 deletions(-) diff --git a/include/wd_util.h b/include/wd_util.h index f226122..42270d9 100644 --- a/include/wd_util.h +++ b/include/wd_util.h @@ -133,7 +133,6 @@ struct wd_init_attrs { struct wd_ctx_config *ctx_config; wd_alg_init alg_init; wd_alg_poll_ctx alg_poll_ctx; - struct wd_alg_driver *driver; //stub for old code }; /* @@ -456,14 +455,10 @@ static inline void wd_alg_clear_init(enum wd_status *status) * * Return 0 if succeed and other error number if fail. */ -int wd_ctx_param_init_nw(struct wd_ctx_params *ctx_params, +int wd_ctx_param_init(struct wd_ctx_params *ctx_params, struct wd_ctx_params *user_ctx_params, char *alg, int task_type, enum wd_type type, int max_op_type); -int wd_ctx_param_init(struct wd_ctx_params *ctx_params, - struct wd_ctx_params *user_ctx_params, - struct wd_alg_driver *driver, - enum wd_type type, int max_op_type); void wd_ctx_param_uninit(struct wd_ctx_params *ctx_params); @@ -497,12 +492,8 @@ void wd_alg_drv_unbind(struct wd_alg_driver *drv); * * Return 0 if succeed and other error number if fail. */ -int wd_alg_init_driver_nw(struct wd_ctx_config_internal *config); -void wd_alg_uninit_driver_nw(struct wd_ctx_config_internal *config); -int wd_alg_init_driver(struct wd_ctx_config_internal *config, - struct wd_alg_driver *driver, void **drv_priv); -void wd_alg_uninit_driver(struct wd_ctx_config_internal *config, - struct wd_alg_driver *driver, void **drv_priv); +int wd_alg_init_driver(struct wd_ctx_config_internal *config); +void wd_alg_uninit_driver(struct wd_ctx_config_internal *config); /** * wd_dlopen_drv() - Open the dynamic library file of the device driver. diff --git a/wd_aead.c b/wd_aead.c index 7ef7dca..fcf23bb 100644 --- a/wd_aead.c +++ b/wd_aead.c @@ -649,7 +649,7 @@ int wd_aead_init(struct wd_ctx_config *config, struct wd_sched *sched) if (ret) goto out_uninit_nolock; - ret = wd_alg_init_driver_nw(&wd_aead_setting.config); + ret = wd_alg_init_driver(&wd_aead_setting.config); if (ret) goto out_drv_deconfig; wd_alg_set_init(&wd_aead_setting.status); @@ -672,7 +672,7 @@ void wd_aead_uninit(void) if (!wd_aead_setting.priv) return; - wd_alg_uninit_driver_nw(&wd_aead_setting.config); + wd_alg_uninit_driver(&wd_aead_setting.config); wd_ctx_drv_deconfig(&wd_aead_setting.config); wd_aead_uninit_nolock(); @@ -726,7 +726,7 @@ int wd_aead_init2_(char *alg, __u32 sched_type, int task_type, memset(&wd_aead_setting.config, 0, sizeof(struct wd_ctx_config_internal)); /* Init ctx param and prepare for ctx request */ aead_ctx_params.ctx_set_num = aead_ctx_num; - ret = wd_ctx_param_init_nw(&aead_ctx_params, ctx_params, + ret = wd_ctx_param_init(&aead_ctx_params, ctx_params, alg, task_type, WD_AEAD_TYPE, WD_DIGEST_CIPHER_DECRYPTION + 1); if (ret) { if (ret == -WD_EAGAIN) { @@ -755,7 +755,7 @@ int wd_aead_init2_(char *alg, __u32 sched_type, int task_type, if (ret) goto out_uninit_nolock; - ret = wd_alg_init_driver_nw(&wd_aead_setting.config); + ret = wd_alg_init_driver(&wd_aead_setting.config); if (ret) goto out_drv_deconfig; diff --git a/wd_agg.c b/wd_agg.c index ebc6e31..f07642d 100644 --- a/wd_agg.c +++ b/wd_agg.c @@ -697,7 +697,7 @@ int wd_agg_init(char *alg, __u32 sched_type, int task_type, struct wd_ctx_params /* Init ctx param and prepare for ctx request */ agg_ctx_params.ctx_set_num = &agg_ctx_num; - ret = wd_ctx_param_init_nw(&agg_ctx_params, ctx_params, alg, task_type, + ret = wd_ctx_param_init(&agg_ctx_params, ctx_params, alg, task_type, WD_AGG_TYPE, 1); if (ret) { if (ret == -WD_EAGAIN) { @@ -726,7 +726,7 @@ int wd_agg_init(char *alg, __u32 sched_type, int task_type, struct wd_ctx_params if (ret) goto out_uninit_nolock; - ret = wd_alg_init_driver_nw(&wd_agg_setting.config); + ret = wd_alg_init_driver(&wd_agg_setting.config); if (ret) goto out_drv_deconfig; @@ -757,7 +757,7 @@ void wd_agg_uninit(void) if (ret) return; - wd_alg_uninit_driver_nw(&wd_agg_setting.config); + wd_alg_uninit_driver(&wd_agg_setting.config); wd_ctx_drv_deconfig(&wd_agg_setting.config); wd_alg_attrs_uninit(&wd_agg_init_attrs); diff --git a/wd_cipher.c b/wd_cipher.c index af0173a..96bb21c 100644 --- a/wd_cipher.c +++ b/wd_cipher.c @@ -419,7 +419,7 @@ int wd_cipher_init(struct wd_ctx_config *config, struct wd_sched *sched) if (ret) goto out_uninit_nolock; - ret = wd_alg_init_driver_nw(&wd_cipher_setting.config); + ret = wd_alg_init_driver(&wd_cipher_setting.config); if (ret) goto out_drv_deconfig; @@ -442,7 +442,7 @@ void wd_cipher_uninit(void) { int ret; - wd_alg_uninit_driver_nw(&wd_cipher_setting.config); + wd_alg_uninit_driver(&wd_cipher_setting.config); wd_ctx_drv_deconfig(&wd_cipher_setting.config); ret = wd_cipher_common_uninit(); @@ -487,7 +487,7 @@ int wd_cipher_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_p /* Init ctx param and prepare for ctx request */ cipher_ctx_params.ctx_set_num = cipher_ctx_num; - ret = wd_ctx_param_init_nw(&cipher_ctx_params, ctx_params, + ret = wd_ctx_param_init(&cipher_ctx_params, ctx_params, alg, task_type, WD_CIPHER_TYPE, WD_CIPHER_DECRYPTION + 1); if (ret) { if (ret == -WD_EAGAIN) { @@ -518,7 +518,7 @@ int wd_cipher_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_p if (ret) goto out_uninit_nolock; - ret = wd_alg_init_driver_nw(&wd_cipher_setting.config); + ret = wd_alg_init_driver(&wd_cipher_setting.config); if (ret) goto out_drv_deconfig; diff --git a/wd_comp.c b/wd_comp.c index 596979b..b4cba28 100644 --- a/wd_comp.c +++ b/wd_comp.c @@ -213,7 +213,7 @@ int wd_comp_init(struct wd_ctx_config *config, struct wd_sched *sched) if (ret) goto out_uninit_nolock; - ret = wd_alg_init_driver_nw(&wd_comp_setting.config); + ret = wd_alg_init_driver(&wd_comp_setting.config); if (ret) goto out_drv_deconfig; @@ -236,7 +236,7 @@ void wd_comp_uninit(void) { int ret; - wd_alg_uninit_driver_nw(&wd_comp_setting.config); + wd_alg_uninit_driver(&wd_comp_setting.config); wd_ctx_drv_deconfig(&wd_comp_setting.config); ret = wd_comp_uninit_nolock(); @@ -282,7 +282,7 @@ int wd_comp_init2_(const char *alg, __u32 sched_type, int task_type, /* Init ctx param and prepare for ctx request */ comp_ctx_params.ctx_set_num = comp_ctx_num; - ret = wd_ctx_param_init_nw(&comp_ctx_params, ctx_params, + ret = wd_ctx_param_init(&comp_ctx_params, ctx_params, alg, task_type, WD_COMP_TYPE, WD_DIR_MAX); if (ret) { if (ret == -WD_EAGAIN) { @@ -312,7 +312,7 @@ int wd_comp_init2_(const char *alg, __u32 sched_type, int task_type, if (ret) goto out_uninit_nolock; - ret = wd_alg_init_driver_nw(&wd_comp_setting.config); + ret = wd_alg_init_driver(&wd_comp_setting.config); if (ret) goto out_drv_deconfig; diff --git a/wd_dh.c b/wd_dh.c index 48edc16..e7322d1 100644 --- a/wd_dh.c +++ b/wd_dh.c @@ -185,7 +185,7 @@ int wd_dh_init(struct wd_ctx_config *config, struct wd_sched *sched) if (ret) goto out_uninit_nolock; - ret = wd_alg_init_driver_nw(&wd_dh_setting.config); + ret = wd_alg_init_driver(&wd_dh_setting.config); if (ret) goto out_drv_deconfig; @@ -212,7 +212,7 @@ void wd_dh_uninit(void) if (ret) return; - wd_alg_uninit_driver_nw(&wd_dh_setting.config); + wd_alg_uninit_driver(&wd_dh_setting.config); wd_ctx_drv_deconfig(&wd_dh_setting.config); wd_dh_close_driver(WD_TYPE_V1); @@ -251,7 +251,7 @@ int wd_dh_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_param /* Init ctx param and prepare for ctx request */ dh_ctx_params.ctx_set_num = dh_ctx_num; - ret = wd_ctx_param_init_nw(&dh_ctx_params, ctx_params, + ret = wd_ctx_param_init(&dh_ctx_params, ctx_params, alg, task_type, WD_DH_TYPE, WD_DH_PHASE2); if (ret) { if (ret == -WD_EAGAIN) @@ -280,7 +280,7 @@ int wd_dh_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_param if (ret) goto out_uninit_nolock; - ret = wd_alg_init_driver_nw(&wd_dh_setting.config); + ret = wd_alg_init_driver(&wd_dh_setting.config); if (ret) goto out_drv_deconfig; diff --git a/wd_digest.c b/wd_digest.c index fc42796..4d46cc5 100644 --- a/wd_digest.c +++ b/wd_digest.c @@ -344,7 +344,7 @@ int wd_digest_init(struct wd_ctx_config *config, struct wd_sched *sched) if (ret) goto out_uninit_nolock; - ret = wd_alg_init_driver_nw(&wd_digest_setting.config); + ret = wd_alg_init_driver(&wd_digest_setting.config); if (ret) goto out_drv_deconfig; @@ -368,7 +368,7 @@ void wd_digest_uninit(void) if (!wd_digest_setting.priv) return; - wd_alg_uninit_driver_nw(&wd_digest_setting.config); + wd_alg_uninit_driver(&wd_digest_setting.config); wd_ctx_drv_deconfig(&wd_digest_setting.config); wd_digest_uninit_nolock(); @@ -420,7 +420,7 @@ int wd_digest_init2_(char *alg, __u32 sched_type, int task_type, /* Init ctx param and prepare for ctx request */ digest_ctx_params.ctx_set_num = &digest_ctx_num; - ret = wd_ctx_param_init_nw(&digest_ctx_params, ctx_params, + ret = wd_ctx_param_init(&digest_ctx_params, ctx_params, alg, task_type, WD_DIGEST_TYPE, 1); if (ret) { if (ret == -WD_EAGAIN) { @@ -449,7 +449,7 @@ int wd_digest_init2_(char *alg, __u32 sched_type, int task_type, if (ret) goto out_uninit_nolock; - ret = wd_alg_init_driver_nw(&wd_digest_setting.config); + ret = wd_alg_init_driver(&wd_digest_setting.config); if (ret) goto out_drv_deconfig; diff --git a/wd_ecc.c b/wd_ecc.c index 75507e8..3c4088b 100644 --- a/wd_ecc.c +++ b/wd_ecc.c @@ -250,7 +250,7 @@ int wd_ecc_init(struct wd_ctx_config *config, struct wd_sched *sched) if (ret) goto out_uninit_nolock; - ret = wd_alg_init_driver_nw(&wd_ecc_setting.config); + ret = wd_alg_init_driver(&wd_ecc_setting.config); if (ret) goto out_drv_deconfig; @@ -273,7 +273,7 @@ void wd_ecc_uninit(void) { int ret; - wd_alg_uninit_driver_nw(&wd_ecc_setting.config); + wd_alg_uninit_driver(&wd_ecc_setting.config); wd_ctx_drv_deconfig(&wd_ecc_setting.config); ret = wd_ecc_common_uninit(); if (ret) @@ -317,7 +317,7 @@ int wd_ecc_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_para /* Init ctx param and prepare for ctx request */ ecc_ctx_params.ctx_set_num = ecc_ctx_num; - ret = wd_ctx_param_init_nw(&ecc_ctx_params, ctx_params, + ret = wd_ctx_param_init(&ecc_ctx_params, ctx_params, alg, task_type, WD_ECC_TYPE, WD_EC_OP_MAX); if (ret) { if (ret == -WD_EAGAIN) @@ -347,7 +347,7 @@ int wd_ecc_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_para if (ret) goto out_uninit_nolock; - ret = wd_alg_init_driver_nw(&wd_ecc_setting.config); + ret = wd_alg_init_driver(&wd_ecc_setting.config); if (ret) goto out_drv_deconfig; diff --git a/wd_join_gather.c b/wd_join_gather.c index 52cd5f9..0199f35 100644 --- a/wd_join_gather.c +++ b/wd_join_gather.c @@ -784,7 +784,7 @@ int wd_join_gather_init(char *alg, __u32 sched_type, int task_type, /* Init ctx param and prepare for ctx request */ join_gather_ctx_params.ctx_set_num = &join_gather_ctx_num; - ret = wd_ctx_param_init_nw(&join_gather_ctx_params, ctx_params, + ret = wd_ctx_param_init(&join_gather_ctx_params, ctx_params, alg, task_type, WD_JOIN_GATHER_TYPE, 1); if (ret) { if (ret == -WD_EAGAIN) { @@ -813,7 +813,7 @@ int wd_join_gather_init(char *alg, __u32 sched_type, int task_type, if (ret) goto out_uninit_nolock; - ret = wd_alg_init_driver_nw(&wd_join_gather_setting.config); + ret = wd_alg_init_driver(&wd_join_gather_setting.config); if (ret) goto out_drv_deconfig; @@ -844,7 +844,7 @@ void wd_join_gather_uninit(void) if (ret) return; - wd_alg_uninit_driver_nw(&wd_join_gather_setting.config); + wd_alg_uninit_driver(&wd_join_gather_setting.config); wd_ctx_drv_deconfig(&wd_join_gather_setting.config); wd_alg_attrs_uninit(&wd_join_gather_init_attrs); diff --git a/wd_rsa.c b/wd_rsa.c index 1104c2a..8606efb 100644 --- a/wd_rsa.c +++ b/wd_rsa.c @@ -225,7 +225,7 @@ int wd_rsa_init(struct wd_ctx_config *config, struct wd_sched *sched) if (ret) goto out_uninit_nolock; - ret = wd_alg_init_driver_nw(&wd_rsa_setting.config); + ret = wd_alg_init_driver(&wd_rsa_setting.config); if (ret) goto out_drv_deconfig; @@ -248,7 +248,7 @@ void wd_rsa_uninit(void) { int ret; - wd_alg_uninit_driver_nw(&wd_rsa_setting.config); + wd_alg_uninit_driver(&wd_rsa_setting.config); wd_ctx_drv_deconfig(&wd_rsa_setting.config); ret = wd_rsa_common_uninit(); if (ret) @@ -290,7 +290,7 @@ int wd_rsa_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_para /* Init ctx param and prepare for ctx request */ rsa_ctx_params.ctx_set_num = rsa_ctx_num; - ret = wd_ctx_param_init_nw(&rsa_ctx_params, ctx_params, + ret = wd_ctx_param_init(&rsa_ctx_params, ctx_params, alg, task_type, WD_RSA_TYPE, WD_RSA_GENKEY); if (ret) { if (ret == -WD_EAGAIN) @@ -320,7 +320,7 @@ int wd_rsa_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_para if (ret) goto out_uninit_nolock; - ret = wd_alg_init_driver_nw(&wd_rsa_setting.config); + ret = wd_alg_init_driver(&wd_rsa_setting.config); if (ret) goto out_drv_deconfig; diff --git a/wd_udma.c b/wd_udma.c index d30f870..9db6d87 100644 --- a/wd_udma.c +++ b/wd_udma.c @@ -374,7 +374,7 @@ void wd_udma_uninit(void) if (status == WD_UNINIT) return; - wd_alg_uninit_driver_nw(&wd_udma_setting.config); + wd_alg_uninit_driver(&wd_udma_setting.config); wd_ctx_drv_deconfig(&wd_udma_setting.config); wd_udma_alg_uninit(); @@ -452,7 +452,7 @@ int wd_udma_init(const char *alg, __u32 sched_type, int task_type, /* Init ctx param and prepare for ctx request */ udma_ctx_params.ctx_set_num = udma_ctx_num; - ret = wd_ctx_param_init_nw(&udma_ctx_params, ctx_params, + ret = wd_ctx_param_init(&udma_ctx_params, ctx_params, alg, task_type, WD_UDMA_TYPE, WD_UDMA_OP_MAX); if (ret) { if (ret == -WD_EAGAIN) { @@ -482,7 +482,7 @@ int wd_udma_init(const char *alg, __u32 sched_type, int task_type, if (ret) goto out_uninit_nolock; - ret = wd_alg_init_driver_nw(&wd_udma_setting.config); + ret = wd_alg_init_driver(&wd_udma_setting.config); if (ret) goto out_drv_deconfig; diff --git a/wd_util.c b/wd_util.c index 09c8f9a..c76f39b 100644 --- a/wd_util.c +++ b/wd_util.c @@ -2084,13 +2084,7 @@ static void wd_ctx_uninit_driver(struct wd_ctx_config_internal *config, } } -int wd_alg_init_driver(struct wd_ctx_config_internal *config, - struct wd_alg_driver *driver, void **drv_priv) -{ - return 0; -} - -int wd_alg_init_driver_nw(struct wd_ctx_config_internal *config) +int wd_alg_init_driver(struct wd_ctx_config_internal *config) { __u32 i, j; int ret; @@ -2113,12 +2107,7 @@ init_err: return ret; } -void wd_alg_uninit_driver(struct wd_ctx_config_internal *config, - struct wd_alg_driver *driver, void **drv_priv) -{ -} - -void wd_alg_uninit_driver_nw(struct wd_ctx_config_internal *config) +void wd_alg_uninit_driver(struct wd_ctx_config_internal *config) { __u32 i; @@ -2253,8 +2242,8 @@ void wd_ctx_param_uninit(struct wd_ctx_params *ctx_params) int wd_ctx_param_init(struct wd_ctx_params *ctx_params, struct wd_ctx_params *user_ctx_params, - struct wd_alg_driver *driver, - enum wd_type type, int max_op_type) + char *alg, int task_type, enum wd_type type, + int max_op_type) { const char *env_name = wd_env_name[type]; const char *var_s; @@ -2268,9 +2257,9 @@ int wd_ctx_param_init(struct wd_ctx_params *ctx_params, /* Only hw driver support environment variable */ var_s = secure_getenv(env_name); - if (var_s && strlen(var_s) && driver->calc_type == UADK_ALG_HW) { + if (var_s && strlen(var_s) && task_type <= TASK_HW) { /* environment variable has the highest priority */ - ret = wd_env_set_ctx_nums(driver->alg_name, env_name, var_s, + ret = wd_env_set_ctx_nums(alg, env_name, var_s, ctx_params, max_op_type); if (ret) { WD_ERR("fail to init ctx nums from %s!\n", env_name); @@ -2294,83 +2283,17 @@ int wd_ctx_param_init(struct wd_ctx_params *ctx_params, } } - /* user_ctx_params is also not set, use defalut queue_num max_op_type */ + /* user_ctx_params is also not set, use driver's defalut queue_num */ numa_bitmask_setall(ctx_params->bmp); for (i = 0; i < max_op_type; i++) { ctx_params->ctx_set_num[i].sync_ctx_num = max_op_type; ctx_params->ctx_set_num[i].async_ctx_num = max_op_type; } - ctx_params->op_type_num = max_op_type; return 0; } -int wd_ctx_param_init_nw(struct wd_ctx_params *ctx_params, - struct wd_ctx_params *user_ctx_params, - char *alg, int task_type, enum wd_type type, - int max_op_type) -{ - const char *env_name = wd_env_name[type]; - const char *var_s; - int i, ret; - - ctx_params->bmp = numa_allocate_nodemask(); - if (!ctx_params->bmp) { - WD_ERR("fail to allocate nodemask.\n"); - return -WD_ENOMEM; - } - - /* Only hw driver support environment variable */ - var_s = secure_getenv(env_name); - if (var_s && strlen(var_s) && task_type <= TASK_HW) { - /* environment variable has the highest priority */ - ret = wd_env_set_ctx_nums(alg, env_name, var_s, - ctx_params, max_op_type); - if (ret) { - WD_ERR("fail to init ctx nums from %s!\n", env_name); - numa_free_nodemask(ctx_params->bmp); - return ret; - } - } else { - /* environment variable is not set, try to use user_ctx_params first */ - if (user_ctx_params) { - if (user_ctx_params->bmp) { - copy_bitmask_to_bitmask(user_ctx_params->bmp, ctx_params->bmp); - } else { - /* default value */ - numa_bitmask_setall(ctx_params->bmp); - } - ctx_params->cap = user_ctx_params->cap; - ctx_params->ctx_set_num = user_ctx_params->ctx_set_num; - ctx_params->op_type_num = user_ctx_params->op_type_num; - if (ctx_params->op_type_num > (__u32)max_op_type) { - WD_ERR("fail to check user op type numbers.\n"); - numa_free_nodemask(ctx_params->bmp); - return -WD_EINVAL; - } - - return 0; - } - - /* user_ctx_params is also not set, use driver's defalut queue_num */ - numa_bitmask_setall(ctx_params->bmp); - for (i = 0; i < driver->op_type_num; i++) { - ctx_params->ctx_set_num[i].sync_ctx_num = driver->queue_num; - ctx_params->ctx_set_num[i].async_ctx_num = driver->queue_num; - } - } - - ctx_params->op_type_num = driver->op_type_num; - if (ctx_params->op_type_num > (__u32)max_op_type) { - WD_ERR("fail to check driver op type numbers.\n"); - numa_free_nodemask(ctx_params->bmp); - return -WD_EAGAIN; - } - - return 0; -} - static void dladdr_empty(void) { } -- 2.43.0

From: Longfang Liu <liulongfang@huawei.com> Remove redundant alert log messages indicating "get msg busy" for all asynchronous mode algorithmic workloads in UADK, which were causing repeated screen flooding. Signed-off-by: Longfang Liu <liulongfang@huawei.com> --- wd_aead.c | 2 +- wd_agg.c | 4 ++-- wd_cipher.c | 4 ++-- wd_comp.c | 4 ++-- wd_dh.c | 4 ++-- wd_digest.c | 4 ++-- wd_ecc.c | 4 ++-- wd_join_gather.c | 4 ++-- wd_rsa.c | 4 ++-- wd_udma.c | 4 ++-- wd_util.c | 3 ++- 11 files changed, 21 insertions(+), 20 deletions(-) diff --git a/wd_aead.c b/wd_aead.c index fcf23bb..037cc40 100644 --- a/wd_aead.c +++ b/wd_aead.c @@ -941,7 +941,7 @@ int wd_do_aead_async(handle_t h_sess, struct wd_aead_req *req) msg_id = wd_get_msg_from_pool(&wd_aead_setting.pool, idx, (void **)&msg); if (unlikely(msg_id < 0)) { - WD_ERR("failed to get msg from pool!\n"); + //WD_ERR("failed to get msg from pool!\n"); return -WD_EBUSY; } diff --git a/wd_agg.c b/wd_agg.c index f07642d..4a97621 100644 --- a/wd_agg.c +++ b/wd_agg.c @@ -1228,8 +1228,8 @@ static int wd_agg_async_job(struct wd_agg_sess *sess, struct wd_agg_req *req, bo ctx = config->ctxs + idx; msg_id = wd_get_msg_from_pool(&wd_agg_setting.pool, idx, (void **)&msg); if (unlikely(msg_id < 0)) { - WD_ERR("failed to get agg msg from pool!\n"); - return msg_id; + //WD_ERR("failed to get agg msg from pool!\n"); + return -WD_EBUSY; } if (is_input) diff --git a/wd_cipher.c b/wd_cipher.c index 96bb21c..f8089a3 100644 --- a/wd_cipher.c +++ b/wd_cipher.c @@ -784,8 +784,8 @@ int wd_do_cipher_async(handle_t h_sess, struct wd_cipher_req *req) msg_id = wd_get_msg_from_pool(&wd_cipher_setting.pool, idx, (void **)&msg); if (unlikely(msg_id < 0)) { - WD_ERR("failed to get msg from pool!\n"); - return msg_id; + //WD_ERR("failed to get msg from pool!\n"); + return -WD_EBUSY; } fill_request_msg(msg, req, sess); diff --git a/wd_comp.c b/wd_comp.c index b4cba28..d4e22eb 100644 --- a/wd_comp.c +++ b/wd_comp.c @@ -934,8 +934,8 @@ int wd_do_comp_async(handle_t h_sess, struct wd_comp_req *req) tag = wd_get_msg_from_pool(&wd_comp_setting.pool, idx, (void **)&msg); if (unlikely(tag < 0)) { - WD_ERR("failed to get msg from pool!\n"); - return tag; + //WD_ERR("failed to get msg from pool!\n"); + return -WD_EBUSY; } fill_comp_msg(sess, msg, req); msg->tag = tag; diff --git a/wd_dh.c b/wd_dh.c index e7322d1..3395060 100644 --- a/wd_dh.c +++ b/wd_dh.c @@ -423,8 +423,8 @@ int wd_do_dh_async(handle_t sess, struct wd_dh_req *req) mid = wd_get_msg_from_pool(&wd_dh_setting.pool, idx, (void **)&msg); if (unlikely(mid < 0)) { - WD_ERR("failed to get msg from pool!\n"); - return mid; + //WD_ERR("failed to get msg from pool!\n"); + return -WD_EBUSY; } ret = fill_dh_msg(msg, req, (struct wd_dh_sess *)sess); diff --git a/wd_digest.c b/wd_digest.c index 4d46cc5..8e5bf94 100644 --- a/wd_digest.c +++ b/wd_digest.c @@ -730,8 +730,8 @@ int wd_do_digest_async(handle_t h_sess, struct wd_digest_req *req) msg_id = wd_get_msg_from_pool(&wd_digest_setting.pool, idx, (void **)&msg); if (unlikely(msg_id < 0)) { - WD_ERR("failed to get msg from pool!\n"); - return msg_id; + //WD_ERR("failed to get msg from pool!\n"); + return -WD_EBUSY; } fill_request_msg(msg, req, dsess); diff --git a/wd_ecc.c b/wd_ecc.c index 3c4088b..c31495f 100644 --- a/wd_ecc.c +++ b/wd_ecc.c @@ -2300,8 +2300,8 @@ int wd_do_ecc_async(handle_t sess, struct wd_ecc_req *req) ctx = config->ctxs + idx; mid = wd_get_msg_from_pool(&wd_ecc_setting.pool, idx, (void **)&msg); if (unlikely(mid < 0)) { - WD_ERR("failed to get msg from pool!\n"); - return mid; + //WD_ERR("failed to get msg from pool!\n"); + return -WD_EBUSY; } ret = fill_ecc_msg(msg, req, (struct wd_ecc_sess *)sess); diff --git a/wd_join_gather.c b/wd_join_gather.c index 0199f35..bd7d4d4 100644 --- a/wd_join_gather.c +++ b/wd_join_gather.c @@ -1321,8 +1321,8 @@ static int wd_join_gather_async_job(struct wd_join_gather_sess *sess, ctx = config->ctxs + idx; msg_id = wd_get_msg_from_pool(&setting->pool, idx, (void **)&msg); if (msg_id < 0) { - WD_ERR("failed to get join gather msg from pool!\n"); - return msg_id; + //WD_ERR("failed to get join gather msg from pool!\n"); + return -WD_EBUSY; } fill_join_gather_msg(msg, req, sess); diff --git a/wd_rsa.c b/wd_rsa.c index 8606efb..c020514 100644 --- a/wd_rsa.c +++ b/wd_rsa.c @@ -484,8 +484,8 @@ int wd_do_rsa_async(handle_t sess, struct wd_rsa_req *req) mid = wd_get_msg_from_pool(&wd_rsa_setting.pool, idx, (void **)&msg); if (unlikely(mid < 0)) { - WD_ERR("failed to get msg from pool!\n"); - return mid; + //WD_ERR("failed to get msg from pool!\n"); + return -WD_EBUSY; } ret = fill_rsa_msg(msg, req, (struct wd_rsa_sess *)sess); diff --git a/wd_udma.c b/wd_udma.c index 9db6d87..13c4331 100644 --- a/wd_udma.c +++ b/wd_udma.c @@ -268,8 +268,8 @@ int wd_do_udma_async(handle_t sess, struct wd_udma_req *req) mid = wd_get_msg_from_pool(&wd_udma_setting.pool, idx, (void **)&msg); if (unlikely(mid < 0)) { - WD_ERR("failed to get msg from pool!\n"); - return mid; + //WD_ERR("failed to get msg from pool!\n"); + return -WD_EBUSY; } fill_udma_msg(msg, req); diff --git a/wd_util.c b/wd_util.c index c76f39b..4830fd4 100644 --- a/wd_util.c +++ b/wd_util.c @@ -3203,7 +3203,7 @@ int wd_alg_attrs_init(struct wd_init_attrs *attrs) goto out_freesched; } - WD_ERR("debug: call function: %s!\n", __func__); + WD_ERR("TASK_MIX: call function: %s!\n", __func__); drv = wd_request_drv(alg_name, ALG_DRV_SOFT); if (drv == NULL) { WD_ERR("fail to find soft driver.\n"); @@ -3231,6 +3231,7 @@ int wd_alg_attrs_init(struct wd_init_attrs *attrs) goto out_freesched; } + WD_ERR("TASK_INSTR: call function: %s!\n", __func__); drv = wd_request_drv(alg_name, ALG_DRV_SOFT); if (drv == NULL) { WD_ERR("fail to find soft driver.\n"); -- 2.43.0