9b9963fb5ed4625315eb7bc989385a6d7adcdd85
[openssl.git] / crypto / async / async.c
1 /* crypto/async/async.c */
2 /*
3  * Written by Matt Caswell (matt@openssl.org) for the OpenSSL project.
4  */
5 /* ====================================================================
6  * Copyright (c) 2015 The OpenSSL Project.  All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  *
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
18  *    distribution.
19  *
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/)"
24  *
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.
29  *
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.
33  *
34  * 6. Redistributions of any form whatsoever must retain the following
35  *    acknowledgment:
36  *    "This product includes software developed by the OpenSSL Project
37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
38  *
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  * ====================================================================
52  */
53
54 /*
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 :-(
59  */
60 #undef _FORTIFY_SOURCE
61
62 #include <openssl/err.h>
63 #include <openssl/async.h>
64 #include <string.h>
65 #include "async_locl.h"
66
67 #define ASYNC_JOB_RUNNING   0
68 #define ASYNC_JOB_PAUSING   1
69 #define ASYNC_JOB_PAUSED    2
70 #define ASYNC_JOB_STOPPING  3
71
72 static async_ctx *async_ctx_new(void)
73 {
74     async_ctx *nctx = NULL;
75
76     if(!(nctx = OPENSSL_malloc(sizeof (async_ctx)))) {
77         ASYNCerr(ASYNC_F_ASYNC_CTX_NEW, ERR_R_MALLOC_FAILURE);
78         goto err;
79     }
80
81     async_fibre_init_dispatcher(&nctx->dispatcher);
82     nctx->currjob = NULL;
83     nctx->blocked = 0;
84     if(!async_set_ctx(nctx))
85         goto err;
86
87     return nctx;
88 err:
89     if(nctx) {
90         OPENSSL_free(nctx);
91     }
92
93     return NULL;
94 }
95
96 static int async_ctx_free(void)
97 {
98     if(async_get_ctx()) {
99         OPENSSL_free(async_get_ctx());
100     }
101
102     if(!async_set_ctx(NULL))
103         return 0;
104
105     return 1;
106 }
107
108 static ASYNC_JOB *async_job_new(void)
109 {
110     ASYNC_JOB *job = NULL;
111     int pipefds[2];
112
113     if(!(job = OPENSSL_malloc(sizeof (ASYNC_JOB)))) {
114         ASYNCerr(ASYNC_F_ASYNC_JOB_NEW, ERR_R_MALLOC_FAILURE);
115         return NULL;
116     }
117
118     if(!async_pipe(pipefds)) {
119         OPENSSL_free(job);
120         ASYNCerr(ASYNC_F_ASYNC_JOB_NEW, ASYNC_R_CANNOT_CREATE_WAIT_PIPE);
121         return NULL;
122     }
123
124     job->wake_set = 0;
125     job->wait_fd = pipefds[0];
126     job->wake_fd = pipefds[1];
127
128     job->status = ASYNC_JOB_RUNNING;
129     job->funcargs = NULL;
130
131     return job;
132 }
133
134 static void async_job_free(ASYNC_JOB *job)
135 {
136     if(job) {
137         if(job->funcargs)
138             OPENSSL_free(job->funcargs);
139         async_fibre_free(&job->fibrectx);
140         OPENSSL_free(job);
141     }
142 }
143
144 static ASYNC_JOB *async_get_pool_job(void) {
145     ASYNC_JOB *job;
146     STACK_OF(ASYNC_JOB) *pool;
147
148     pool = async_get_pool();
149     if (pool == NULL) {
150         /*
151          * Pool has not been initialised, so init with the defaults, i.e.
152          * no max size and no pre-created jobs
153          */
154         if (ASYNC_init_pool(0, 0) == 0)
155             return NULL;
156         pool = async_get_pool();
157     }
158
159     job = sk_ASYNC_JOB_pop(pool);
160     if (job == NULL) {
161         /* Pool is empty */
162         if (!async_pool_can_grow())
163             return NULL;
164
165         job = async_job_new();
166         if (job) {
167             async_fibre_makecontext(&job->fibrectx);
168             async_increment_pool_size();
169         }
170     }
171     return job;
172 }
173
174 static void async_release_job(ASYNC_JOB *job) {
175     if(job->funcargs)
176         OPENSSL_free(job->funcargs);
177     job->funcargs = NULL;
178     /* Ignore error return */
179     async_release_job_to_pool(job);
180 }
181
182 void async_start_func(void)
183 {
184     ASYNC_JOB *job;
185
186     while (1) {
187         /* Run the job */
188         job = async_get_ctx()->currjob;
189         job->ret = job->func(job->funcargs);
190
191         /* Stop the job */
192         job->status = ASYNC_JOB_STOPPING;
193         if(!async_fibre_swapcontext(&job->fibrectx,
194                                     &async_get_ctx()->dispatcher, 1)) {
195             /*
196              * Should not happen. Getting here will close the thread...can't do
197              * much about it
198              */
199             ASYNCerr(ASYNC_F_ASYNC_START_FUNC, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
200         }
201     }
202 }
203
204 int ASYNC_start_job(ASYNC_JOB **job, int *ret, int (*func)(void *),
205                          void *args, size_t size)
206 {
207     if(!async_get_ctx() && !async_ctx_new()) {
208         return ASYNC_ERR;
209     }
210
211     if(*job) {
212         async_get_ctx()->currjob = *job;
213     }
214
215     for (;;) {
216         if(async_get_ctx()->currjob) {
217             if(async_get_ctx()->currjob->status == ASYNC_JOB_STOPPING) {
218                 *ret = async_get_ctx()->currjob->ret;
219                 async_release_job(async_get_ctx()->currjob);
220                 async_get_ctx()->currjob = NULL;
221                 *job = NULL;
222                 return ASYNC_FINISH;
223             }
224
225             if(async_get_ctx()->currjob->status == ASYNC_JOB_PAUSING) {
226                 *job = async_get_ctx()->currjob;
227                 async_get_ctx()->currjob->status = ASYNC_JOB_PAUSED;
228                 async_get_ctx()->currjob = NULL;
229                 return ASYNC_PAUSE;
230             }
231
232             if(async_get_ctx()->currjob->status == ASYNC_JOB_PAUSED) {
233                 async_get_ctx()->currjob = *job;
234                 /* Resume previous job */
235                 if(!async_fibre_swapcontext(&async_get_ctx()->dispatcher,
236                     &async_get_ctx()->currjob->fibrectx, 1)) {
237                     ASYNCerr(ASYNC_F_ASYNC_START_JOB,
238                              ASYNC_R_FAILED_TO_SWAP_CONTEXT);
239                     goto err;
240                 }
241                 continue;
242             }
243
244             /* Should not happen */
245             ASYNCerr(ASYNC_F_ASYNC_START_JOB, ERR_R_INTERNAL_ERROR);
246             async_release_job(async_get_ctx()->currjob);
247             async_get_ctx()->currjob = NULL;
248             *job = NULL;
249             return ASYNC_ERR;
250         }
251
252         /* Start a new job */
253         if(!(async_get_ctx()->currjob = async_get_pool_job())) {
254             return ASYNC_NO_JOBS;
255         }
256
257         if(args != NULL) {
258             async_get_ctx()->currjob->funcargs = OPENSSL_malloc(size);
259             if(!async_get_ctx()->currjob->funcargs) {
260                 ASYNCerr(ASYNC_F_ASYNC_START_JOB, ERR_R_MALLOC_FAILURE);
261                 async_release_job(async_get_ctx()->currjob);
262                 async_get_ctx()->currjob = NULL;
263                 return ASYNC_ERR;
264             }
265             memcpy(async_get_ctx()->currjob->funcargs, args, size);
266         } else {
267             async_get_ctx()->currjob->funcargs = NULL;
268         }
269
270         async_get_ctx()->currjob->func = func;
271         if(!async_fibre_swapcontext(&async_get_ctx()->dispatcher,
272             &async_get_ctx()->currjob->fibrectx, 1)) {
273             ASYNCerr(ASYNC_F_ASYNC_START_JOB, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
274             goto err;
275         }
276     }
277
278 err:
279     async_release_job(async_get_ctx()->currjob);
280     async_get_ctx()->currjob = NULL;
281     *job = NULL;
282     return ASYNC_ERR;
283 }
284
285
286 int ASYNC_pause_job(void)
287 {
288     ASYNC_JOB *job;
289
290     if (async_get_ctx() == NULL
291             || async_get_ctx()->currjob == NULL
292             || async_get_ctx()->blocked) {
293         /*
294          * Could be we've deliberately not been started within a job so this is
295          * counted as success.
296          */
297         return 1;
298     }
299
300     job = async_get_ctx()->currjob;
301     job->status = ASYNC_JOB_PAUSING;
302
303     if (!async_fibre_swapcontext(&job->fibrectx,
304                                  &async_get_ctx()->dispatcher, 1)) {
305         ASYNCerr(ASYNC_F_ASYNC_PAUSE_JOB, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
306         return 0;
307     }
308
309     return 1;
310 }
311
312 static void async_empty_pool(STACK_OF(ASYNC_JOB) *pool)
313 {
314     ASYNC_JOB *job;
315
316     do {
317         job = sk_ASYNC_JOB_pop(pool);
318         async_job_free(job);
319     } while (job);
320 }
321
322 int ASYNC_init_pool(size_t max_size, size_t init_size)
323 {
324     STACK_OF(ASYNC_JOB) *pool;
325     size_t curr_size = 0;
326
327     if (init_size > max_size) {
328         ASYNCerr(ASYNC_F_ASYNC_INIT_POOL, ASYNC_R_INVALID_POOL_SIZE);
329         return 0;
330     }
331
332     pool = sk_ASYNC_JOB_new_null();
333     if (pool == NULL) {
334         ASYNCerr(ASYNC_F_ASYNC_INIT_POOL, ERR_R_MALLOC_FAILURE);
335         return 0;
336     }
337     /* Pre-create jobs as required */
338     while (init_size) {
339         ASYNC_JOB *job;
340         job = async_job_new();
341         if (job) {
342             async_fibre_makecontext(&job->fibrectx);
343             job->funcargs = NULL;
344             sk_ASYNC_JOB_push(pool, job);
345             curr_size++;
346             init_size--;
347         } else {
348             /*
349              * Not actually fatal because we already created the pool, just skip
350              * creation of any more jobs
351              */
352             init_size = 0;
353         }
354     }
355
356     if (!async_set_pool(pool, curr_size, max_size)) {
357         ASYNCerr(ASYNC_F_ASYNC_INIT_POOL, ASYNC_R_FAILED_TO_SET_POOL);
358         async_empty_pool(pool);
359         sk_ASYNC_JOB_free(pool);
360         return 0;
361     }
362
363     return 1;
364 }
365
366 void ASYNC_free_pool(void)
367 {
368     STACK_OF(ASYNC_JOB) *pool;
369
370     pool = async_get_pool();
371     if (pool == NULL)
372         return;
373
374     async_empty_pool(pool);
375     async_release_pool();
376     async_ctx_free();
377 }
378
379 ASYNC_JOB *ASYNC_get_current_job(void)
380 {
381     async_ctx *ctx;
382     if((ctx = async_get_ctx()) == NULL)
383         return NULL;
384
385     return ctx->currjob;
386 }
387
388 int ASYNC_get_wait_fd(ASYNC_JOB *job)
389 {
390     return job->wait_fd;
391 }
392
393 void ASYNC_wake(ASYNC_JOB *job)
394 {
395     char dummy = 0;
396
397     if (job->wake_set)
398         return;
399     async_write1(job->wake_fd, &dummy);
400     job->wake_set = 1;
401 }
402
403 void ASYNC_clear_wake(ASYNC_JOB *job)
404 {
405     char dummy = 0;
406     if (!job->wake_set)
407         return;
408     async_read1(job->wait_fd, &dummy);
409     job->wake_set = 0;
410 }
411
412 void ASYNC_block_pause(void)
413 {
414     if (async_get_ctx() == NULL
415             || async_get_ctx()->currjob == NULL) {
416         /*
417          * We're not in a job anyway so ignore this
418          */
419         return;
420     }
421     async_get_ctx()->blocked++;
422 }
423
424 void ASYNC_unblock_pause(void)
425 {
426     if (async_get_ctx() == NULL
427             || async_get_ctx()->currjob == NULL) {
428         /*
429          * We're not in a job anyway so ignore this
430          */
431         return;
432     }
433     if(async_get_ctx()->blocked > 0)
434         async_get_ctx()->blocked--;
435 }