5bf64afa226cb84803e8c9d9b94ff2ed1d5c4e4c
[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     nctx = OPENSSL_malloc(sizeof (async_ctx));
77     if (nctx == NULL) {
78         ASYNCerr(ASYNC_F_ASYNC_CTX_NEW, ERR_R_MALLOC_FAILURE);
79         goto err;
80     }
81
82     async_fibre_init_dispatcher(&nctx->dispatcher);
83     nctx->currjob = NULL;
84     nctx->blocked = 0;
85     if (!async_set_ctx(nctx))
86         goto err;
87
88     return nctx;
89 err:
90     OPENSSL_free(nctx);
91
92     return NULL;
93 }
94
95 static int async_ctx_free(void)
96 {
97     async_ctx *ctx;
98
99     ctx = async_get_ctx();
100
101     if (!async_set_ctx(NULL))
102         return 0;
103
104     OPENSSL_free(ctx);
105
106     return 1;
107 }
108
109 static ASYNC_JOB *async_job_new(void)
110 {
111     ASYNC_JOB *job = NULL;
112     OSSL_ASYNC_FD pipefds[2];
113
114     job = OPENSSL_malloc(sizeof (ASYNC_JOB));
115     if (job == NULL) {
116         ASYNCerr(ASYNC_F_ASYNC_JOB_NEW, ERR_R_MALLOC_FAILURE);
117         return NULL;
118     }
119
120     if (!async_pipe(pipefds)) {
121         OPENSSL_free(job);
122         ASYNCerr(ASYNC_F_ASYNC_JOB_NEW, ASYNC_R_CANNOT_CREATE_WAIT_PIPE);
123         return NULL;
124     }
125
126     job->wake_set = 0;
127     job->wait_fd = pipefds[0];
128     job->wake_fd = pipefds[1];
129
130     job->status = ASYNC_JOB_RUNNING;
131     job->funcargs = NULL;
132
133     return job;
134 }
135
136 static void async_job_free(ASYNC_JOB *job)
137 {
138     if (job != NULL) {
139         OPENSSL_free(job->funcargs);
140         async_fibre_free(&job->fibrectx);
141         OPENSSL_free(job);
142     }
143 }
144
145 static ASYNC_JOB *async_get_pool_job(void) {
146     ASYNC_JOB *job;
147     STACK_OF(ASYNC_JOB) *pool;
148
149     pool = async_get_pool();
150     if (pool == NULL) {
151         /*
152          * Pool has not been initialised, so init with the defaults, i.e.
153          * no max size and no pre-created jobs
154          */
155         if (ASYNC_init_pool(0, 0) == 0)
156             return NULL;
157         pool = async_get_pool();
158     }
159
160     job = sk_ASYNC_JOB_pop(pool);
161     if (job == NULL) {
162         /* Pool is empty */
163         if (!async_pool_can_grow())
164             return NULL;
165
166         job = async_job_new();
167         if (job) {
168             async_fibre_makecontext(&job->fibrectx);
169             async_increment_pool_size();
170         }
171     }
172     return job;
173 }
174
175 static void async_release_job(ASYNC_JOB *job) {
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() == NULL && async_ctx_new() == NULL) {
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 != NULL) {
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()) == NULL) {
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 == NULL) {
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
383     ctx = async_get_ctx();
384     if(ctx == NULL)
385         return NULL;
386
387     return ctx->currjob;
388 }
389
390 OSSL_ASYNC_FD ASYNC_get_wait_fd(ASYNC_JOB *job)
391 {
392     return job->wait_fd;
393 }
394
395 void ASYNC_wake(ASYNC_JOB *job)
396 {
397     char dummy = 0;
398
399     if (job->wake_set)
400         return;
401     async_write1(job->wake_fd, &dummy);
402     job->wake_set = 1;
403 }
404
405 void ASYNC_clear_wake(ASYNC_JOB *job)
406 {
407     char dummy = 0;
408     if (!job->wake_set)
409         return;
410     async_read1(job->wait_fd, &dummy);
411     job->wake_set = 0;
412 }
413
414 void ASYNC_block_pause(void)
415 {
416     if (async_get_ctx() == NULL
417             || async_get_ctx()->currjob == NULL) {
418         /*
419          * We're not in a job anyway so ignore this
420          */
421         return;
422     }
423     async_get_ctx()->blocked++;
424 }
425
426 void ASYNC_unblock_pause(void)
427 {
428     if (async_get_ctx() == NULL
429             || async_get_ctx()->currjob == NULL) {
430         /*
431          * We're not in a job anyway so ignore this
432          */
433         return;
434     }
435     if(async_get_ctx()->blocked > 0)
436         async_get_ctx()->blocked--;
437 }