Make the ASYNC code default libctx aware
[openssl.git] / crypto / async / async.c
1 /*
2  * Copyright 2015-2018 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 /*
11  * Without this we start getting longjmp crashes because it thinks we're jumping
12  * up the stack when in fact we are jumping to an entirely different stack. The
13  * cost of this is not having certain buffer overrun/underrun checks etc for
14  * this source file :-(
15  */
16 #undef _FORTIFY_SOURCE
17
18 /* This must be the first #include file */
19 #include "async_local.h"
20
21 #include <openssl/err.h>
22 #include "crypto/cryptlib.h"
23 #include <string.h>
24
25 #define ASYNC_JOB_RUNNING   0
26 #define ASYNC_JOB_PAUSING   1
27 #define ASYNC_JOB_PAUSED    2
28 #define ASYNC_JOB_STOPPING  3
29
30 static CRYPTO_THREAD_LOCAL ctxkey;
31 static CRYPTO_THREAD_LOCAL poolkey;
32
33 static void async_delete_thread_state(void *arg);
34
35 static async_ctx *async_ctx_new(void)
36 {
37     async_ctx *nctx;
38
39     if (!ossl_init_thread_start(NULL, NULL, async_delete_thread_state))
40         return NULL;
41
42     nctx = OPENSSL_malloc(sizeof(*nctx));
43     if (nctx == NULL) {
44         ASYNCerr(ASYNC_F_ASYNC_CTX_NEW, ERR_R_MALLOC_FAILURE);
45         goto err;
46     }
47
48     async_fibre_init_dispatcher(&nctx->dispatcher);
49     nctx->currjob = NULL;
50     nctx->blocked = 0;
51     if (!CRYPTO_THREAD_set_local(&ctxkey, nctx))
52         goto err;
53
54     return nctx;
55 err:
56     OPENSSL_free(nctx);
57
58     return NULL;
59 }
60
61 async_ctx *async_get_ctx(void)
62 {
63     return (async_ctx *)CRYPTO_THREAD_get_local(&ctxkey);
64 }
65
66 static int async_ctx_free(void)
67 {
68     async_ctx *ctx;
69
70     ctx = async_get_ctx();
71
72     if (!CRYPTO_THREAD_set_local(&ctxkey, NULL))
73         return 0;
74
75     OPENSSL_free(ctx);
76
77     return 1;
78 }
79
80 static ASYNC_JOB *async_job_new(void)
81 {
82     ASYNC_JOB *job = NULL;
83
84     job = OPENSSL_zalloc(sizeof(*job));
85     if (job == NULL) {
86         ASYNCerr(ASYNC_F_ASYNC_JOB_NEW, ERR_R_MALLOC_FAILURE);
87         return NULL;
88     }
89
90     job->status = ASYNC_JOB_RUNNING;
91
92     return job;
93 }
94
95 static void async_job_free(ASYNC_JOB *job)
96 {
97     if (job != NULL) {
98         OPENSSL_free(job->funcargs);
99         async_fibre_free(&job->fibrectx);
100         OPENSSL_free(job);
101     }
102 }
103
104 static ASYNC_JOB *async_get_pool_job(void) {
105     ASYNC_JOB *job;
106     async_pool *pool;
107
108     pool = (async_pool *)CRYPTO_THREAD_get_local(&poolkey);
109     if (pool == NULL) {
110         /*
111          * Pool has not been initialised, so init with the defaults, i.e.
112          * no max size and no pre-created jobs
113          */
114         if (ASYNC_init_thread(0, 0) == 0)
115             return NULL;
116         pool = (async_pool *)CRYPTO_THREAD_get_local(&poolkey);
117     }
118
119     job = sk_ASYNC_JOB_pop(pool->jobs);
120     if (job == NULL) {
121         /* Pool is empty */
122         if ((pool->max_size != 0) && (pool->curr_size >= pool->max_size))
123             return NULL;
124
125         job = async_job_new();
126         if (job != NULL) {
127             if (! async_fibre_makecontext(&job->fibrectx)) {
128                 async_job_free(job);
129                 return NULL;
130             }
131             pool->curr_size++;
132         }
133     }
134     return job;
135 }
136
137 static void async_release_job(ASYNC_JOB *job) {
138     async_pool *pool;
139
140     pool = (async_pool *)CRYPTO_THREAD_get_local(&poolkey);
141     OPENSSL_free(job->funcargs);
142     job->funcargs = NULL;
143     sk_ASYNC_JOB_push(pool->jobs, job);
144 }
145
146 void async_start_func(void)
147 {
148     ASYNC_JOB *job;
149     async_ctx *ctx = async_get_ctx();
150
151     while (1) {
152         /* Run the job */
153         job = ctx->currjob;
154         job->ret = job->func(job->funcargs);
155
156         /* Stop the job */
157         job->status = ASYNC_JOB_STOPPING;
158         if (!async_fibre_swapcontext(&job->fibrectx,
159                                      &ctx->dispatcher, 1)) {
160             /*
161              * Should not happen. Getting here will close the thread...can't do
162              * much about it
163              */
164             ASYNCerr(ASYNC_F_ASYNC_START_FUNC, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
165         }
166     }
167 }
168
169 int ASYNC_start_job(ASYNC_JOB **job, ASYNC_WAIT_CTX *wctx, int *ret,
170                     int (*func)(void *), void *args, size_t size)
171 {
172     async_ctx *ctx;
173     OPENSSL_CTX *libctx;
174
175     if (!OPENSSL_init_crypto(OPENSSL_INIT_ASYNC, NULL))
176         return ASYNC_ERR;
177
178     ctx = async_get_ctx();
179     if (ctx == NULL)
180         ctx = async_ctx_new();
181     if (ctx == NULL)
182         return ASYNC_ERR;
183
184     if (*job)
185         ctx->currjob = *job;
186
187     for (;;) {
188         if (ctx->currjob != NULL) {
189             if (ctx->currjob->status == ASYNC_JOB_STOPPING) {
190                 *ret = ctx->currjob->ret;
191                 ctx->currjob->waitctx = NULL;
192                 async_release_job(ctx->currjob);
193                 ctx->currjob = NULL;
194                 *job = NULL;
195                 return ASYNC_FINISH;
196             }
197
198             if (ctx->currjob->status == ASYNC_JOB_PAUSING) {
199                 *job = ctx->currjob;
200                 ctx->currjob->status = ASYNC_JOB_PAUSED;
201                 ctx->currjob = NULL;
202                 return ASYNC_PAUSE;
203             }
204
205             if (ctx->currjob->status == ASYNC_JOB_PAUSED) {
206                 ctx->currjob = *job;
207                 /*
208                  * Restore the default libctx to what it was the last time the
209                  * fibre ran
210                  */
211                 libctx = OPENSSL_CTX_set0_default(ctx->currjob->libctx);
212                 /* Resume previous job */
213                 if (!async_fibre_swapcontext(&ctx->dispatcher,
214                         &ctx->currjob->fibrectx, 1)) {
215                     ASYNCerr(ASYNC_F_ASYNC_START_JOB,
216                              ASYNC_R_FAILED_TO_SWAP_CONTEXT);
217                     goto err;
218                 }
219                 /*
220                  * In case the fibre changed the default libctx we set it back
221                  * again to what it was originally, and remember what it had
222                  * been changed to.
223                  */
224                 ctx->currjob->libctx = OPENSSL_CTX_set0_default(libctx);
225                 continue;
226             }
227
228             /* Should not happen */
229             ASYNCerr(ASYNC_F_ASYNC_START_JOB, ERR_R_INTERNAL_ERROR);
230             async_release_job(ctx->currjob);
231             ctx->currjob = NULL;
232             *job = NULL;
233             return ASYNC_ERR;
234         }
235
236         /* Start a new job */
237         if ((ctx->currjob = async_get_pool_job()) == NULL)
238             return ASYNC_NO_JOBS;
239
240         if (args != NULL) {
241             ctx->currjob->funcargs = OPENSSL_malloc(size);
242             if (ctx->currjob->funcargs == NULL) {
243                 ASYNCerr(ASYNC_F_ASYNC_START_JOB, ERR_R_MALLOC_FAILURE);
244                 async_release_job(ctx->currjob);
245                 ctx->currjob = NULL;
246                 return ASYNC_ERR;
247             }
248             memcpy(ctx->currjob->funcargs, args, size);
249         } else {
250             ctx->currjob->funcargs = NULL;
251         }
252
253         ctx->currjob->func = func;
254         ctx->currjob->waitctx = wctx;
255         libctx = openssl_ctx_get_concrete(NULL);
256         if (!async_fibre_swapcontext(&ctx->dispatcher,
257                 &ctx->currjob->fibrectx, 1)) {
258             ASYNCerr(ASYNC_F_ASYNC_START_JOB, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
259             goto err;
260         }
261         /*
262          * In case the fibre changed the default libctx we set it back again
263          * to what it was, and remember what it had been changed to.
264          */
265         ctx->currjob->libctx = OPENSSL_CTX_set0_default(libctx);
266     }
267
268 err:
269     async_release_job(ctx->currjob);
270     ctx->currjob = NULL;
271     *job = NULL;
272     return ASYNC_ERR;
273 }
274
275 int ASYNC_pause_job(void)
276 {
277     ASYNC_JOB *job;
278     async_ctx *ctx = async_get_ctx();
279
280     if (ctx == NULL
281             || ctx->currjob == NULL
282             || ctx->blocked) {
283         /*
284          * Could be we've deliberately not been started within a job so this is
285          * counted as success.
286          */
287         return 1;
288     }
289
290     job = ctx->currjob;
291     job->status = ASYNC_JOB_PAUSING;
292
293     if (!async_fibre_swapcontext(&job->fibrectx,
294                                  &ctx->dispatcher, 1)) {
295         ASYNCerr(ASYNC_F_ASYNC_PAUSE_JOB, ASYNC_R_FAILED_TO_SWAP_CONTEXT);
296         return 0;
297     }
298     /* Reset counts of added and deleted fds */
299     async_wait_ctx_reset_counts(job->waitctx);
300
301     return 1;
302 }
303
304 static void async_empty_pool(async_pool *pool)
305 {
306     ASYNC_JOB *job;
307
308     if (pool == NULL || pool->jobs == NULL)
309         return;
310
311     do {
312         job = sk_ASYNC_JOB_pop(pool->jobs);
313         async_job_free(job);
314     } while (job);
315 }
316
317 int async_init(void)
318 {
319     if (!CRYPTO_THREAD_init_local(&ctxkey, NULL))
320         return 0;
321
322     if (!CRYPTO_THREAD_init_local(&poolkey, NULL)) {
323         CRYPTO_THREAD_cleanup_local(&ctxkey);
324         return 0;
325     }
326
327     return 1;
328 }
329
330 void async_deinit(void)
331 {
332     CRYPTO_THREAD_cleanup_local(&ctxkey);
333     CRYPTO_THREAD_cleanup_local(&poolkey);
334 }
335
336 int ASYNC_init_thread(size_t max_size, size_t init_size)
337 {
338     async_pool *pool;
339     size_t curr_size = 0;
340
341     if (init_size > max_size) {
342         ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ASYNC_R_INVALID_POOL_SIZE);
343         return 0;
344     }
345
346     if (!OPENSSL_init_crypto(OPENSSL_INIT_ASYNC, NULL))
347         return 0;
348
349     if (!ossl_init_thread_start(NULL, NULL, async_delete_thread_state))
350         return 0;
351
352     pool = OPENSSL_zalloc(sizeof(*pool));
353     if (pool == NULL) {
354         ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ERR_R_MALLOC_FAILURE);
355         return 0;
356     }
357
358     pool->jobs = sk_ASYNC_JOB_new_reserve(NULL, init_size);
359     if (pool->jobs == NULL) {
360         ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ERR_R_MALLOC_FAILURE);
361         OPENSSL_free(pool);
362         return 0;
363     }
364
365     pool->max_size = max_size;
366
367     /* Pre-create jobs as required */
368     while (init_size--) {
369         ASYNC_JOB *job;
370         job = async_job_new();
371         if (job == NULL || !async_fibre_makecontext(&job->fibrectx)) {
372             /*
373              * Not actually fatal because we already created the pool, just
374              * skip creation of any more jobs
375              */
376             async_job_free(job);
377             break;
378         }
379         job->funcargs = NULL;
380         sk_ASYNC_JOB_push(pool->jobs, job); /* Cannot fail due to reserve */
381         curr_size++;
382     }
383     pool->curr_size = curr_size;
384     if (!CRYPTO_THREAD_set_local(&poolkey, pool)) {
385         ASYNCerr(ASYNC_F_ASYNC_INIT_THREAD, ASYNC_R_FAILED_TO_SET_POOL);
386         goto err;
387     }
388
389     return 1;
390 err:
391     async_empty_pool(pool);
392     sk_ASYNC_JOB_free(pool->jobs);
393     OPENSSL_free(pool);
394     return 0;
395 }
396
397 /* TODO(3.0): arg ignored for now */
398 static void async_delete_thread_state(void *arg)
399 {
400     async_pool *pool = (async_pool *)CRYPTO_THREAD_get_local(&poolkey);
401
402     if (pool != NULL) {
403         async_empty_pool(pool);
404         sk_ASYNC_JOB_free(pool->jobs);
405         OPENSSL_free(pool);
406         CRYPTO_THREAD_set_local(&poolkey, NULL);
407     }
408     async_local_cleanup();
409     async_ctx_free();
410 }
411
412 void ASYNC_cleanup_thread(void)
413 {
414     if (!OPENSSL_init_crypto(OPENSSL_INIT_ASYNC, NULL))
415         return;
416
417     async_delete_thread_state(NULL);
418 }
419
420 ASYNC_JOB *ASYNC_get_current_job(void)
421 {
422     async_ctx *ctx;
423
424     if (!OPENSSL_init_crypto(OPENSSL_INIT_ASYNC, NULL))
425         return NULL;
426
427     ctx = async_get_ctx();
428     if (ctx == NULL)
429         return NULL;
430
431     return ctx->currjob;
432 }
433
434 ASYNC_WAIT_CTX *ASYNC_get_wait_ctx(ASYNC_JOB *job)
435 {
436     return job->waitctx;
437 }
438
439 void ASYNC_block_pause(void)
440 {
441     async_ctx *ctx;
442
443     if (!OPENSSL_init_crypto(OPENSSL_INIT_ASYNC, NULL))
444         return;
445
446     ctx = async_get_ctx();
447     if (ctx == NULL || ctx->currjob == NULL) {
448         /*
449          * We're not in a job anyway so ignore this
450          */
451         return;
452     }
453     ctx->blocked++;
454 }
455
456 void ASYNC_unblock_pause(void)
457 {
458     async_ctx *ctx;
459
460     if (!OPENSSL_init_crypto(OPENSSL_INIT_ASYNC, NULL))
461         return;
462
463     ctx = async_get_ctx();
464     if (ctx == NULL || ctx->currjob == NULL) {
465         /*
466          * We're not in a job anyway so ignore this
467          */
468         return;
469     }
470     if (ctx->blocked > 0)
471         ctx->blocked--;
472 }