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 * ====================================================================
54 #include <openssl/crypto.h>
55 #include <openssl/async.h>
57 #include "async_locl.h"
59 #define ASYNC_JOB_RUNNING 0
60 #define ASYNC_JOB_PAUSING 1
61 #define ASYNC_JOB_PAUSED 2
62 #define ASYNC_JOB_STOPPING 3
64 static size_t pool_max_size = 0;
65 static size_t curr_size = 0;
67 DECLARE_STACK_OF(ASYNC_JOB)
68 static STACK_OF(ASYNC_JOB) *pool = NULL;
71 static ASYNC_CTX *ASYNC_CTX_new(void)
73 ASYNC_CTX *nctx = NULL;
75 if(!(nctx = OPENSSL_malloc(sizeof (ASYNC_CTX)))) {
80 ASYNC_FIBRE_init_dispatcher(&nctx->dispatcher);
82 if(!ASYNC_set_ctx(nctx))
94 static int ASYNC_CTX_free(void)
97 OPENSSL_free(ASYNC_get_ctx());
100 if(!ASYNC_set_ctx(NULL))
106 static ASYNC_JOB *ASYNC_JOB_new(void)
108 ASYNC_JOB *job = NULL;
111 if(!(job = OPENSSL_malloc(sizeof (ASYNC_JOB)))) {
115 if(!async_pipe(pipefds)) {
121 job->wait_fd = pipefds[0];
122 job->wake_fd = pipefds[1];
124 job->status = ASYNC_JOB_RUNNING;
125 job->funcargs = NULL;
130 static void ASYNC_JOB_free(ASYNC_JOB *job)
134 OPENSSL_free(job->funcargs);
135 ASYNC_FIBRE_free(&job->fibrectx);
140 static ASYNC_JOB *async_get_pool_job(void) {
145 * Pool has not been initialised, so init with the defaults, i.e.
146 * global pool, with no max size and no pre-created jobs
148 if (ASYNC_init_pool(0, 0, 0) == 0)
152 job = sk_ASYNC_JOB_pop(pool);
155 if (pool_max_size && curr_size >= pool_max_size) {
156 /* Pool is at max size. We cannot continue */
159 job = ASYNC_JOB_new();
161 ASYNC_FIBRE_makecontext(&job->fibrectx);
168 static void async_release_job(ASYNC_JOB *job) {
170 OPENSSL_free(job->funcargs);
171 job->funcargs = NULL;
172 /* Ignore error return */
173 sk_ASYNC_JOB_push(pool, job);
176 void ASYNC_start_func(void)
182 job = ASYNC_get_ctx()->currjob;
183 job->ret = job->func(job->funcargs);
186 job->status = ASYNC_JOB_STOPPING;
187 if(!ASYNC_FIBRE_swapcontext(&job->fibrectx,
188 &ASYNC_get_ctx()->dispatcher, 1)) {
190 * Should not happen. Getting here will close the thread...can't do much
197 int ASYNC_start_job(ASYNC_JOB **job, int *ret, int (*func)(void *),
198 void *args, size_t size)
200 if(ASYNC_get_ctx() || !ASYNC_CTX_new()) {
205 ASYNC_get_ctx()->currjob = *job;
209 if(ASYNC_get_ctx()->currjob) {
210 if(ASYNC_get_ctx()->currjob->status == ASYNC_JOB_STOPPING) {
211 *ret = ASYNC_get_ctx()->currjob->ret;
212 async_release_job(ASYNC_get_ctx()->currjob);
213 ASYNC_get_ctx()->currjob = NULL;
219 if(ASYNC_get_ctx()->currjob->status == ASYNC_JOB_PAUSING) {
220 *job = ASYNC_get_ctx()->currjob;
221 ASYNC_get_ctx()->currjob->status = ASYNC_JOB_PAUSED;
226 if(ASYNC_get_ctx()->currjob->status == ASYNC_JOB_PAUSED) {
227 ASYNC_get_ctx()->currjob = *job;
228 /* Resume previous job */
229 if(!ASYNC_FIBRE_swapcontext(&ASYNC_get_ctx()->dispatcher,
230 &ASYNC_get_ctx()->currjob->fibrectx, 1))
235 /* Should not happen */
236 async_release_job(ASYNC_get_ctx()->currjob);
237 ASYNC_get_ctx()->currjob = NULL;
243 /* Start a new job */
244 if(!(ASYNC_get_ctx()->currjob = async_get_pool_job())) {
246 return ASYNC_NO_JOBS;
250 ASYNC_get_ctx()->currjob->funcargs = OPENSSL_malloc(size);
251 if(!ASYNC_get_ctx()->currjob->funcargs) {
252 async_release_job(ASYNC_get_ctx()->currjob);
253 ASYNC_get_ctx()->currjob = NULL;
257 memcpy(ASYNC_get_ctx()->currjob->funcargs, args, size);
259 ASYNC_get_ctx()->currjob->funcargs = NULL;
262 ASYNC_get_ctx()->currjob->func = func;
263 if(!ASYNC_FIBRE_swapcontext(&ASYNC_get_ctx()->dispatcher,
264 &ASYNC_get_ctx()->currjob->fibrectx, 1))
269 async_release_job(ASYNC_get_ctx()->currjob);
270 ASYNC_get_ctx()->currjob = NULL;
277 int ASYNC_pause_job(void)
281 if(!ASYNC_get_ctx() || !ASYNC_get_ctx()->currjob)
284 job = ASYNC_get_ctx()->currjob;
285 job->status = ASYNC_JOB_PAUSING;
287 if(!ASYNC_FIBRE_swapcontext(&job->fibrectx,
288 &ASYNC_get_ctx()->dispatcher, 1)) {
296 int ASYNC_in_job(void)
304 int ASYNC_init_pool(unsigned int local, size_t max_size, size_t init_size)
307 /* We only support a global pool so far */
311 pool_max_size = max_size;
312 pool = sk_ASYNC_JOB_new_null();
316 /* Pre-create jobs as required */
319 job = ASYNC_JOB_new();
321 ASYNC_FIBRE_makecontext(&job->fibrectx);
322 job->funcargs = NULL;
323 sk_ASYNC_JOB_push(pool, job);
328 * Not actually fatal because we already created the pool, just skip
329 * creation of any more jobs
338 void ASYNC_free_pool(void)
343 job = sk_ASYNC_JOB_pop(pool);
346 sk_ASYNC_JOB_free(pool);
349 ASYNC_JOB *ASYNC_get_current_job(void)
352 if((ctx = ASYNC_get_ctx()) == NULL)
358 int ASYNC_get_wait_fd(ASYNC_JOB *job)
363 void ASYNC_wake(ASYNC_JOB *job)
369 async_write1(job->wake_fd, &dummy);
373 void ASYNC_clear_wake(ASYNC_JOB *job)
378 async_read1(job->wait_fd, &dummy);