Three policies are customized for numa configuration: 1.If a node is enabled, all nodes share the same configuration. user input: sync-comp:5@0,sync-decomp:3@2 real set: sync-comp:5@0,sync-comp:5@2,sync-decomp:0@2,sync-decomp:3@2 2.If there are same type configurations, use the maximum ctx number. user input: sync-comp:5@0,sync-comp:3@2 real set: sync-comp:5@0,sync-comp:5@2 3.If the number of queues is 0, ignore this configuration. user input: sync-comp:0@0,sync-comp:3@2 real set: sync-comp:3@2 Signed-off-by: Wenkai Lin <linwenkai6@hisilicon.com> --- wd_cipher.c | 13 +++++++++++-- wd_comp.c | 14 +++++++++++++- wd_dh.c | 12 +++++++++++- wd_ecc.c | 12 +++++++++++- wd_rsa.c | 12 +++++++++++- wd_util.c | 25 ++++++++++++++++--------- 6 files changed, 73 insertions(+), 15 deletions(-) diff --git a/wd_cipher.c b/wd_cipher.c index e7c2007..77d81ea 100644 --- a/wd_cipher.c +++ b/wd_cipher.c @@ -384,6 +384,7 @@ int wd_cipher_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_p { struct wd_ctx_nums cipher_ctx_num[WD_CIPHER_DECRYPTION + 1] = {0}; struct wd_ctx_params cipher_ctx_params = {0}; + struct bitmask *inner_bmp; int ret = 0; bool flag; @@ -411,6 +412,13 @@ int wd_cipher_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_p goto out_uninit; } + cipher_ctx_params.bmp = inner_bmp = numa_allocate_nodemask(); + if (!inner_bmp) { + WD_ERR("fail to allocate nodemask.\n"); + ret = -WD_ENOMEM; + goto out_dlopen; + } + res_retry: memset(&wd_cipher_setting.config, 0, sizeof(struct wd_ctx_config_internal)); @@ -419,10 +427,9 @@ res_retry: if (!wd_cipher_setting.driver) { WD_ERR("fail to bind a valid driver.\n"); ret = -WD_EINVAL; - goto out_dlopen; + goto out_bmp; } - cipher_ctx_params.ctx_set_num = cipher_ctx_num; ret = wd_ctx_param_init(&cipher_ctx_params, ctx_params, wd_cipher_setting.driver, @@ -459,6 +466,8 @@ res_retry: out_driver: wd_alg_drv_unbind(wd_cipher_setting.driver); +out_bmp: + numa_free_nodemask(inner_bmp); out_dlopen: wd_dlclose_drv(wd_cipher_setting.dlh_list); out_uninit: diff --git a/wd_comp.c b/wd_comp.c index ed1d128..4d6fbb3 100644 --- a/wd_comp.c +++ b/wd_comp.c @@ -206,6 +206,7 @@ int wd_comp_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_par { struct wd_ctx_nums comp_ctx_num[WD_DIR_MAX] = {0}; struct wd_ctx_params comp_ctx_params; + struct bitmask *inner_bmp; int ret = 0; bool flag; @@ -233,6 +234,13 @@ int wd_comp_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_par goto out_uninit; } + comp_ctx_params.bmp = inner_bmp = numa_allocate_nodemask(); + if (!inner_bmp) { + WD_ERR("fail to allocate nodemask.\n"); + ret = -WD_ENOMEM; + goto out_dlopen; + } + res_retry: memset(&wd_comp_setting.config, 0, sizeof(struct wd_ctx_config_internal)); @@ -240,7 +248,7 @@ res_retry: wd_comp_setting.driver = wd_alg_drv_bind(task_type, alg); if (!wd_comp_setting.driver) { WD_ERR("fail to bind a valid driver.\n"); - goto out_dlopen; + goto out_bmp; } comp_ctx_params.ctx_set_num = comp_ctx_num; @@ -274,10 +282,14 @@ res_retry: wd_alg_set_init(&wd_comp_setting.status); + numa_free_nodemask(inner_bmp); + return 0; out_driver: wd_alg_drv_unbind(wd_comp_setting.driver); +out_bmp: + numa_free_nodemask(inner_bmp); out_dlopen: wd_dlclose_drv(wd_comp_setting.dlh_list); out_uninit: diff --git a/wd_dh.c b/wd_dh.c index 7c57449..be0346b 100644 --- a/wd_dh.c +++ b/wd_dh.c @@ -197,6 +197,7 @@ int wd_dh_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_param { struct wd_ctx_nums dh_ctx_num[WD_DH_PHASE2] = {0}; struct wd_ctx_params dh_ctx_params = {0}; + struct bitmask *inner_bmp; bool flag; int ret; @@ -224,6 +225,13 @@ int wd_dh_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_param goto out_clear_init; } + dh_ctx_params.bmp = inner_bmp = numa_allocate_nodemask(); + if (!inner_bmp) { + ret = -WD_ENOMEM; + WD_ERR("fail to allocate nodemask.\n"); + goto out_dlopen; + } + res_retry: memset(&wd_dh_setting.config, 0, sizeof(struct wd_ctx_config_internal)); @@ -232,7 +240,7 @@ res_retry: if (!wd_dh_setting.driver) { WD_ERR("fail to bind a valid driver.\n"); ret = -WD_EINVAL; - goto out_dlopen; + goto out_bmp; } dh_ctx_params.ctx_set_num = dh_ctx_num; @@ -270,6 +278,8 @@ res_retry: out_driver: wd_alg_drv_unbind(wd_dh_setting.driver); +out_bmp: + numa_free_nodemask(inner_bmp); out_dlopen: wd_dlclose_drv(wd_dh_setting.dlh_list); out_clear_init: diff --git a/wd_ecc.c b/wd_ecc.c index fbe2d16..f1a3f0d 100644 --- a/wd_ecc.c +++ b/wd_ecc.c @@ -253,6 +253,7 @@ int wd_ecc_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_para { struct wd_ctx_nums ecc_ctx_num[WD_EC_OP_MAX] = {0}; struct wd_ctx_params ecc_ctx_params = {0}; + struct bitmask *inner_bmp; bool flag; int ret; @@ -280,6 +281,13 @@ int wd_ecc_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_para goto out_clear_init; } + ecc_ctx_params.bmp = inner_bmp = numa_allocate_nodemask(); + if (!inner_bmp) { + WD_ERR("fail to allocate nodemask.\n"); + ret = -WD_ENOMEM; + goto out_dlopen; + } + res_retry: memset(&wd_ecc_setting.config, 0, sizeof(struct wd_ctx_config_internal)); @@ -288,7 +296,7 @@ res_retry: if (!wd_ecc_setting.driver) { WD_ERR("failed to bind a valid driver!\n"); ret = -WD_EINVAL; - goto out_dlopen; + goto out_bmp; } ecc_ctx_params.ctx_set_num = ecc_ctx_num; @@ -326,6 +334,8 @@ res_retry: out_driver: wd_alg_drv_unbind(wd_ecc_setting.driver); +out_bmp: + numa_free_nodemask(inner_bmp); out_dlopen: wd_dlclose_drv(wd_ecc_setting.dlh_list); out_clear_init: diff --git a/wd_rsa.c b/wd_rsa.c index 64c833b..7b62017 100644 --- a/wd_rsa.c +++ b/wd_rsa.c @@ -238,6 +238,7 @@ int wd_rsa_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_para { struct wd_ctx_nums rsa_ctx_num[WD_RSA_GENKEY] = {0}; struct wd_ctx_params rsa_ctx_params = {0}; + struct bitmask *inner_bmp; bool flag; int ret; @@ -265,6 +266,13 @@ int wd_rsa_init2_(char *alg, __u32 sched_type, int task_type, struct wd_ctx_para goto out_clear_init; } + rsa_ctx_params.bmp = inner_bmp = numa_allocate_nodemask(); + if (!inner_bmp) { + WD_ERR("fail to allocate nodemask.\n"); + ret = -WD_ENOMEM; + goto out_dlopen; + } + res_retry: memset(&wd_rsa_setting.config, 0, sizeof(struct wd_ctx_config_internal)); @@ -273,7 +281,7 @@ res_retry: if (!wd_rsa_setting.driver) { WD_ERR("failed to bind a valid driver!\n"); ret = -WD_EINVAL; - goto out_dlopen; + goto out_bmp; } rsa_ctx_params.ctx_set_num = rsa_ctx_num; @@ -311,6 +319,8 @@ res_retry: out_driver: wd_alg_drv_unbind(wd_rsa_setting.driver); +out_bmp: + numa_free_nodemask(inner_bmp); out_dlopen: wd_dlclose_drv(wd_rsa_setting.dlh_list); out_clear_init: diff --git a/wd_util.c b/wd_util.c index fe5ece2..9b5486b 100644 --- a/wd_util.c +++ b/wd_util.c @@ -21,6 +21,7 @@ #define WD_RECV_MAX_CNT_NOSLEEP 200000000 #define PRIVILEGE_FLAG 600 #define MIN(a, b) ((a) > (b) ? (b) : (a)) +#define MAX(a, b) ((a) > (b) ? (a) : (b)) #define WD_INIT_SLEEP_UTIME 1000 #define WD_INIT_RETRY_TIMES 10000 @@ -2010,9 +2011,10 @@ static void add_lib_to_list(struct drv_lib_list *head, tmp->next = node; } -static int wd_set_ctx_nums(struct wd_ctx_nums *ctx_nums, const char *section, +static int wd_set_ctx_nums(struct wd_ctx_params *ctx_params, const char *section, __u32 op_type_num, int is_comp) { + struct wd_ctx_nums *ctxs = ctx_params->ctx_set_num; int i, j, ctx_num, node, ret; char *ctx_section; const char *type; @@ -2031,18 +2033,24 @@ static int wd_set_ctx_nums(struct wd_ctx_nums *ctx_nums, const char *section, if (ret) return ret; - /* Allocate queues evenly on each numa */ + /* If the number of ctxs is set to 0, skip the configuration */ + if (!ctx_num) + return 0; + for (i = 0; i < CTX_MODE_MAX; i++) { for (j = 0; j < op_type_num; j++) { type = is_comp ? comp_ctx_type[i][j] : ctx_type[i][0]; if (strncmp(section, type, strlen(type))) continue; + /* If there're multiple configurations, use the maximum ctx number */ if (!i) - ctx_nums[j].sync_ctx_num = ctx_num; + ctxs[j].sync_ctx_num = MAX(ctxs[j].sync_ctx_num, ctx_num); else - ctx_nums[j].async_ctx_num = ctx_num; + ctxs[j].async_ctx_num = MAX(ctxs[j].async_ctx_num, ctx_num); + /* enable a node here, all enabled nodes share the same configuration */ + numa_bitmask_setbit(ctx_params->bmp, node); return 0; } } @@ -2050,9 +2058,8 @@ static int wd_set_ctx_nums(struct wd_ctx_nums *ctx_nums, const char *section, return -WD_EINVAL; } -/* return 0 for success, others failed */ static int wd_env_set_ctx_nums(const char *name, const char *var_s, - struct wd_ctx_nums *ctx_nums, __u32 size) + struct wd_ctx_params *ctx_params, __u32 size) { char *left, *section, *start; int is_comp; @@ -2067,7 +2074,7 @@ static int wd_env_set_ctx_nums(const char *name, const char *var_s, left = start; while ((section = strsep(&left, ","))) { - ret = wd_set_ctx_nums(ctx_nums, section, size, is_comp); + ret = wd_set_ctx_nums(ctx_params, section, size, is_comp); if (ret < 0) goto out_free_str; } @@ -2089,7 +2096,7 @@ int wd_ctx_param_init(struct wd_ctx_params *ctx_params, var_s = secure_getenv(env_name); if (var_s && strlen(var_s)) { /* environment variable has the highest priority */ - ret = wd_env_set_ctx_nums(env_name, var_s, ctx_params->ctx_set_num, max_op_type); + ret = wd_env_set_ctx_nums(env_name, var_s, ctx_params, max_op_type); if (ret) { WD_ERR("fail to init ctx nums from %s!\n", env_name); return -WD_EINVAL; @@ -2109,13 +2116,13 @@ int wd_ctx_param_init(struct wd_ctx_params *ctx_params, } /* user_ctx_params is also not set, use driver's defalut queue_num */ + ctx_params->bmp = NULL; 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->bmp = NULL; ctx_params->op_type_num = driver->op_type_num; if (ctx_params->op_type_num > max_op_type) { WD_ERR("fail to check driver op type numbers.\n"); -- 2.30.0