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