#ifdef ASYNC_NULL
-int async_global_init(void)
-{
- return 0;
-}
-
void async_local_cleanup(void)
{
}
-void async_global_cleanup(void)
-{
-}
-
#endif
} async_fibre;
-# define async_set_ctx(nctx) 0
-# define async_arch_get_ctx() ((async_ctx *)NULL)
# define async_fibre_swapcontext(o,n,r) 0
# define async_fibre_makecontext(c) 0
# define async_fibre_free(f)
# define async_fibre_init_dispatcher(f)
-# define async_get_pool() NULL
-# define async_set_pool(p) 0
#endif
# include <stddef.h>
# include <unistd.h>
-pthread_key_t posixctx;
-pthread_key_t posixpool;
-
#define STACKSIZE 32768
-int async_global_init(void)
-{
- if (pthread_key_create(&posixctx, NULL) != 0
- || pthread_key_create(&posixpool, NULL) != 0)
- return 0;
-
- return 1;
-}
-
void async_local_cleanup(void)
{
}
-void async_global_cleanup(void)
-{
-}
int async_fibre_makecontext(async_fibre *fibre)
{
# include <setjmp.h>
# include "e_os.h"
-extern pthread_key_t posixctx;
-extern pthread_key_t posixpool;
-
typedef struct async_fibre_st {
ucontext_t fibre;
jmp_buf env;
int env_init;
} async_fibre;
-# define async_set_ctx(nctx) (pthread_setspecific(posixctx , (nctx)) == 0)
-# define async_arch_get_ctx() ((async_ctx *)pthread_getspecific(posixctx))
-# define async_set_pool(p) (pthread_setspecific(posixpool , (p)) == 0)
-# define async_get_pool() ((async_pool *)pthread_getspecific(posixpool))
-
static inline int async_fibre_swapcontext(async_fibre *o, async_fibre *n, int r)
{
o->env_init = 1;
# include <windows.h>
# include "internal/cryptlib.h"
-struct winpool {
- STACK_OF(ASYNC_JOB) *pool;
- size_t curr_size;
- size_t max_size;
-};
-
-static DWORD asyncwinpool = 0;
-static DWORD asyncwinctx = 0;
-
-
-void async_start_func(void);
-
-int async_global_init(void)
-{
- asyncwinpool = TlsAlloc();
- asyncwinctx = TlsAlloc();
- if (asyncwinpool == TLS_OUT_OF_INDEXES
- || asyncwinctx == TLS_OUT_OF_INDEXES) {
- if (asyncwinpool != TLS_OUT_OF_INDEXES) {
- TlsFree(asyncwinpool);
- }
- if (asyncwinctx != TLS_OUT_OF_INDEXES) {
- TlsFree(asyncwinctx);
- }
- return 0;
- }
- return 1;
-}
-
void async_local_cleanup(void)
{
- async_ctx *ctx = async_arch_get_ctx();
+ async_ctx *ctx = async_get_ctx();
if (ctx != NULL) {
async_fibre *fibre = &ctx->dispatcher;
if(fibre != NULL && fibre->fibre != NULL && fibre->converted) {
}
}
-void async_global_cleanup(void)
-{
- TlsFree(asyncwinpool);
- TlsFree(asyncwinctx);
- asyncwinpool = 0;
- asyncwinctx = 0;
-}
-
int async_fibre_init_dispatcher(async_fibre *fibre)
{
fibre->fibre = ConvertThreadToFiber(NULL);
async_start_func();
}
-async_pool *async_get_pool(void)
-{
- return (async_pool *)TlsGetValue(asyncwinpool);
-}
-
-
-int async_set_pool(async_pool *pool)
-{
- return TlsSetValue(asyncwinpool, (LPVOID)pool) != 0;
-}
-
-async_ctx *async_arch_get_ctx(void)
-{
- return (async_ctx *)TlsGetValue(asyncwinctx);
-}
-
-int async_set_ctx(async_ctx *ctx)
-{
- return TlsSetValue(asyncwinctx, (LPVOID)ctx) != 0;
-}
-
#endif
((c)->fibre = CreateFiber(0, async_start_func_win, 0))
# define async_fibre_free(f) (DeleteFiber((f)->fibre))
-async_ctx *async_arch_get_ctx(void);
-int async_set_ctx(async_ctx *ctx);
-
int async_fibre_init_dispatcher(async_fibre *fibre);
VOID CALLBACK async_start_func_win(PVOID unused);
-async_pool *async_get_pool(void);
-int async_set_pool(async_pool *pool);
-
#endif
/* 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>
#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)
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;
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)
ctx = async_get_ctx();
- if (!async_set_ctx(NULL))
+ if (!CRYPTO_THREAD_set_local(&ctxkey, NULL))
return 0;
OPENSSL_free(ctx);
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.
*/
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);
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);
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;
}
+/* TODO: FIXME: This needs to be called by something!!! */
+void async_deinit(void);
+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;
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;
}
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)
size_t max_size;
};
-int async_global_init(void);
void async_local_cleanup(void);
-void async_global_cleanup(void);
void async_start_func(void);
+async_ctx *async_get_ctx(void);
void async_wait_ctx_reset_counts(ASYNC_WAIT_CTX *ctx);