[PATCH 01/11 v2] uadk_engine: cleanup code style of async functions

8 Oct 2023

Cleanup the return value and judgment code style
of async mode functions.

Signed-off-by: Zhiqi Song <songzhiqi1@huawei.com>
---
 src/uadk_async.c | 132 +++++++++++++++++++++++------------------------
 src/uadk_async.h |   3 ++
 2 files changed, 68 insertions(+), 67 deletions(-)

diff --git a/src/uadk_async.c b/src/uadk_async.c
index 9251238..3462d67 100644
--- a/src/uadk_async.c
+++ b/src/uadk_async.c
@@ -48,67 +48,65 @@ static void async_fd_cleanup(ASYNC_WAIT_CTX *ctx, const void *key,
 int async_setup_async_event_notification(struct async_op *op)
 {
 	ASYNC_WAIT_CTX *waitctx;
+	void *custom = NULL;
 	OSSL_ASYNC_FD efd;
-	void *custom;
 
 	memset(op, 0, sizeof(struct async_op));
+
 	op->job = ASYNC_get_current_job();
-	if (op->job == NULL)
-		return 1;
+	if (!op->job)
+		return DO_SYNC;
 
 	waitctx = ASYNC_get_wait_ctx(op->job);
-	if (waitctx == NULL)
-		return 0;
+	if (!waitctx)
+		return UADK_E_FAIL;
 
-	if (ASYNC_WAIT_CTX_get_fd(waitctx, engine_uadk_id,
-				  &efd, &custom) == 0) {
+	if (!ASYNC_WAIT_CTX_get_fd(waitctx, engine_uadk_id, &efd, &custom)) {
 		efd = eventfd(0, EFD_NONBLOCK);
 		if (efd == -1)
-			return 0;
+			return UADK_E_FAIL;
 
-		if (ASYNC_WAIT_CTX_set_wait_fd(waitctx, engine_uadk_id, efd,
-					       custom, async_fd_cleanup) == 0) {
+		if (!ASYNC_WAIT_CTX_set_wait_fd(waitctx, engine_uadk_id, efd,
+						custom, async_fd_cleanup)) {
 			async_fd_cleanup(waitctx, engine_uadk_id, efd, NULL);
-			return 0;
+			return UADK_E_FAIL;
 		}
 	}
 
-	return 1;
+	return UADK_E_SUCCESS;
 }
 
 int async_clear_async_event_notification(void)
 {
-	ASYNC_JOB *job;
 	ASYNC_WAIT_CTX *waitctx;
+	void *custom = NULL;
 	OSSL_ASYNC_FD efd;
 	size_t num_add_fds;
 	size_t num_del_fds;
-	void *custom = NULL;
+	ASYNC_JOB *job;
 
 	job = ASYNC_get_current_job();
-	if (job == NULL)
-		return 0;
+	if (!job)
+		return UADK_E_FAIL;
 
 	waitctx = ASYNC_get_wait_ctx(job);
-	if (waitctx == NULL)
-		return 0;
+	if (!waitctx)
+		return UADK_E_FAIL;
 
-	if (ASYNC_WAIT_CTX_get_changed_fds(waitctx, NULL, &num_add_fds,
-					   NULL, &num_del_fds) == 0)
-		return 0;
+	if (!ASYNC_WAIT_CTX_get_changed_fds(waitctx, NULL, &num_add_fds, NULL, &num_del_fds))
+		return UADK_E_FAIL;
 
 	if (num_add_fds > 0) {
-		if (ASYNC_WAIT_CTX_get_fd(waitctx, engine_uadk_id,
-					  &efd, &custom) == 0)
-			return 0;
+		if (!ASYNC_WAIT_CTX_get_fd(waitctx, engine_uadk_id, &efd, &custom))
+			return UADK_E_FAIL;
 
 		async_fd_cleanup(waitctx, engine_uadk_id, efd, NULL);
 
-		if (ASYNC_WAIT_CTX_clear_fd(waitctx, engine_uadk_id) == 0)
-			return 0;
+		if (!ASYNC_WAIT_CTX_clear_fd(waitctx, engine_uadk_id))
+			return UADK_E_FAIL;
 	}
 
-	return 1;
+	return UADK_E_SUCCESS;
 }
 
 static void async_poll_task_free(void)
@@ -120,11 +118,11 @@ static void async_poll_task_free(void)
 	uadk_e_set_async_poll_state(DISABLE_ASYNC_POLLING);
 
 	error = pthread_mutex_lock(&poll_queue.async_task_mutex);
-	if (error != 0)
+	if (error)
 		return;
 
 	task = poll_queue.head;
-	if (task != NULL)
+	if (task)
 		OPENSSL_free(task);
 
 	poll_queue.head = NULL;
@@ -143,13 +141,13 @@ static int async_get_poll_task(int *id)
 	while (!poll_queue.status[idx]) {
 		idx = (idx + 1) % ASYNC_QUEUE_TASK_NUM;
 		if (cnt++ == ASYNC_QUEUE_TASK_NUM)
-			return 0;
+			return UADK_E_FAIL;
 	}
 
 	*id = idx;
 	poll_queue.rid = (idx + 1) % ASYNC_QUEUE_TASK_NUM;
 
-	return 1;
+	return UADK_E_SUCCESS;
 }
 
 static struct async_poll_task *async_get_queue_task(void)
@@ -158,11 +156,11 @@ static struct async_poll_task *async_get_queue_task(void)
 	struct async_poll_task *task_queue;
 	int idx, ret;
 
-	if (pthread_mutex_lock(&poll_queue.async_task_mutex) != 0)
+	if (pthread_mutex_lock(&poll_queue.async_task_mutex))
 		return NULL;
 
 	ret = async_get_poll_task(&idx);
-	if (!ret)
+	if (ret == UADK_E_FAIL)
 		goto err;
 
 	task_queue = poll_queue.head;
@@ -170,10 +168,10 @@ static struct async_poll_task *async_get_queue_task(void)
 	poll_queue.is_recv = 0;
 
 err:
-	if (pthread_mutex_unlock(&poll_queue.async_task_mutex) != 0)
+	if (pthread_mutex_unlock(&poll_queue.async_task_mutex))
 		return NULL;
 
-	if (cur_task && cur_task->op == NULL)
+	if (cur_task && !cur_task->op)
 		return NULL;
 
 	return cur_task;
@@ -181,7 +179,7 @@ err:
 
 void async_free_poll_task(int id, bool is_cb)
 {
-	if (pthread_mutex_lock(&poll_queue.async_task_mutex) != 0)
+	if (pthread_mutex_lock(&poll_queue.async_task_mutex))
 		return;
 
 	poll_queue.status[id] = 0;
@@ -189,7 +187,7 @@ void async_free_poll_task(int id, bool is_cb)
 	if (is_cb)
 		poll_queue.is_recv = 1;
 
-	if (pthread_mutex_unlock(&poll_queue.async_task_mutex) != 0)
+	if (pthread_mutex_unlock(&poll_queue.async_task_mutex))
 		return;
 
 	(void)sem_post(&poll_queue.empty_sem);
@@ -202,17 +200,17 @@ int async_get_free_task(int *id)
 	int idx, ret;
 	int cnt = 0;
 
-	if (sem_wait(&poll_queue.empty_sem) != 0)
-		return 0;
+	if (sem_wait(&poll_queue.empty_sem))
+		return UADK_E_FAIL;
 
-	if (pthread_mutex_lock(&poll_queue.async_task_mutex) != 0)
-		return 0;
+	if (pthread_mutex_lock(&poll_queue.async_task_mutex))
+		return UADK_E_FAIL;
 
 	idx = poll_queue.sid;
 	while (poll_queue.status[idx]) {
 		idx = (idx + 1) % ASYNC_QUEUE_TASK_NUM;
 		if (cnt++ == ASYNC_QUEUE_TASK_NUM) {
-			ret = 0;
+			ret = UADK_E_FAIL;
 			goto out;
 		}
 	}
@@ -223,16 +221,16 @@ int async_get_free_task(int *id)
 	task_queue = poll_queue.head;
 	task = &task_queue[idx];
 	if (!task) {
-		ret = 0;
+		ret = UADK_E_FAIL;
 		goto out;
 	}
 
 	task->op = NULL;
-	ret = 1;
+	ret = UADK_E_SUCCESS;
 
 out:
-	if (pthread_mutex_unlock(&poll_queue.async_task_mutex) != 0)
-		return 0;
+	if (pthread_mutex_unlock(&poll_queue.async_task_mutex))
+		return UADK_E_FAIL;
 
 	return ret;
 }
@@ -246,7 +244,7 @@ static int async_add_poll_task(void *ctx, struct async_op *op, enum task_type ty
 	task_queue = poll_queue.head;
 	task = &task_queue[id];
 	if (!task)
-		return 0;
+		return UADK_E_FAIL;
 
 	task->ctx = ctx;
 	task->type = type;
@@ -254,9 +252,9 @@ static int async_add_poll_task(void *ctx, struct async_op *op, enum task_type ty
 
 	ret = sem_post(&poll_queue.full_sem);
 	if (ret)
-		return 0;
+		return UADK_E_FAIL;
 
-	return 1;
+	return UADK_E_SUCCESS;
 }
 
 int async_pause_job(void *ctx, struct async_op *op, enum task_type type, int id)
@@ -268,19 +266,19 @@ int async_pause_job(void *ctx, struct async_op *op, enum task_type type, int id)
 	int ret;
 
 	ret = async_add_poll_task(ctx, op, type, id);
-	if (ret == 0)
+	if (ret == UADK_E_FAIL)
 		return ret;
 
 	waitctx = ASYNC_get_wait_ctx((ASYNC_JOB *)op->job);
-	if (waitctx == NULL)
-		return 0;
+	if (!waitctx)
+		return UADK_E_FAIL;
 
 	do {
-		if (ASYNC_pause_job() == 0)
-			return 0;
+		if (!ASYNC_pause_job())
+			return UADK_E_FAIL;
 
 		ret = ASYNC_WAIT_CTX_get_fd(waitctx, engine_uadk_id, &efd, &custom);
-		if (ret <= 0)
+		if (ret == UADK_E_FAIL)
 			continue;
 
 		if (read(efd, &buf, sizeof(uint64_t)) == -1) {
@@ -298,13 +296,13 @@ int async_wake_job(ASYNC_JOB *job)
 {
 	ASYNC_WAIT_CTX *waitctx;
 	OSSL_ASYNC_FD efd;
-	void *custom;
 	uint64_t buf = 1;
+	void *custom;
 	int ret;
 
 	waitctx = ASYNC_get_wait_ctx(job);
-	if (waitctx == NULL)
-		return 0;
+	if (!waitctx)
+		return UADK_E_FAIL;
 
 	ret = ASYNC_WAIT_CTX_get_fd(waitctx, engine_uadk_id, &efd, &custom);
 	if (ret > 0) {
@@ -332,7 +330,7 @@ static void *async_poll_process_func(void *args)
 	int ret, idx;
 
 	while (uadk_e_get_async_poll_state()) {
-		if (sem_wait(&poll_queue.full_sem) != 0) {
+		if (sem_wait(&poll_queue.full_sem)) {
 			if (errno == EINTR) {
 				/* sem_wait is interrupted by interrupt, continue */
 				continue;
@@ -340,7 +338,7 @@ static void *async_poll_process_func(void *args)
 		}
 
 		task = async_get_queue_task();
-		if (task == NULL) {
+		if (!task) {
 			(void)sem_post(&poll_queue.full_sem);
 			usleep(1);
 			continue;
@@ -368,19 +366,19 @@ int async_module_init(void)
 	memset(&poll_queue, 0, sizeof(struct async_poll_queue));
 
 	if (pthread_mutex_init(&(poll_queue.async_task_mutex), NULL) < 0)
-		return 0;
+		return UADK_E_FAIL;
 
 	poll_queue.head = malloc(sizeof(struct async_poll_task) * ASYNC_QUEUE_TASK_NUM);
-	if (poll_queue.head == NULL)
-		return 0;
+	if (!poll_queue.head)
+		return UADK_E_FAIL;
 
 	memset(poll_queue.head, 0,
 	       sizeof(struct async_poll_task) * ASYNC_QUEUE_TASK_NUM);
 
-	if (sem_init(&poll_queue.empty_sem, 0, ASYNC_QUEUE_TASK_NUM) != 0)
+	if (sem_init(&poll_queue.empty_sem, 0, ASYNC_QUEUE_TASK_NUM))
 		goto err;
 
-	if (sem_init(&poll_queue.full_sem, 0, 0) != 0)
+	if (sem_init(&poll_queue.full_sem, 0, 0))
 		goto err;
 
 	uadk_e_set_async_poll_state(ENABLE_ASYNC_POLLING);
@@ -393,9 +391,9 @@ int async_module_init(void)
 	poll_queue.thread_id = thread_id;
 	OPENSSL_atexit(async_poll_task_free);
 
-	return 1;
+	return UADK_E_SUCCESS;
 
 err:
 	async_poll_task_free();
-	return 0;
+	return UADK_E_FAIL;
 }
diff --git a/src/uadk_async.h b/src/uadk_async.h
index 7e75951..8c26777 100644
--- a/src/uadk_async.h
+++ b/src/uadk_async.h
@@ -22,6 +22,9 @@
 #include <openssl/async.h>
 
 #define ASYNC_QUEUE_TASK_NUM	1024
+#define UADK_E_SUCCESS		1
+#define UADK_E_FAIL		0
+#define DO_SYNC			1
 
 struct async_op {
 	ASYNC_JOB *job;
-- 
2.30.0

    

Zhiqi Song

tags

participants (1)