Ensure Async is deinited properly

[openssl.git] / crypto / async / async.c

diff --git a/crypto/async/async.c b/crypto/async/async.c
index ebc5ebbe93b43e0a49097cbebf992cddfcaf39ab..b4ba5618881789869e30df438463d82256741550 100644 (file)
--- a/crypto/async/async.c
+++ b/crypto/async/async.c
@@ -61,6 +61,7 @@
 /* This must be the first #include file */
 #include "async_locl.h"
 
+#include <internal/threads.h>
 #include <openssl/err.h>
 #include <internal/cryptlib_int.h>
 #include <string.h>
@@ -70,6 +71,9 @@
 #define ASYNC_JOB_PAUSED    2
 #define ASYNC_JOB_STOPPING  3
 
+static CRYPTO_THREAD_LOCAL ctxkey;
+static CRYPTO_THREAD_LOCAL poolkey;
+
 static void async_free_pool_internal(async_pool *pool);
 
 static async_ctx *async_ctx_new(void)
@@ -85,7 +89,7 @@ static async_ctx *async_ctx_new(void)
     async_fibre_init_dispatcher(&nctx->dispatcher);
     nctx->currjob = NULL;
     nctx->blocked = 0;
-    if (!async_set_ctx(nctx))
+    if (!CRYPTO_THREAD_set_local(&ctxkey, nctx))
         goto err;
 
     return nctx;
@@ -95,11 +99,12 @@ err:
     return NULL;
 }
 
-static async_ctx *async_get_ctx(void)
+async_ctx *async_get_ctx(void)
 {
     if (!OPENSSL_init_crypto(OPENSSL_INIT_ASYNC, NULL))
         return NULL;
-    return async_arch_get_ctx();
+
+    return (async_ctx *)CRYPTO_THREAD_get_local(&ctxkey);
 }
 
 static int async_ctx_free(void)
@@ -108,7 +113,7 @@ static int async_ctx_free(void)
 
     ctx = async_get_ctx();
 
-    if (!async_set_ctx(NULL))
+    if (!CRYPTO_THREAD_set_local(&ctxkey, NULL))
         return 0;
 
     OPENSSL_free(ctx);
@@ -119,26 +124,14 @@ static int async_ctx_free(void)
 static ASYNC_JOB *async_job_new(void)
 {
     ASYNC_JOB *job = NULL;
-    OSSL_ASYNC_FD pipefds[2];
 
-    job = OPENSSL_malloc(sizeof (ASYNC_JOB));
+    job = OPENSSL_zalloc(sizeof (ASYNC_JOB));
     if (job == NULL) {
         ASYNCerr(ASYNC_F_ASYNC_JOB_NEW, ERR_R_MALLOC_FAILURE);
         return NULL;
     }
 
-    if (!async_pipe(pipefds)) {
-        OPENSSL_free(job);
-        ASYNCerr(ASYNC_F_ASYNC_JOB_NEW, ASYNC_R_CANNOT_CREATE_WAIT_PIPE);
-        return NULL;
-    }
-
-    job->wake_set = 0;
-    job->wait_fd = pipefds[0];
-    job->wake_fd = pipefds[1];
-
     job->status = ASYNC_JOB_RUNNING;
-    job->funcargs = NULL;
 
     return job;
 }
@@ -148,8 +141,6 @@ static void async_job_free(ASYNC_JOB *job)
     if (job != NULL) {
         OPENSSL_free(job->funcargs);
         async_fibre_free(&job->fibrectx);
-        async_close_fd(job->wait_fd);
-        async_close_fd(job->wake_fd);
         OPENSSL_free(job);
     }
 }
