static ASYNC_JOB *async_job_new(void) { ASYNC_JOB *job = NULL; OSSL_ASYNC_FD pipefds[2]; job = OPENSSL_malloc(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; }
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) { ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ASYNC_R_INVALID_POOL_SIZE); return 0; } if (!OPENSSL_init_crypto(OPENSSL_INIT_ASYNC, NULL)) { return 0; } if (!ossl_init_thread_start(OPENSSL_INIT_THREAD_ASYNC)) { return 0; } pool = OPENSSL_zalloc(sizeof(*pool)); if (pool == NULL) { ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ERR_R_MALLOC_FAILURE); return 0; } pool->jobs = sk_ASYNC_JOB_new_reserve(NULL, init_size); if (pool->jobs == NULL) { ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ERR_R_MALLOC_FAILURE); 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(&poolkey, pool)) { ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ASYNC_R_FAILED_TO_SET_POOL); goto err; } return 1; err: async_free_pool_internal(pool); return 0; }
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) { ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ASYNC_R_INVALID_POOL_SIZE); return 0; } if (!async_local_init()) { ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ASYNC_R_INIT_FAILED); return 0; } pool = OPENSSL_zalloc(sizeof *pool); if (pool == NULL) { ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ERR_R_MALLOC_FAILURE); return 0; } pool->jobs = sk_ASYNC_JOB_new_null(); if (pool->jobs == NULL) { ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ERR_R_MALLOC_FAILURE); 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) { async_fibre_makecontext(&job->fibrectx); job->funcargs = NULL; sk_ASYNC_JOB_push(pool->jobs, job); curr_size++; init_size--; } else { /* * Not actually fatal because we already created the pool, just skip * creation of any more jobs */ init_size = 0; } } pool->curr_size = curr_size; if (!async_set_pool(pool)) { ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ASYNC_R_FAILED_TO_SET_POOL); goto err; } return 1; err: async_free_pool_internal(pool); return 0; }
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)) { 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; }
int ASYNC_pause_job(void) { ASYNC_JOB *job; if (async_get_ctx() == NULL || async_get_ctx()->currjob == NULL || async_get_ctx()->blocked) { /* * Could be we've deliberately not been started within a job so this is * counted as success. */ return 1; } job = async_get_ctx()->currjob; job->status = ASYNC_JOB_PAUSING; if (!async_fibre_swapcontext(&job->fibrectx, &async_get_ctx()->dispatcher, 1)) { ASYNCerr(ASYNC_F_ASYNC_PAUSE_JOB, ASYNC_R_FAILED_TO_SWAP_CONTEXT); return 0; } return 1; }
static ASYNC_JOB *async_job_new(void) { ASYNC_JOB *job = NULL; job = OPENSSL_zalloc(sizeof(*job)); if (job == NULL) { ASYNCerr(ASYNC_F_ASYNC_JOB_NEW, ERR_R_MALLOC_FAILURE); return NULL; } job->status = ASYNC_JOB_RUNNING; return job; }
void async_start_func(void) { ASYNC_JOB *job; while (1) { /* Run the job */ job = async_get_ctx()->currjob; job->ret = job->func(job->funcargs); /* Stop the job */ job->status = ASYNC_JOB_STOPPING; if (!async_fibre_swapcontext(&job->fibrectx, &async_get_ctx()->dispatcher, 1)) { /* * Should not happen. Getting here will close the thread...can't do * much about it */ ASYNCerr(ASYNC_F_ASYNC_START_FUNC, ASYNC_R_FAILED_TO_SWAP_CONTEXT); } } }
static async_ctx *async_ctx_new(void) { async_ctx *nctx = NULL; nctx = OPENSSL_malloc(sizeof(*nctx)); if (nctx == NULL) { ASYNCerr(ASYNC_F_ASYNC_CTX_NEW, ERR_R_MALLOC_FAILURE); goto err; } async_fibre_init_dispatcher(&nctx->dispatcher); nctx->currjob = NULL; nctx->blocked = 0; if (!CRYPTO_THREAD_set_local(&ctxkey, nctx)) goto err; return nctx; err: OPENSSL_free(nctx); return NULL; }
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) ctx = async_ctx_new(); if (ctx == NULL) { return ASYNC_ERR; } if (*job) { 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) { ctx->currjob = *job; /* Resume previous job */ if (!async_fibre_swapcontext(&ctx->dispatcher, &ctx->currjob->fibrectx, 1)) { ASYNCerr(ASYNC_F_ASYNC_START_JOB, ASYNC_R_FAILED_TO_SWAP_CONTEXT); goto err; } continue; } /* Should not happen */ ASYNCerr(ASYNC_F_ASYNC_START_JOB, 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) { ASYNCerr(ASYNC_F_ASYNC_START_JOB, ERR_R_MALLOC_FAILURE); 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; if (!async_fibre_swapcontext(&ctx->dispatcher, &ctx->currjob->fibrectx, 1)) { ASYNCerr(ASYNC_F_ASYNC_START_JOB, ASYNC_R_FAILED_TO_SWAP_CONTEXT); goto err; } } err: async_release_job(ctx->currjob); ctx->currjob = NULL; *job = NULL; return ASYNC_ERR; }