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

/*
 * Copyright 2015-2022 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

/*
 * Without this we start getting longjmp crashes because it thinks we're jumping
 * up the stack when in fact we are jumping to an entirely different stack. The
 * cost of this is not having certain buffer overrun/underrun checks etc for
 * this source file :-(
 */
#undef _FORTIFY_SOURCE

/* This must be the first #include file */
#include "async_local.h"
#include "internal/threads_common.h"

#include <openssl/err.h>
#include "crypto/cryptlib.h"
#include <string.h>

#define ASYNC_JOB_RUNNING   0
#define ASYNC_JOB_PAUSING   1
#define ASYNC_JOB_PAUSED    2
#define ASYNC_JOB_STOPPING  3

static void async_delete_thread_state(void *arg);

static async_ctx *async_ctx_new(void)
{
    async_ctx *nctx;

    if (!ossl_init_thread_start(NULL, NULL, async_delete_thread_state))
        return NULL;

    nctx = OPENSSL_malloc(sizeof(*nctx));
    if (nctx == NULL)
        goto err;

    async_fibre_init_dispatcher(&nctx->dispatcher);
    nctx->currjob = NULL;
    nctx->blocked = 0;
    if (!CRYPTO_THREAD_set_local_ex(CRYPTO_THREAD_LOCAL_ASYNC_CTX_KEY,
                                    CRYPTO_THREAD_NO_CONTEXT, nctx))
        goto err;

    return nctx;
err:
    OPENSSL_free(nctx);

    return NULL;
}

async_ctx *async_get_ctx(void)
{
    return (async_ctx *)CRYPTO_THREAD_get_local_ex(CRYPTO_THREAD_LOCAL_ASYNC_CTX_KEY,
                                                   CRYPTO_THREAD_NO_CONTEXT);
}

static int async_ctx_free(void)
{
    async_ctx *ctx;

    ctx = async_get_ctx();

    if (!CRYPTO_THREAD_set_local_ex(CRYPTO_THREAD_LOCAL_ASYNC_CTX_KEY,
                                    CRYPTO_THREAD_NO_CONTEXT, NULL))
        return 0;

    OPENSSL_free(ctx);

    return 1;
}

static ASYNC_JOB *async_job_new(void)
{
    ASYNC_JOB *job = NULL;

    job = OPENSSL_zalloc(sizeof(*job));
    if (job == NULL)
        return NULL;

    job->status = ASYNC_JOB_RUNNING;

    return job;
}

static void async_job_free(ASYNC_JOB *job)
{
    if (job != NULL) {
        OPENSSL_free(job->funcargs);
        async_fibre_free(&job->fibrectx);
        OPENSSL_free(job);
    }
}

static ASYNC_JOB *async_get_pool_job(void) {
    ASYNC_JOB *job;
    async_pool *pool;

    pool = (async_pool *)CRYPTO_THREAD_get_local_ex(CRYPTO_THREAD_LOCAL_ASYNC_POOL_KEY,
                                                    CRYPTO_THREAD_NO_CONTEXT);
    if (pool == NULL) {
        /*
         * Pool has not been initialised, so init with the defaults, i.e.
         * no max size and no pre-created jobs
         */
        if (ASYNC_init_thread(0, 0) == 0)
            return NULL;
        pool = (async_pool *)CRYPTO_THREAD_get_local_ex(CRYPTO_THREAD_LOCAL_ASYNC_POOL_KEY,
                                                        CRYPTO_THREAD_NO_CONTEXT);
    }

    job = sk_ASYNC_JOB_pop(pool->jobs);
    if (job == NULL) {
        /* Pool is empty */
        if ((pool->max_size != 0) && (pool->curr_size >= pool->max_size))
            return NULL;

        job = async_job_new();
        if (job != NULL) {
            if (! async_fibre_makecontext(&job->fibrectx)) {
                async_job_free(job);
                return NULL;
            }
            pool->curr_size++;
        }
    }
    return job;
}