@@ -158,7 +149,7 @@ static ASYNC_JOB *async_get_pool_job(void) {
     ASYNC_JOB *job;
     async_pool *pool;
 
-    pool = async_get_pool();
+    pool = (async_pool *)CRYPTO_THREAD_get_local(&poolkey);
     if (pool == NULL) {
         /*
          * Pool has not been initialised, so init with the defaults, i.e.
@@ -166,7 +157,7 @@ static ASYNC_JOB *async_get_pool_job(void) {
          */
         if (ASYNC_init_thread(0, 0) == 0)
             return NULL;
-        pool = async_get_pool();
+        pool = (async_pool *)CRYPTO_THREAD_get_local(&poolkey);
     }
 
     job = sk_ASYNC_JOB_pop(pool->jobs);
@@ -190,7 +181,7 @@ static ASYNC_JOB *async_get_pool_job(void) {
 static void async_release_job(ASYNC_JOB *job) {
     async_pool *pool;
 
-    pool = async_get_pool();
+    pool = (async_pool *)CRYPTO_THREAD_get_local(&poolkey);
     OPENSSL_free(job->funcargs);
     job->funcargs = NULL;
     sk_ASYNC_JOB_push(pool->jobs, job);
@@ -219,8 +210,8 @@ void async_start_func(void)
     }
 }
 
-int ASYNC_start_job(ASYNC_JOB **job, int *ret, int (*func)(void *),
-                         void *args, size_t size)
+int ASYNC_start_job(ASYNC_JOB **job, ASYNC_WAIT_CTX *wctx, int *ret,
+                    int (*func)(void *), void *args, size_t size)
 {
     async_ctx *ctx = async_get_ctx();
     if (ctx == NULL)
@@ -237,6 +228,7 @@ int ASYNC_start_job(ASYNC_JOB **job, int *ret, int (*func)(void *),
         if (ctx->currjob != NULL) {
             if (ctx->currjob->status == ASYNC_JOB_STOPPING) {
                 *ret = ctx->currjob->ret;
+                ctx->currjob->waitctx = NULL;
                 async_release_job(ctx->currjob);
                 ctx->currjob = NULL;
                 *job = NULL;
@@ -289,6 +281,7 @@ int ASYNC_start_job(ASYNC_JOB **job, int *ret, int (*func)(void *),
         }
 
         ctx->currjob->func = func;
+        ctx->currjob->waitctx = wctx;
         if (!async_fibre_swapcontext(&ctx->dispatcher,
                 &ctx->currjob->fibrectx, 1)) {
             ASYNCerr(ASYNC_F_ASYNC_START_JOB, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
@@ -303,7 +296,6 @@ err:
     return ASYNC_ERR;
 }
 
-
 int ASYNC_pause_job(void)
 {
     ASYNC_JOB *job;
@@ -327,6 +319,8 @@ int ASYNC_pause_job(void)
         ASYNCerr(ASYNC_F_ASYNC_PAUSE_JOB, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
         return 0;
     }
+    /* Reset counts of added and deleted fds */
+    async_wait_ctx_reset_counts(job->waitctx);
 
     return 1;
 }
@@ -346,12 +340,23 @@ static void async_empty_pool(async_pool *pool)
 
 int async_init(void)
 {
-    if (!async_global_init())
+    if (!CRYPTO_THREAD_init_local(&ctxkey, NULL))
         return 0;
 
+    if (!CRYPTO_THREAD_init_local(&poolkey, NULL)) {
+        CRYPTO_THREAD_cleanup_local(&ctxkey);
+        return 0;
+    }
+
     return 1;
 }
 
+void async_deinit(void)
+{
+    CRYPTO_THREAD_cleanup_local(&ctxkey);
+    CRYPTO_THREAD_cleanup_local(&poolkey);
+}
+
 int ASYNC_init_thread(size_t max_size, size_t init_size)
 {
     async_pool *pool;
@@ -401,7 +406,7 @@ int ASYNC_init_thread(size_t max_size, size_t init_size)
         curr_size++;
     }
     pool->curr_size = curr_size;
-    if (!async_set_pool(pool)) {
+    if (!CRYPTO_THREAD_set_local(&poolkey, pool)) {
         ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ASYNC_R_FAILED_TO_SET_POOL);
         goto err;
     }
@@ -420,14 +425,14 @@ static void async_free_pool_internal(async_pool *pool)
     async_empty_pool(pool);
     sk_ASYNC_JOB_free(pool->jobs);
     OPENSSL_free(pool);
-    (void)async_set_pool(NULL);
+    CRYPTO_THREAD_set_local(&poolkey, NULL);
     async_local_cleanup();
     async_ctx_free();
 }
 
 void ASYNC_cleanup_thread(void)
 {
-    async_free_pool_internal(async_get_pool());
+    async_free_pool_internal((async_pool *)CRYPTO_THREAD_get_local(&poolkey));
 }
 
 ASYNC_JOB *ASYNC_get_current_job(void)
@@ -441,28 +446,9 @@ ASYNC_JOB *ASYNC_get_current_job(void)
     return ctx->currjob;
 }
 
-OSSL_ASYNC_FD ASYNC_get_wait_fd(ASYNC_JOB *job)
-{
-    return job->wait_fd;
-}
-
-void ASYNC_wake(ASYNC_JOB *job)
+ASYNC_WAIT_CTX *ASYNC_get_wait_ctx(ASYNC_JOB *job)
 {
-    char dummy = 0;
-
-    if (job->wake_set)
-        return;
-    async_write1(job->wake_fd, &dummy);
-    job->wake_set = 1;
-}
-
-void ASYNC_clear_wake(ASYNC_JOB *job)
-{
-    char dummy = 0;
-    if (!job->wake_set)
-        return;
-    async_read1(job->wait_fd, &dummy);
-    job->wake_set = 0;
+    return job->waitctx;
 }
 
 void ASYNC_block_pause(void)