d08ac132b7f7ff73624f40c93f282e0afa5779cc
[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     if(!async_set_ctx(nctx))
84         goto err;
85
86     return nctx;
87 err:
88     if(nctx) {
89         OPENSSL_free(nctx);
90     }
91
92     return NULL;
93 }
94
95 static int async_ctx_free(void)
96 {
97     if(async_get_ctx()) {
98         OPENSSL_free(async_get_ctx());
99     }
100
101     if(!async_set_ctx(NULL))
102         return 0;
103
104     return 1;
105 }
106
107 static ASYNC_JOB *async_job_new(void)
108 {
109     ASYNC_JOB *job = NULL;
110     int pipefds[2];
111
112     if(!(job = OPENSSL_malloc(sizeof (ASYNC_JOB)))) {
113         ASYNCerr(ASYNC_F_ASYNC_JOB_NEW, ERR_R_MALLOC_FAILURE);
114         return NULL;
115     }
116
117     if(!async_pipe(pipefds)) {
118         OPENSSL_free(job);
119         ASYNCerr(ASYNC_F_ASYNC_JOB_NEW, ASYNC_R_CANNOT_CREATE_WAIT_PIPE);
120         return NULL;
121     }
122
123     job->wake_set = 0;
124     job->wait_fd = pipefds[0];
125     job->wake_fd = pipefds[1];
126
127     job->status = ASYNC_JOB_RUNNING;
128     job->funcargs = NULL;
129
130     return job;
131 }
132
133 static void async_job_free(ASYNC_JOB *job)
134 {
135     if(job) {
136         if(job->funcargs)
137             OPENSSL_free(job->funcargs);
138         async_fibre_free(&job->fibrectx);
139         OPENSSL_free(job);
140     }
141 }
142
143 static ASYNC_JOB *async_get_pool_job(void) {
144     ASYNC_JOB *job;
145     STACK_OF(ASYNC_JOB) *pool;
146
147     pool = async_get_pool();
148     if (pool == NULL) {
149         /*
150          * Pool has not been initialised, so init with the defaults, i.e.
151          * no max size and no pre-created jobs
152          */
153         if (ASYNC_init_pool(0, 0) == 0)
154             return NULL;
155         pool = async_get_pool();
156     }
157
158     job = sk_ASYNC_JOB_pop(pool);
159     if (job == NULL) {
160         /* Pool is empty */
161         if (!async_pool_can_grow())
162             return NULL;
163
164         job = async_job_new();
165         if (job) {
166             async_fibre_makecontext(&job->fibrectx);
167             async_increment_pool_size();
168         }
169     }
170     return job;
171 }
172
173 static void async_release_job(ASYNC_JOB *job) {
174     if(job->funcargs)
175         OPENSSL_free(job->funcargs);
176     job->funcargs = NULL;
177     /* Ignore error return */
178     async_release_job_to_pool(job);
179 }
180
181 void async_start_func(void)
182 {
183     ASYNC_JOB *job;
184
185     while (1) {
186         /* Run the job */
187         job = async_get_ctx()->currjob;
188         job->ret = job->func(job->funcargs);
189
190         /* Stop the job */
191         job->status = ASYNC_JOB_STOPPING;
192         if(!async_fibre_swapcontext(&job->fibrectx,
193                                     &async_get_ctx()->dispatcher, 1)) {
194             /*
195              * Should not happen. Getting here will close the thread...can't do
196              * much about it
197              */
198             ASYNCerr(ASYNC_F_ASYNC_START_FUNC, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
199         }
200     }
201 }
202
203 int ASYNC_start_job(ASYNC_JOB **job, int *ret, int (*func)(void *),
204                          void *args, size_t size)
205 {
206     if(!async_get_ctx() && !async_ctx_new()) {
207         return ASYNC_ERR;
208     }
209
210     if(*job) {
211         async_get_ctx()->currjob = *job;
212     }
213
214     for (;;) {
215         if(async_get_ctx()->currjob) {
216             if(async_get_ctx()->currjob->status == ASYNC_JOB_STOPPING) {
217                 *ret = async_get_ctx()->currjob->ret;
218                 async_release_job(async_get_ctx()->currjob);
219                 async_get_ctx()->currjob = NULL;
220                 *job = NULL;
221                 return ASYNC_FINISH;
222             }
223
224             if(async_get_ctx()->currjob->status == ASYNC_JOB_PAUSING) {
225                 *job = async_get_ctx()->currjob;
226                 async_get_ctx()->currjob->status = ASYNC_JOB_PAUSED;
227                 async_get_ctx()->currjob = NULL;
228                 return ASYNC_PAUSE;
229             }
230
231             if(async_get_ctx()->currjob->status == ASYNC_JOB_PAUSED) {
232                 async_get_ctx()->currjob = *job;
233                 /* Resume previous job */
234                 if(!async_fibre_swapcontext(&async_get_ctx()->dispatcher,
235                     &async_get_ctx()->currjob->fibrectx, 1)) {
236                     ASYNCerr(ASYNC_F_ASYNC_START_JOB,
237                              ASYNC_R_FAILED_TO_SWAP_CONTEXT);
238                     goto err;
239                 }
240                 continue;
241             }
242
243             /* Should not happen */
244             ASYNCerr(ASYNC_F_ASYNC_START_JOB, ERR_R_INTERNAL_ERROR);
245             async_release_job(async_get_ctx()->currjob);
246             async_get_ctx()->currjob = NULL;
247             *job = NULL;
248             return ASYNC_ERR;
249         }
250
251         /* Start a new job */
252         if(!(async_get_ctx()->currjob = async_get_pool_job())) {
253             return ASYNC_NO_JOBS;
254         }
255
256         if(args != NULL) {
257             async_get_ctx()->currjob->funcargs = OPENSSL_malloc(size);
258             if(!async_get_ctx()->currjob->funcargs) {
259                 ASYNCerr(ASYNC_F_ASYNC_START_JOB, ERR_R_MALLOC_FAILURE);
260                 async_release_job(async_get_ctx()->currjob);
261                 async_get_ctx()->currjob = NULL;
262                 return ASYNC_ERR;
263             }
264             memcpy(async_get_ctx()->currjob->funcargs, args, size);
265         } else {
266             async_get_ctx()->currjob->funcargs = NULL;
267         }
268
269         async_get_ctx()->currjob->func = func;
270         if(!async_fibre_swapcontext(&async_get_ctx()->dispatcher,
271             &async_get_ctx()->currjob->fibrectx, 1)) {
272             ASYNCerr(ASYNC_F_ASYNC_START_JOB, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
273             goto err;
274         }
275     }
276
277 err:
278     async_release_job(async_get_ctx()->currjob);
279     async_get_ctx()->currjob = NULL;
280     *job = NULL;
281     return ASYNC_ERR;
282 }
283
284
285 int ASYNC_pause_job(void)
286 {
287     ASYNC_JOB *job;
288
289     if(!async_get_ctx() || !async_get_ctx()->currjob) {
290         /*
291          * Could be we've deliberately not been started within a job so this is
292          * counted as success.
293          */
294         return 1;
295     }
296
297     job = async_get_ctx()->currjob;
298     job->status = ASYNC_JOB_PAUSING;
299
300     if(!async_fibre_swapcontext(&job->fibrectx,
301                                &async_get_ctx()->dispatcher, 1)) {
302         ASYNCerr(ASYNC_F_ASYNC_PAUSE_JOB, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
303         return 0;
304     }
305
306     return 1;
307 }
308
309 static void async_empty_pool(STACK_OF(ASYNC_JOB) *pool)
310 {
311     ASYNC_JOB *job;
312
313     do {
314         job = sk_ASYNC_JOB_pop(pool);
315         async_job_free(job);
316     } while (job);
317 }
318
319 int ASYNC_init_pool(size_t max_size, size_t init_size)
320 {
321     STACK_OF(ASYNC_JOB) *pool;
322     size_t curr_size = 0;
323
324     if (init_size > max_size) {
325         ASYNCerr(ASYNC_F_ASYNC_INIT_POOL, ASYNC_R_INVALID_POOL_SIZE);
326         return 0;
327     }
328
329     pool = sk_ASYNC_JOB_new_null();
330     if (pool == NULL) {
331         ASYNCerr(ASYNC_F_ASYNC_INIT_POOL, ERR_R_MALLOC_FAILURE);
332         return 0;
333     }
334     /* Pre-create jobs as required */
335     while (init_size) {
336         ASYNC_JOB *job;
337         job = async_job_new();
338         if (job) {
339             async_fibre_makecontext(&job->fibrectx);
340             job->funcargs = NULL;
341             sk_ASYNC_JOB_push(pool, job);
342             curr_size++;
343             init_size--;
344         } else {
345             /*
346              * Not actually fatal because we already created the pool, just skip
347              * creation of any more jobs
348              */
349             init_size = 0;
350         }
351     }
352
353     if (!async_set_pool(pool, curr_size, max_size)) {
354         ASYNCerr(ASYNC_F_ASYNC_INIT_POOL, ASYNC_R_FAILED_TO_SET_POOL);
355         async_empty_pool(pool);
356         sk_ASYNC_JOB_free(pool);
357         return 0;
358     }
359
360     return 1;
361 }
362
363 void ASYNC_free_pool(void)
364 {
365     STACK_OF(ASYNC_JOB) *pool;
366
367     pool = async_get_pool();
368     if (pool == NULL)
369         return;
370
371     async_empty_pool(pool);
372     async_release_pool();
373     async_ctx_free();
374 }
375
376 ASYNC_JOB *ASYNC_get_current_job(void)
377 {
378     async_ctx *ctx;
379     if((ctx = async_get_ctx()) == NULL)
380         return NULL;
381
382     return ctx->currjob;
383 }
384
385 int ASYNC_get_wait_fd(ASYNC_JOB *job)
386 {
387     return job->wait_fd;
388 }
389
390 void ASYNC_wake(ASYNC_JOB *job)
391 {
392     char dummy = 0;
393
394     if (job->wake_set)
395         return;
396     async_write1(job->wake_fd, &dummy);
397     job->wake_set = 1;
398 }
399
400 void ASYNC_clear_wake(ASYNC_JOB *job)
401 {
402     char dummy = 0;
403     if (!job->wake_set)
404         return;
405     async_read1(job->wait_fd, &dummy);
406     job->wake_set = 0;
407 }