1 /* crypto/async/async.c */
3 * Written by Matt Caswell (matt@openssl.org) for the OpenSSL project.
5 /* ====================================================================
6 * Copyright (c) 2015 The OpenSSL Project. All rights reserved.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in
17 * the documentation and/or other materials provided with the
20 * 3. All advertising materials mentioning features or use of this
21 * software must display the following acknowledgment:
22 * "This product includes software developed by the OpenSSL Project
23 * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
25 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26 * endorse or promote products derived from this software without
27 * prior written permission. For written permission, please contact
28 * licensing@OpenSSL.org.
30 * 5. Products derived from this software may not be called "OpenSSL"
31 * nor may "OpenSSL" appear in their names without prior written
32 * permission of the OpenSSL Project.
34 * 6. Redistributions of any form whatsoever must retain the following
36 * "This product includes software developed by the OpenSSL Project
37 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
39 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
43 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50 * OF THE POSSIBILITY OF SUCH DAMAGE.
51 * ====================================================================
55 * Without this we start getting longjmp crashes because it thinks we're jumping
56 * up the stack when in fact we are jumping to an entirely different stack. The
57 * cost of this is not having certain buffer overrun/underrun checks etc for
58 * this source file :-(
60 #undef _FORTIFY_SOURCE
62 /* This must be the first #include file */
63 #include "async_locl.h"
65 #include <openssl/err.h>
68 #define ASYNC_JOB_RUNNING 0
69 #define ASYNC_JOB_PAUSING 1
70 #define ASYNC_JOB_PAUSED 2
71 #define ASYNC_JOB_STOPPING 3
73 static void async_free_pool_internal(async_pool *pool);
75 static async_ctx *async_ctx_new(void)
77 async_ctx *nctx = NULL;
79 nctx = OPENSSL_malloc(sizeof (async_ctx));
81 ASYNCerr(ASYNC_F_ASYNC_CTX_NEW, ERR_R_MALLOC_FAILURE);
85 async_fibre_init_dispatcher(&nctx->dispatcher);
88 if (!async_set_ctx(nctx))
98 static int async_ctx_free(void)
102 ctx = async_get_ctx();
104 if (!async_set_ctx(NULL))
112 static ASYNC_JOB *async_job_new(void)
114 ASYNC_JOB *job = NULL;
115 OSSL_ASYNC_FD pipefds[2];
117 job = OPENSSL_malloc(sizeof (ASYNC_JOB));
119 ASYNCerr(ASYNC_F_ASYNC_JOB_NEW, ERR_R_MALLOC_FAILURE);
123 if (!async_pipe(pipefds)) {
125 ASYNCerr(ASYNC_F_ASYNC_JOB_NEW, ASYNC_R_CANNOT_CREATE_WAIT_PIPE);
130 job->wait_fd = pipefds[0];
131 job->wake_fd = pipefds[1];
133 job->status = ASYNC_JOB_RUNNING;
134 job->funcargs = NULL;
139 static void async_job_free(ASYNC_JOB *job)
142 OPENSSL_free(job->funcargs);
143 async_fibre_free(&job->fibrectx);
144 async_close_fd(job->wait_fd);
145 async_close_fd(job->wake_fd);
150 static ASYNC_JOB *async_get_pool_job(void) {
154 pool = async_get_pool();
157 * Pool has not been initialised, so init with the defaults, i.e.
158 * no max size and no pre-created jobs
160 if (ASYNC_init_thread(0, 0) == 0)
162 pool = async_get_pool();
165 job = sk_ASYNC_JOB_pop(pool->jobs);
168 if ((pool->max_size != 0) && (pool->curr_size >= pool->max_size))
171 job = async_job_new();
173 if (! async_fibre_makecontext(&job->fibrectx)) {
183 static void async_release_job(ASYNC_JOB *job) {
186 pool = async_get_pool();
187 OPENSSL_free(job->funcargs);
188 job->funcargs = NULL;
189 sk_ASYNC_JOB_push(pool->jobs, job);
192 void async_start_func(void)
198 job = async_get_ctx()->currjob;
199 job->ret = job->func(job->funcargs);
202 job->status = ASYNC_JOB_STOPPING;
203 if (!async_fibre_swapcontext(&job->fibrectx,
204 &async_get_ctx()->dispatcher, 1)) {
206 * Should not happen. Getting here will close the thread...can't do
209 ASYNCerr(ASYNC_F_ASYNC_START_FUNC, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
214 int ASYNC_start_job(ASYNC_JOB **job, int *ret, int (*func)(void *),
215 void *args, size_t size)
217 if (async_get_ctx() == NULL && async_ctx_new() == NULL) {
222 async_get_ctx()->currjob = *job;
226 if (async_get_ctx()->currjob != NULL) {
227 if (async_get_ctx()->currjob->status == ASYNC_JOB_STOPPING) {
228 *ret = async_get_ctx()->currjob->ret;
229 async_release_job(async_get_ctx()->currjob);
230 async_get_ctx()->currjob = NULL;
235 if (async_get_ctx()->currjob->status == ASYNC_JOB_PAUSING) {
236 *job = async_get_ctx()->currjob;
237 async_get_ctx()->currjob->status = ASYNC_JOB_PAUSED;
238 async_get_ctx()->currjob = NULL;
242 if (async_get_ctx()->currjob->status == ASYNC_JOB_PAUSED) {
243 async_get_ctx()->currjob = *job;
244 /* Resume previous job */
245 if (!async_fibre_swapcontext(&async_get_ctx()->dispatcher,
246 &async_get_ctx()->currjob->fibrectx, 1)) {
247 ASYNCerr(ASYNC_F_ASYNC_START_JOB,
248 ASYNC_R_FAILED_TO_SWAP_CONTEXT);
254 /* Should not happen */
255 ASYNCerr(ASYNC_F_ASYNC_START_JOB, ERR_R_INTERNAL_ERROR);
256 async_release_job(async_get_ctx()->currjob);
257 async_get_ctx()->currjob = NULL;
262 /* Start a new job */
263 if ((async_get_ctx()->currjob = async_get_pool_job()) == NULL) {
264 return ASYNC_NO_JOBS;
268 async_get_ctx()->currjob->funcargs = OPENSSL_malloc(size);
269 if (async_get_ctx()->currjob->funcargs == NULL) {
270 ASYNCerr(ASYNC_F_ASYNC_START_JOB, ERR_R_MALLOC_FAILURE);
271 async_release_job(async_get_ctx()->currjob);
272 async_get_ctx()->currjob = NULL;
275 memcpy(async_get_ctx()->currjob->funcargs, args, size);
277 async_get_ctx()->currjob->funcargs = NULL;
280 async_get_ctx()->currjob->func = func;
281 if (!async_fibre_swapcontext(&async_get_ctx()->dispatcher,
282 &async_get_ctx()->currjob->fibrectx, 1)) {
283 ASYNCerr(ASYNC_F_ASYNC_START_JOB, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
289 async_release_job(async_get_ctx()->currjob);
290 async_get_ctx()->currjob = NULL;
296 int ASYNC_pause_job(void)
300 if (async_get_ctx() == NULL
301 || async_get_ctx()->currjob == NULL
302 || async_get_ctx()->blocked) {
304 * Could be we've deliberately not been started within a job so this is
305 * counted as success.
310 job = async_get_ctx()->currjob;
311 job->status = ASYNC_JOB_PAUSING;
313 if (!async_fibre_swapcontext(&job->fibrectx,
314 &async_get_ctx()->dispatcher, 1)) {
315 ASYNCerr(ASYNC_F_ASYNC_PAUSE_JOB, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
322 static void async_empty_pool(async_pool *pool)
326 if (!pool || !pool->jobs)
330 job = sk_ASYNC_JOB_pop(pool->jobs);
335 int ASYNC_init(int init_thread, size_t max_size, size_t init_size)
337 if (!async_global_init())
341 return ASYNC_init_thread(max_size, init_size);
346 int ASYNC_init_thread(size_t max_size, size_t init_size)
349 size_t curr_size = 0;
351 if (init_size > max_size) {
352 ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ASYNC_R_INVALID_POOL_SIZE);
356 if (!async_local_init()) {
357 ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ASYNC_R_INIT_FAILED);
360 pool = OPENSSL_zalloc(sizeof *pool);
362 ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ERR_R_MALLOC_FAILURE);
366 pool->jobs = sk_ASYNC_JOB_new_null();
367 if (pool->jobs == NULL) {
368 ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ERR_R_MALLOC_FAILURE);
373 pool->max_size = max_size;
375 /* Pre-create jobs as required */
376 while (init_size--) {
378 job = async_job_new();
379 if (job == NULL || !async_fibre_makecontext(&job->fibrectx)) {
381 * Not actually fatal because we already created the pool, just
382 * skip creation of any more jobs
387 job->funcargs = NULL;
388 sk_ASYNC_JOB_push(pool->jobs, job);
391 pool->curr_size = curr_size;
392 if (!async_set_pool(pool)) {
393 ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ASYNC_R_FAILED_TO_SET_POOL);
399 async_free_pool_internal(pool);
403 static void async_free_pool_internal(async_pool *pool)
408 async_empty_pool(pool);
409 sk_ASYNC_JOB_free(pool->jobs);
411 (void)async_set_pool(NULL);
412 async_local_cleanup();
416 void ASYNC_cleanup_thread(void)
418 async_free_pool_internal(async_get_pool());
421 void ASYNC_cleanup(int cleanupthread)
424 * We don't actually have any global cleanup at the moment so just cleanup
428 ASYNC_cleanup_thread();
431 ASYNC_JOB *ASYNC_get_current_job(void)
435 ctx = async_get_ctx();
442 OSSL_ASYNC_FD ASYNC_get_wait_fd(ASYNC_JOB *job)
447 void ASYNC_wake(ASYNC_JOB *job)
453 async_write1(job->wake_fd, &dummy);
457 void ASYNC_clear_wake(ASYNC_JOB *job)
462 async_read1(job->wait_fd, &dummy);
466 void ASYNC_block_pause(void)
468 if (async_get_ctx() == NULL
469 || async_get_ctx()->currjob == NULL) {
471 * We're not in a job anyway so ignore this
475 async_get_ctx()->blocked++;
478 void ASYNC_unblock_pause(void)
480 if (async_get_ctx() == NULL
481 || async_get_ctx()->currjob == NULL) {
483 * We're not in a job anyway so ignore this
487 if(async_get_ctx()->blocked > 0)
488 async_get_ctx()->blocked--;