static void async_release_job(ASYNC_JOB *job) {
    async_pool *pool;

    pool = (async_pool *)CRYPTO_THREAD_get_local_ex(CRYPTO_THREAD_LOCAL_ASYNC_POOL_KEY,
                                                    CRYPTO_THREAD_NO_CONTEXT);
    if (pool == NULL) {
        ERR_raise(ERR_LIB_ASYNC, ERR_R_INTERNAL_ERROR);
        return;
    }
    OPENSSL_free(job->funcargs);
    job->funcargs = NULL;
    sk_ASYNC_JOB_push(pool->jobs, job);
}

void async_start_func(void)
{
    ASYNC_JOB *job;
    async_ctx *ctx = async_get_ctx();

    if (ctx == NULL) {
        ERR_raise(ERR_LIB_ASYNC, ERR_R_INTERNAL_ERROR);
        return;
    }
    while (1) {
        /* Run the job */
        job = ctx->currjob;
        job->ret = job->func(job->funcargs);

        /* Stop the job */
        job->status = ASYNC_JOB_STOPPING;
        if (!async_fibre_swapcontext(&job->fibrectx,
                                     &ctx->dispatcher, 1)) {
            /*
             * Should not happen. Getting here will close the thread...can't do
             * much about it
             */
            ERR_raise(ERR_LIB_ASYNC, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
        }
    }
}

int ASYNC_start_job(ASYNC_JOB **job, ASYNC_WAIT_CTX *wctx, int *ret,
                    int (*func)(void *), void *args, size_t size)
{
    async_ctx *ctx;
    OSSL_LIB_CTX *libctx;

    if (!OPENSSL_init_crypto(OPENSSL_INIT_ASYNC, NULL))
        return ASYNC_ERR;

    ctx = async_get_ctx();
    if (ctx == NULL)
        ctx = async_ctx_new();
    if (ctx == NULL)
        return ASYNC_ERR;

    if (*job != NULL)
        ctx->currjob = *job;

    for (;;) {
        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;
                return ASYNC_FINISH;
            }

            if (ctx->currjob->status == ASYNC_JOB_PAUSING) {
                *job = ctx->currjob;
                ctx->currjob->status = ASYNC_JOB_PAUSED;
                ctx->currjob = NULL;
                return ASYNC_PAUSE;
            }

            if (ctx->currjob->status == ASYNC_JOB_PAUSED) {
                if (*job == NULL)
                    return ASYNC_ERR;
                ctx->currjob = *job;

                /*
                 * Restore the default libctx to what it was the last time the
                 * fibre ran
                 */
                libctx = OSSL_LIB_CTX_set0_default(ctx->currjob->libctx);
                if (libctx == NULL) {
                    /* Failed to set the default context */
                    ERR_raise(ERR_LIB_ASYNC, ERR_R_INTERNAL_ERROR);
                    goto err;
                }
                /* Resume previous job */
                if (!async_fibre_swapcontext(&ctx->dispatcher,
                        &ctx->currjob->fibrectx, 1)) {
                    ctx->currjob->libctx = OSSL_LIB_CTX_set0_default(libctx);
                    ERR_raise(ERR_LIB_ASYNC, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
                    goto err;
                }
                /*
                 * In case the fibre changed the default libctx we set it back
                 * again to what it was originally, and remember what it had
                 * been changed to.
                 */
                ctx->currjob->libctx = OSSL_LIB_CTX_set0_default(libctx);
                continue;
            }

            /* Should not happen */
            ERR_raise(ERR_LIB_ASYNC, ERR_R_INTERNAL_ERROR);
            async_release_job(ctx->currjob);
            ctx->currjob = NULL;
            *job = NULL;
            return ASYNC_ERR;
        }

        /* Start a new job */
        if ((ctx->currjob = async_get_pool_job()) == NULL)
            return ASYNC_NO_JOBS;

        if (args != NULL) {
            ctx->currjob->funcargs = OPENSSL_malloc(size);
            if (ctx->currjob->funcargs == NULL) {
                async_release_job(ctx->currjob);
                ctx->currjob = NULL;
                return ASYNC_ERR;
            }
            memcpy(ctx->currjob->funcargs, args, size);
        } else {
            ctx->currjob->funcargs = NULL;
        }

        ctx->currjob->func = func;
        ctx->currjob->waitctx = wctx;
        libctx = ossl_lib_ctx_get_concrete(NULL);
        if (!async_fibre_swapcontext(&ctx->dispatcher,
                &ctx->currjob->fibrectx, 1)) {
            ERR_raise(ERR_LIB_ASYNC, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
            goto err;
        }
        /*
         * In case the fibre changed the default libctx we set it back again
         * to what it was, and remember what it had been changed to.
         */
        ctx->currjob->libctx = OSSL_LIB_CTX_set0_default(libctx);
    }

err:
    async_release_job(ctx->currjob);
    ctx->currjob = NULL;
    *job = NULL;
    return ASYNC_ERR;
}

int ASYNC_pause_job(void)
{
    ASYNC_JOB *job;
    async_ctx *ctx = async_get_ctx();

    if (ctx == NULL
            || ctx->currjob == NULL
            || ctx->blocked) {
        /*
         * Could be we've deliberately not been started within a job so this is
         * counted as success.
         */
        return 1;
    }

    job = ctx->currjob;
    job->status = ASYNC_JOB_PAUSING;

    if (!async_fibre_swapcontext(&job->fibrectx,
                                 &ctx->dispatcher, 1)) {
        ERR_raise(ERR_LIB_ASYNC, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
        return 0;
    }
    /* Reset counts of added and deleted fds */
    async_wait_ctx_reset_counts(job->waitctx);

    return 1;
}

static void async_empty_pool(async_pool *pool)
{
    ASYNC_JOB *job;

    if (pool == NULL || pool->jobs == NULL)
        return;

    do {
        job = sk_ASYNC_JOB_pop(pool->jobs);
        async_job_free(job);
    } while (job);
}

int async_init(void)
{
    return async_local_init();
}

void async_deinit(void)
{
    async_local_deinit();
}

int ASYNC_init_thread(size_t max_size, size_t init_size)
{
    async_pool *pool;
    size_t curr_size = 0;

    if (init_size > max_size || max_size > INT_MAX) {
        ERR_raise(ERR_LIB_ASYNC, ASYNC_R_INVALID_POOL_SIZE);
        return 0;
    }

    if (!OPENSSL_init_crypto(OPENSSL_INIT_ASYNC, NULL))
        return 0;

    if (!ossl_init_thread_start(NULL, NULL, async_delete_thread_state))
        return 0;

    pool = OPENSSL_zalloc(sizeof(*pool));
    if (pool == NULL)
        return 0;

    pool->jobs = sk_ASYNC_JOB_new_reserve(NULL, (int)init_size);
    if (pool->jobs == NULL) {
        ERR_raise(ERR_LIB_ASYNC, ERR_R_CRYPTO_LIB);
        OPENSSL_free(pool);
        return 0;
    }

    pool->max_size = max_size;

    /* Pre-create jobs as required */
    while (init_size--) {
        ASYNC_JOB *job;
        job = async_job_new();
        if (job == NULL || !async_fibre_makecontext(&job->fibrectx)) {
            /*
             * Not actually fatal because we already created the pool, just
             * skip creation of any more jobs
             */
            async_job_free(job);
            break;
        }
        job->funcargs = NULL;
        sk_ASYNC_JOB_push(pool->jobs, job); /* Cannot fail due to reserve */
        curr_size++;
    }
    pool->curr_size = curr_size;
    if (!CRYPTO_THREAD_set_local_ex(CRYPTO_THREAD_LOCAL_ASYNC_POOL_KEY,
                                    CRYPTO_THREAD_NO_CONTEXT, pool)) {
        ERR_raise(ERR_LIB_ASYNC, ASYNC_R_FAILED_TO_SET_POOL);
        goto err;
    }

    return 1;
err:
    async_empty_pool(pool);
    sk_ASYNC_JOB_free(pool->jobs);
    OPENSSL_free(pool);
    return 0;
}

static void async_delete_thread_state(void *arg)
{
    async_pool *pool = (async_pool *)CRYPTO_THREAD_get_local_ex(CRYPTO_THREAD_LOCAL_ASYNC_POOL_KEY,
                                                                CRYPTO_THREAD_NO_CONTEXT);

    if (pool != NULL) {
        async_empty_pool(pool);
        sk_ASYNC_JOB_free(pool->jobs);
        OPENSSL_free(pool);
        CRYPTO_THREAD_set_local_ex(CRYPTO_THREAD_LOCAL_ASYNC_POOL_KEY,
                                   CRYPTO_THREAD_NO_CONTEXT, NULL);
    }
    async_local_cleanup();
    async_ctx_free();
}

void ASYNC_cleanup_thread(void)
{
    if (!OPENSSL_init_crypto(OPENSSL_INIT_ASYNC, NULL))
        return;

    async_delete_thread_state(NULL);
}

ASYNC_JOB *ASYNC_get_current_job(void)
{
    async_ctx *ctx;

    if (!OPENSSL_init_crypto(OPENSSL_INIT_ASYNC, NULL))
        return NULL;

    ctx = async_get_ctx();
    if (ctx == NULL)
        return NULL;

    return ctx->currjob;
}

ASYNC_WAIT_CTX *ASYNC_get_wait_ctx(ASYNC_JOB *job)
{
    return job->waitctx;
}

void ASYNC_block_pause(void)
{
    async_ctx *ctx;

    if (!OPENSSL_init_crypto(OPENSSL_INIT_ASYNC, NULL))
        return;

    ctx = async_get_ctx();
    if (ctx == NULL || ctx->currjob == NULL) {
        /*
         * We're not in a job anyway so ignore this
         */
        return;
    }
    ctx->blocked++;
}

void ASYNC_unblock_pause(void)
{
    async_ctx *ctx;

    if (!OPENSSL_init_crypto(OPENSSL_INIT_ASYNC, NULL))
        return;

    ctx = async_get_ctx();
    if (ctx == NULL || ctx->currjob == NULL) {
        /*
         * We're not in a job anyway so ignore this
         */
        return;
    }
    if (ctx->blocked > 0)
        ctx->blocked--;
}
Commit	Line	Data
	1	/*
	2	* Copyright 2015-2022 The OpenSSL Project Authors. All Rights Reserved.
	3	*
	4	* Licensed under the Apache License 2.0 (the "License"). You may not use
	5	* this file except in compliance with the License. You can obtain a copy
	6	* in the file LICENSE in the source distribution or at
	7	* https://www.openssl.org/source/license.html
	8	*/
	9
	10	/*
	11	* Without this we start getting longjmp crashes because it thinks we're jumping
	12	* up the stack when in fact we are jumping to an entirely different stack. The
	13	* cost of this is not having certain buffer overrun/underrun checks etc for
	14	* this source file :-(
	15	*/
	16	#undef _FORTIFY_SOURCE
	17
	18	/* This must be the first #include file */
	19	#include "async_local.h"
	20	#include "internal/threads_common.h"
	21
	22	#include <openssl/err.h>
	23	#include "crypto/cryptlib.h"
	24	#include <string.h>
	25
	26	#define ASYNC_JOB_RUNNING 0
	27	#define ASYNC_JOB_PAUSING 1
	28	#define ASYNC_JOB_PAUSED 2
	29	#define ASYNC_JOB_STOPPING 3
	30
	31	static void async_delete_thread_state(void *arg);
	32
	33	static async_ctx *async_ctx_new(void)
	34	{
	35	async_ctx *nctx;
	36
	37	if (!ossl_init_thread_start(NULL, NULL, async_delete_thread_state))
	38	return NULL;
	39
	40	nctx = OPENSSL_malloc(sizeof(*nctx));
	41	if (nctx == NULL)
	42	goto err;
	43
	44	async_fibre_init_dispatcher(&nctx->dispatcher);
	45	nctx->currjob = NULL;
	46	nctx->blocked = 0;
	47	if (!CRYPTO_THREAD_set_local_ex(CRYPTO_THREAD_LOCAL_ASYNC_CTX_KEY,
	48	CRYPTO_THREAD_NO_CONTEXT, nctx))
	49	goto err;
	50
	51	return nctx;
	52	err:
	53	OPENSSL_free(nctx);
	54
	55	return NULL;
	56	}
	57
	58	async_ctx *async_get_ctx(void)
	59	{
	60	return (async_ctx *)CRYPTO_THREAD_get_local_ex(CRYPTO_THREAD_LOCAL_ASYNC_CTX_KEY,
	61	CRYPTO_THREAD_NO_CONTEXT);
	62	}
	63
	64	static int async_ctx_free(void)
	65	{
	66	async_ctx *ctx;
	67
	68	ctx = async_get_ctx();
	69
	70	if (!CRYPTO_THREAD_set_local_ex(CRYPTO_THREAD_LOCAL_ASYNC_CTX_KEY,
	71	CRYPTO_THREAD_NO_CONTEXT, NULL))
	72	return 0;
	73
	74	OPENSSL_free(ctx);
	75
	76	return 1;
	77	}
	78
	79	static ASYNC_JOB *async_job_new(void)
	80	{
	81	ASYNC_JOB *job = NULL;
	82
	83	job = OPENSSL_zalloc(sizeof(*job));
	84	if (job == NULL)
	85	return NULL;
	86
	87	job->status = ASYNC_JOB_RUNNING;
	88
	89	return job;
	90	}
	91
	92	static void async_job_free(ASYNC_JOB *job)
	93	{
	94	if (job != NULL) {
	95	OPENSSL_free(job->funcargs);
	96	async_fibre_free(&job->fibrectx);
	97	OPENSSL_free(job);
	98	}
	99	}
	100
	101	static ASYNC_JOB *async_get_pool_job(void) {
	102	ASYNC_JOB *job;
	103	async_pool *pool;
	104
	105	pool = (async_pool *)CRYPTO_THREAD_get_local_ex(CRYPTO_THREAD_LOCAL_ASYNC_POOL_KEY,
	106	CRYPTO_THREAD_NO_CONTEXT);
	107	if (pool == NULL) {
	108	/*
	109	* Pool has not been initialised, so init with the defaults, i.e.
	110	* no max size and no pre-created jobs
	111	*/
	112	if (ASYNC_init_thread(0, 0) == 0)
	113	return NULL;
	114	pool = (async_pool *)CRYPTO_THREAD_get_local_ex(CRYPTO_THREAD_LOCAL_ASYNC_POOL_KEY,
	115	CRYPTO_THREAD_NO_CONTEXT);
	116	}
	117
	118	job = sk_ASYNC_JOB_pop(pool->jobs);
	119	if (job == NULL) {
	120	/* Pool is empty */
	121	if ((pool->max_size != 0) && (pool->curr_size >= pool->max_size))
	122	return NULL;
	123
	124	job = async_job_new();
	125	if (job != NULL) {
	126	if (! async_fibre_makecontext(&job->fibrectx)) {
	127	async_job_free(job);
	128	return NULL;
	129	}
	130	pool->curr_size++;
	131	}
	132	}
	133	return job;
	134	}
	135
	136	static void async_release_job(ASYNC_JOB *job) {
	137	async_pool *pool;
	138
	139	pool = (async_pool *)CRYPTO_THREAD_get_local_ex(CRYPTO_THREAD_LOCAL_ASYNC_POOL_KEY,
	140	CRYPTO_THREAD_NO_CONTEXT);
	141	if (pool == NULL) {
	142	ERR_raise(ERR_LIB_ASYNC, ERR_R_INTERNAL_ERROR);
	143	return;
	144	}
	145	OPENSSL_free(job->funcargs);
	146	job->funcargs = NULL;
	147	sk_ASYNC_JOB_push(pool->jobs, job);
	148	}
	149
	150	void async_start_func(void)
	151	{
	152	ASYNC_JOB *job;
	153	async_ctx *ctx = async_get_ctx();
	154
	155	if (ctx == NULL) {
	156	ERR_raise(ERR_LIB_ASYNC, ERR_R_INTERNAL_ERROR);
	157	return;
	158	}
	159	while (1) {
	160	/* Run the job */
	161	job = ctx->currjob;
	162	job->ret = job->func(job->funcargs);
	163
	164	/* Stop the job */
	165	job->status = ASYNC_JOB_STOPPING;
	166	if (!async_fibre_swapcontext(&job->fibrectx,
	167	&ctx->dispatcher, 1)) {
	168	/*
	169	* Should not happen. Getting here will close the thread...can't do
	170	* much about it
	171	*/
	172	ERR_raise(ERR_LIB_ASYNC, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
	173	}
	174	}
	175	}
	176
	177	int ASYNC_start_job(ASYNC_JOB *job, ASYNC_WAIT_CTX wctx, int *ret,
	178	int (func)(void ), void *args, size_t size)
	179	{
	180	async_ctx *ctx;
	181	OSSL_LIB_CTX *libctx;
	182
	183	if (!OPENSSL_init_crypto(OPENSSL_INIT_ASYNC, NULL))
	184	return ASYNC_ERR;
	185
	186	ctx = async_get_ctx();
	187	if (ctx == NULL)
	188	ctx = async_ctx_new();
	189	if (ctx == NULL)
	190	return ASYNC_ERR;
	191
	192	if (*job != NULL)
	193	ctx->currjob = *job;
	194
	195	for (;;) {
	196	if (ctx->currjob != NULL) {
	197	if (ctx->currjob->status == ASYNC_JOB_STOPPING) {
	198	*ret = ctx->currjob->ret;
	199	ctx->currjob->waitctx = NULL;
	200	async_release_job(ctx->currjob);
	201	ctx->currjob = NULL;
	202	*job = NULL;
	203	return ASYNC_FINISH;
	204	}
	205
	206	if (ctx->currjob->status == ASYNC_JOB_PAUSING) {
	207	*job = ctx->currjob;
	208	ctx->currjob->status = ASYNC_JOB_PAUSED;
	209	ctx->currjob = NULL;
	210	return ASYNC_PAUSE;
	211	}
	212
	213	if (ctx->currjob->status == ASYNC_JOB_PAUSED) {
	214	if (*job == NULL)
	215	return ASYNC_ERR;
	216	ctx->currjob = *job;
	217
	218	/*
	219	* Restore the default libctx to what it was the last time the
	220	* fibre ran
	221	*/
	222	libctx = OSSL_LIB_CTX_set0_default(ctx->currjob->libctx);
	223	if (libctx == NULL) {
	224	/* Failed to set the default context */
	225	ERR_raise(ERR_LIB_ASYNC, ERR_R_INTERNAL_ERROR);
	226	goto err;
	227	}
	228	/* Resume previous job */
	229	if (!async_fibre_swapcontext(&ctx->dispatcher,
	230	&ctx->currjob->fibrectx, 1)) {
	231	ctx->currjob->libctx = OSSL_LIB_CTX_set0_default(libctx);
	232	ERR_raise(ERR_LIB_ASYNC, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
	233	goto err;
	234	}
	235	/*
	236	* In case the fibre changed the default libctx we set it back
	237	* again to what it was originally, and remember what it had
	238	* been changed to.
	239	*/
	240	ctx->currjob->libctx = OSSL_LIB_CTX_set0_default(libctx);
	241	continue;
	242	}
	243
	244	/* Should not happen */
	245	ERR_raise(ERR_LIB_ASYNC, ERR_R_INTERNAL_ERROR);
	246	async_release_job(ctx->currjob);
	247	ctx->currjob = NULL;
	248	*job = NULL;
	249	return ASYNC_ERR;
	250	}
	251
	252	/* Start a new job */
	253	if ((ctx->currjob = async_get_pool_job()) == NULL)
	254	return ASYNC_NO_JOBS;
	255
	256	if (args != NULL) {
	257	ctx->currjob->funcargs = OPENSSL_malloc(size);
	258	if (ctx->currjob->funcargs == NULL) {
	259	async_release_job(ctx->currjob);
	260	ctx->currjob = NULL;
	261	return ASYNC_ERR;
	262	}
	263	memcpy(ctx->currjob->funcargs, args, size);
	264	} else {
	265	ctx->currjob->funcargs = NULL;
	266	}
	267
	268	ctx->currjob->func = func;
	269	ctx->currjob->waitctx = wctx;
	270	libctx = ossl_lib_ctx_get_concrete(NULL);
	271	if (!async_fibre_swapcontext(&ctx->dispatcher,
	272	&ctx->currjob->fibrectx, 1)) {
	273	ERR_raise(ERR_LIB_ASYNC, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
	274	goto err;
	275	}
	276	/*
	277	* In case the fibre changed the default libctx we set it back again
	278	* to what it was, and remember what it had been changed to.
	279	*/
	280	ctx->currjob->libctx = OSSL_LIB_CTX_set0_default(libctx);
	281	}
	282
	283	err:
	284	async_release_job(ctx->currjob);
	285	ctx->currjob = NULL;
	286	*job = NULL;
	287	return ASYNC_ERR;
	288	}
	289
	290	int ASYNC_pause_job(void)
	291	{
	292	ASYNC_JOB *job;
	293	async_ctx *ctx = async_get_ctx();
	294
	295	if (ctx == NULL
	296	\|\| ctx->currjob == NULL
	297	\|\| ctx->blocked) {
	298	/*
	299	* Could be we've deliberately not been started within a job so this is
	300	* counted as success.
	301	*/
	302	return 1;
	303	}
	304
	305	job = ctx->currjob;
	306	job->status = ASYNC_JOB_PAUSING;
	307
	308	if (!async_fibre_swapcontext(&job->fibrectx,
	309	&ctx->dispatcher, 1)) {
	310	ERR_raise(ERR_LIB_ASYNC, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
	311	return 0;
	312	}
	313	/* Reset counts of added and deleted fds */
	314	async_wait_ctx_reset_counts(job->waitctx);
	315
	316	return 1;
	317	}
	318
	319	static void async_empty_pool(async_pool *pool)
	320	{
	321	ASYNC_JOB *job;
	322
	323	if (pool == NULL \|\| pool->jobs == NULL)
	324	return;
	325
	326	do {
	327	job = sk_ASYNC_JOB_pop(pool->jobs);
	328	async_job_free(job);
	329	} while (job);
	330	}
	331
	332	int async_init(void)
	333	{
	334	return async_local_init();
	335	}
	336
	337	void async_deinit(void)
	338	{
	339	async_local_deinit();
	340	}
	341
	342	int ASYNC_init_thread(size_t max_size, size_t init_size)
	343	{
	344	async_pool *pool;
	345	size_t curr_size = 0;
	346
	347	if (init_size > max_size \|\| max_size > INT_MAX) {
	348	ERR_raise(ERR_LIB_ASYNC, ASYNC_R_INVALID_POOL_SIZE);
	349	return 0;
	350	}
	351
	352	if (!OPENSSL_init_crypto(OPENSSL_INIT_ASYNC, NULL))
	353	return 0;
	354
	355	if (!ossl_init_thread_start(NULL, NULL, async_delete_thread_state))
	356	return 0;
	357
	358	pool = OPENSSL_zalloc(sizeof(*pool));
	359	if (pool == NULL)
	360	return 0;
	361
	362	pool->jobs = sk_ASYNC_JOB_new_reserve(NULL, (int)init_size);
	363	if (pool->jobs == NULL) {
	364	ERR_raise(ERR_LIB_ASYNC, ERR_R_CRYPTO_LIB);
	365	OPENSSL_free(pool);
	366	return 0;
	367	}
	368
	369	pool->max_size = max_size;
	370
	371	/* Pre-create jobs as required */
	372	while (init_size--) {
	373	ASYNC_JOB *job;
	374	job = async_job_new();
	375	if (job == NULL \|\| !async_fibre_makecontext(&job->fibrectx)) {
	376	/*
	377	* Not actually fatal because we already created the pool, just
	378	* skip creation of any more jobs
	379	*/
	380	async_job_free(job);
	381	break;
	382	}
	383	job->funcargs = NULL;
	384	sk_ASYNC_JOB_push(pool->jobs, job); /* Cannot fail due to reserve */
	385	curr_size++;
	386	}
	387	pool->curr_size = curr_size;
	388	if (!CRYPTO_THREAD_set_local_ex(CRYPTO_THREAD_LOCAL_ASYNC_POOL_KEY,
	389	CRYPTO_THREAD_NO_CONTEXT, pool)) {
	390	ERR_raise(ERR_LIB_ASYNC, ASYNC_R_FAILED_TO_SET_POOL);
	391	goto err;
	392	}
	393
	394	return 1;
	395	err:
	396	async_empty_pool(pool);
	397	sk_ASYNC_JOB_free(pool->jobs);
	398	OPENSSL_free(pool);
	399	return 0;
	400	}
	401
	402	static void async_delete_thread_state(void *arg)
	403	{
	404	async_pool pool = (async_pool )CRYPTO_THREAD_get_local_ex(CRYPTO_THREAD_LOCAL_ASYNC_POOL_KEY,
	405	CRYPTO_THREAD_NO_CONTEXT);
	406
	407	if (pool != NULL) {
	408	async_empty_pool(pool);
	409	sk_ASYNC_JOB_free(pool->jobs);
	410	OPENSSL_free(pool);
	411	CRYPTO_THREAD_set_local_ex(CRYPTO_THREAD_LOCAL_ASYNC_POOL_KEY,
	412	CRYPTO_THREAD_NO_CONTEXT, NULL);
	413	}
	414	async_local_cleanup();
	415	async_ctx_free();
	416	}
	417
	418	void ASYNC_cleanup_thread(void)
	419	{
	420	if (!OPENSSL_init_crypto(OPENSSL_INIT_ASYNC, NULL))
	421	return;
	422
	423	async_delete_thread_state(NULL);
	424	}
	425
	426	ASYNC_JOB *ASYNC_get_current_job(void)
	427	{
	428	async_ctx *ctx;
	429
	430	if (!OPENSSL_init_crypto(OPENSSL_INIT_ASYNC, NULL))
	431	return NULL;
	432
	433	ctx = async_get_ctx();
	434	if (ctx == NULL)
	435	return NULL;
	436
	437	return ctx->currjob;
	438	}
	439
	440	ASYNC_WAIT_CTX ASYNC_get_wait_ctx(ASYNC_JOB job)
	441	{
	442	return job->waitctx;
	443	}
	444
	445	void ASYNC_block_pause(void)
	446	{
	447	async_ctx *ctx;
	448
	449	if (!OPENSSL_init_crypto(OPENSSL_INIT_ASYNC, NULL))
	450	return;
	451
	452	ctx = async_get_ctx();
	453	if (ctx == NULL \|\| ctx->currjob == NULL) {
	454	/*
	455	* We're not in a job anyway so ignore this
	456	*/
	457	return;
	458	}
	459	ctx->blocked++;
	460	}
	461
	462	void ASYNC_unblock_pause(void)
	463	{
	464	async_ctx *ctx;
	465
	466	if (!OPENSSL_init_crypto(OPENSSL_INIT_ASYNC, NULL))
	467	return;
	468
	469	ctx = async_get_ctx();
	470	if (ctx == NULL \|\| ctx->currjob == NULL) {
	471	/*
	472	* We're not in a job anyway so ignore this
	473	*/
	474	return;
	475	}
	476	if (ctx->blocked > 0)
	477	ctx->blocked--;
	478	}