From: Zhushuai Yin <yinzhushuai@huawei.com> To improve performance, the lock scope is narrowed, and the mb() operation is added to ensure the visibility and ordering of shared data, thereby avoiding data races. Signed-off-by: Zhushuai Yin <yinzhushuai@huawei.com> --- src/uadk_prov_aead.c | 18 ++++++----- src/uadk_prov_cipher.c | 70 +++++++++++++++++++++--------------------- src/uadk_prov_dh.c | 15 ++++++--- src/uadk_prov_digest.c | 18 ++++++----- src/uadk_prov_hmac.c | 24 +++++++-------- src/uadk_prov_pkey.c | 14 ++++++--- src/uadk_prov_rsa.c | 14 ++++++--- 7 files changed, 98 insertions(+), 75 deletions(-) diff --git a/src/uadk_prov_aead.c b/src/uadk_prov_aead.c index 4533540..cef0503 100644 --- a/src/uadk_prov_aead.c +++ b/src/uadk_prov_aead.c @@ -293,18 +293,15 @@ static int uadk_prov_aead_dev_init(struct aead_priv_ctx *priv) struct wd_ctx_params cparams = {0}; int ret = UADK_AEAD_SUCCESS; - pthread_atfork(NULL, NULL, uadk_aead_mutex_infork); - pthread_mutex_lock(&aead_mutex); if (aprov.pid == getpid()) - goto mutex_unlock; + return ret; cparams.op_type_num = UADK_AEAD_OP_NUM; cparams.ctx_set_num = &ctx_set_num; cparams.bmp = numa_allocate_nodemask(); if (!cparams.bmp) { - ret = UADK_AEAD_FAIL; UADK_ERR("failed to create nodemask!\n"); - goto mutex_unlock; + return UADK_AEAD_FAIL; } numa_bitmask_setall(cparams.bmp); @@ -312,6 +309,11 @@ static int uadk_prov_aead_dev_init(struct aead_priv_ctx *priv) ctx_set_num.sync_ctx_num = UADK_AEAD_DEF_CTXS; ctx_set_num.async_ctx_num = UADK_AEAD_DEF_CTXS; + pthread_atfork(NULL, NULL, uadk_aead_mutex_infork); + pthread_mutex_lock(&aead_mutex); + if (aprov.pid == getpid()) + goto free_nodemask; + ret = wd_aead_init2_(priv->alg_name, TASK_MIX, SCHED_POLICY_RR, &cparams); if (unlikely(ret)) { ret = UADK_AEAD_FAIL; @@ -319,13 +321,13 @@ static int uadk_prov_aead_dev_init(struct aead_priv_ctx *priv) goto free_nodemask; } - aprov.pid = getpid(); async_register_poll_fn(ASYNC_TASK_AEAD, uadk_aead_poll); + mb(); + aprov.pid = getpid(); free_nodemask: - numa_free_nodemask(cparams.bmp); -mutex_unlock: pthread_mutex_unlock(&aead_mutex); + numa_free_nodemask(cparams.bmp); return ret; } diff --git a/src/uadk_prov_cipher.c b/src/uadk_prov_cipher.c index 0bb4aae..d442d3d 100644 --- a/src/uadk_prov_cipher.c +++ b/src/uadk_prov_cipher.c @@ -528,54 +528,54 @@ static void uadk_cipher_mutex_infork(void) static int uadk_prov_cipher_dev_init(struct cipher_priv_ctx *priv) { - int ret; + struct wd_ctx_params cparams = {0}; + struct wd_ctx_nums *ctx_set_num; + int ret = UADK_P_SUCCESS; - pthread_atfork(NULL, NULL, uadk_cipher_mutex_infork); - pthread_mutex_lock(&cipher_mutex); - if (prov.pid != getpid()) { - struct wd_ctx_nums *ctx_set_num; - struct wd_ctx_params cparams = {0}; - - ctx_set_num = calloc(UADK_CIPHER_OP_NUM, sizeof(*ctx_set_num)); - if (!ctx_set_num) { - UADK_ERR("failed to alloc ctx_set_size!\n"); - ret = UADK_P_FAIL; - goto init_err; - } + if (prov.pid == getpid()) + return ret; - cparams.op_type_num = UADK_CIPHER_OP_NUM; - cparams.ctx_set_num = ctx_set_num; - cparams.bmp = numa_allocate_nodemask(); - if (!cparams.bmp) { - UADK_ERR("failed to create nodemask!\n"); - free(ctx_set_num); - ret = UADK_P_FAIL; - goto init_err; - } + ctx_set_num = calloc(UADK_CIPHER_OP_NUM, sizeof(*ctx_set_num)); + if (!ctx_set_num) { + UADK_ERR("failed to alloc ctx_set_size!\n"); + return UADK_P_FAIL; + } - numa_bitmask_setall(cparams.bmp); + cparams.op_type_num = UADK_CIPHER_OP_NUM; + cparams.ctx_set_num = ctx_set_num; + cparams.bmp = numa_allocate_nodemask(); + if (!cparams.bmp) { + UADK_ERR("failed to create nodemask!\n"); + free(ctx_set_num); + return UADK_P_FAIL; + } - ctx_set_num->sync_ctx_num = UADK_CIPHER_DEF_CTXS; - ctx_set_num->async_ctx_num = UADK_CIPHER_DEF_CTXS; + numa_bitmask_setall(cparams.bmp); - ret = wd_cipher_init2_(priv->alg_name, TASK_MIX, SCHED_POLICY_RR, &cparams); - numa_free_nodemask(cparams.bmp); - free(ctx_set_num); + ctx_set_num->sync_ctx_num = UADK_CIPHER_DEF_CTXS; + ctx_set_num->async_ctx_num = UADK_CIPHER_DEF_CTXS; - if (unlikely(ret)) { - UADK_ERR("failed to init cipher!\n"); - ret = UADK_P_FAIL; - goto init_err; - } + pthread_atfork(NULL, NULL, uadk_cipher_mutex_infork); + pthread_mutex_lock(&cipher_mutex); + if (prov.pid == getpid()) + goto init_err; - prov.pid = getpid(); - async_register_poll_fn(ASYNC_TASK_CIPHER, uadk_cipher_poll); + ret = wd_cipher_init2_(priv->alg_name, TASK_MIX, SCHED_POLICY_RR, &cparams); + if (unlikely(ret)) { + UADK_ERR("failed to init cipher!\n"); + ret = UADK_P_FAIL; + goto init_err; } + async_register_poll_fn(ASYNC_TASK_CIPHER, uadk_cipher_poll); + mb(); + prov.pid = getpid(); ret = UADK_P_SUCCESS; init_err: pthread_mutex_unlock(&cipher_mutex); + numa_free_nodemask(cparams.bmp); + free(ctx_set_num); return ret; } diff --git a/src/uadk_prov_dh.c b/src/uadk_prov_dh.c index a89e555..2d96a1d 100644 --- a/src/uadk_prov_dh.c +++ b/src/uadk_prov_dh.c @@ -658,18 +658,25 @@ static int uadk_prov_dh_init(void) char alg_name[] = "dh"; int ret; - pthread_atfork(NULL, NULL, uadk_prov_dh_mutex_infork); - pthread_mutex_lock(&dh_mutex); if (g_dh_prov.pid != getpid()) { + pthread_atfork(NULL, NULL, uadk_prov_dh_mutex_infork); + pthread_mutex_lock(&dh_mutex); + if (g_dh_prov.pid == getpid()) { + pthread_mutex_unlock(&dh_mutex); + return UADK_P_INIT_SUCCESS; + } + ret = wd_dh_init2(alg_name, SCHED_POLICY_RR, TASK_HW); if (unlikely(ret)) { pthread_mutex_unlock(&dh_mutex); return ret; } - g_dh_prov.pid = getpid(); + async_register_poll_fn(ASYNC_TASK_DH, uadk_prov_dh_poll); + mb(); + g_dh_prov.pid = getpid(); + pthread_mutex_unlock(&dh_mutex); } - pthread_mutex_unlock(&dh_mutex); return UADK_P_INIT_SUCCESS; } diff --git a/src/uadk_prov_digest.c b/src/uadk_prov_digest.c index d9c5ae3..1a5cc81 100644 --- a/src/uadk_prov_digest.c +++ b/src/uadk_prov_digest.c @@ -345,18 +345,15 @@ static int uadk_prov_digest_dev_init(struct digest_priv_ctx *priv) struct wd_ctx_nums ctx_set_num; int ret = UADK_DIGEST_SUCCESS; - pthread_atfork(NULL, NULL, uadk_digest_mutex_infork); - pthread_mutex_lock(&digest_mutex); if (dprov.pid == getpid()) - goto mutex_unlock; + return ret; cparams.op_type_num = UADK_DIGEST_OP_NUM; cparams.ctx_set_num = &ctx_set_num; cparams.bmp = numa_allocate_nodemask(); if (!cparams.bmp) { - ret = UADK_DIGEST_FAIL; UADK_ERR("failed to create nodemask!\n"); - goto mutex_unlock; + return UADK_DIGEST_FAIL; } numa_bitmask_setall(cparams.bmp); @@ -364,6 +361,11 @@ static int uadk_prov_digest_dev_init(struct digest_priv_ctx *priv) ctx_set_num.sync_ctx_num = UADK_DIGEST_DEF_CTXS; ctx_set_num.async_ctx_num = UADK_DIGEST_DEF_CTXS; + pthread_atfork(NULL, NULL, uadk_digest_mutex_infork); + pthread_mutex_lock(&digest_mutex); + if (dprov.pid == getpid()) + goto free_nodemask; + ret = wd_digest_init2_(priv->alg_name, TASK_MIX, SCHED_POLICY_RR, &cparams); if (unlikely(ret && ret != -WD_EEXIST)) { UADK_ERR("uadk failed to initialize digest dev, ret = %d\n", ret); @@ -371,13 +373,13 @@ static int uadk_prov_digest_dev_init(struct digest_priv_ctx *priv) } ret = UADK_DIGEST_SUCCESS; - dprov.pid = getpid(); async_register_poll_fn(ASYNC_TASK_DIGEST, uadk_digest_poll); + mb(); + dprov.pid = getpid(); free_nodemask: - numa_free_nodemask(cparams.bmp); -mutex_unlock: pthread_mutex_unlock(&digest_mutex); + numa_free_nodemask(cparams.bmp); return ret; } diff --git a/src/uadk_prov_hmac.c b/src/uadk_prov_hmac.c index e1a8b10..0c53d12 100644 --- a/src/uadk_prov_hmac.c +++ b/src/uadk_prov_hmac.c @@ -412,24 +412,19 @@ static int uadk_prov_hmac_dev_init(struct hmac_priv_ctx *priv) int ret = UADK_P_SUCCESS; const char *alg_name; - pthread_atfork(NULL, NULL, uadk_hmac_mutex_infork); - pthread_mutex_lock(&hmac_mutex); if (hprov.pid == getpid()) - goto mutex_unlock; + return ret; alg_name = get_uadk_alg_name(priv->alg_id); - if (!alg_name) { - ret = UADK_P_FAIL; - goto mutex_unlock; - } + if (!alg_name) + return UADK_P_FAIL; cparams.op_type_num = UADK_DIGEST_OP_NUM; cparams.ctx_set_num = &ctx_set_num; cparams.bmp = numa_allocate_nodemask(); if (!cparams.bmp) { - ret = UADK_P_FAIL; UADK_ERR("failed to create nodemask!\n"); - goto mutex_unlock; + return UADK_P_FAIL; } numa_bitmask_setall(cparams.bmp); @@ -437,6 +432,11 @@ static int uadk_prov_hmac_dev_init(struct hmac_priv_ctx *priv) ctx_set_num.sync_ctx_num = UADK_DIGEST_DEF_CTXS; ctx_set_num.async_ctx_num = UADK_DIGEST_DEF_CTXS; + pthread_atfork(NULL, NULL, uadk_hmac_mutex_infork); + pthread_mutex_lock(&hmac_mutex); + if (hprov.pid == getpid()) + goto free_nodemask; + ret = wd_digest_init2_((char *)alg_name, TASK_MIX, SCHED_POLICY_RR, &cparams); if (unlikely(ret && ret != -WD_EEXIST)) { UADK_ERR("uadk failed to initialize hmac, ret = %d\n", ret); @@ -444,13 +444,13 @@ static int uadk_prov_hmac_dev_init(struct hmac_priv_ctx *priv) } ret = UADK_P_SUCCESS; - hprov.pid = getpid(); async_register_poll_fn(ASYNC_TASK_HMAC, uadk_hmac_poll); + mb(); + hprov.pid = getpid(); free_nodemask: - numa_free_nodemask(cparams.bmp); -mutex_unlock: pthread_mutex_unlock(&hmac_mutex); + numa_free_nodemask(cparams.bmp); return ret; } diff --git a/src/uadk_prov_pkey.c b/src/uadk_prov_pkey.c index 9597e7f..994ea07 100644 --- a/src/uadk_prov_pkey.c +++ b/src/uadk_prov_pkey.c @@ -815,18 +815,24 @@ int uadk_prov_ecc_init(const char *alg_name) { int ret; - pthread_atfork(NULL, NULL, uadk_prov_ecc_mutex_infork); - pthread_mutex_lock(&ecc_mutex); if (g_ecc_prov.pid != getpid()) { + pthread_atfork(NULL, NULL, uadk_prov_ecc_mutex_infork); + pthread_mutex_lock(&ecc_mutex); + if (g_ecc_prov.pid == getpid()) { + pthread_mutex_unlock(&ecc_mutex); + return UADK_P_SUCCESS; + } + ret = wd_ecc_init2((char *)alg_name, SCHED_POLICY_RR, TASK_HW); if (unlikely(ret)) { pthread_mutex_unlock(&ecc_mutex); return UADK_P_FAIL; } - g_ecc_prov.pid = getpid(); async_register_poll_fn(ASYNC_TASK_ECC, uadk_prov_ecc_poll); + mb(); + g_ecc_prov.pid = getpid(); + pthread_mutex_unlock(&ecc_mutex); } - pthread_mutex_unlock(&ecc_mutex); return UADK_P_SUCCESS; } diff --git a/src/uadk_prov_rsa.c b/src/uadk_prov_rsa.c index a0bb26e..f77f718 100644 --- a/src/uadk_prov_rsa.c +++ b/src/uadk_prov_rsa.c @@ -213,18 +213,24 @@ int uadk_prov_rsa_init(void) char alg_name[] = "rsa"; int ret; - pthread_atfork(NULL, NULL, uadk_rsa_mutex_infork); - pthread_mutex_lock(&rsa_mutex); if (g_rsa_prov.pid != getpid()) { + pthread_atfork(NULL, NULL, uadk_rsa_mutex_infork); + pthread_mutex_lock(&rsa_mutex); + if (g_rsa_prov.pid == getpid()) { + pthread_mutex_unlock(&rsa_mutex); + return UADK_P_INIT_SUCCESS; + } + ret = wd_rsa_init2(alg_name, SCHED_POLICY_RR, TASK_MIX); if (unlikely(ret)) { pthread_mutex_unlock(&rsa_mutex); return ret; } - g_rsa_prov.pid = getpid(); async_register_poll_fn(ASYNC_TASK_RSA, uadk_rsa_env_poll); + mb(); + g_rsa_prov.pid = getpid(); + pthread_mutex_unlock(&rsa_mutex); } - pthread_mutex_unlock(&rsa_mutex); return UADK_P_INIT_SUCCESS; } -- 2.43.0