c1f9b224786f3cc780c1a3bc1e641889d7988368
[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 #include <openssl/async.h>
55 #include <string.h>
56 #include "async_locl.h"
57
58 #define ASYNC_JOB_RUNNING   0
59 #define ASYNC_JOB_PAUSING   1
60 #define ASYNC_JOB_PAUSED    2
61 #define ASYNC_JOB_STOPPING  3
62
63 static ASYNC_CTX *ASYNC_CTX_new(void)
64 {
65     ASYNC_CTX *nctx = NULL;
66
67     if(!(nctx = OPENSSL_malloc(sizeof (ASYNC_CTX)))) {
68         /* Error here */
69         goto err;
70     }
71
72     ASYNC_FIBRE_init_dispatcher(&nctx->dispatcher);
73     nctx->currjob = NULL;
74     if(!ASYNC_set_ctx(nctx))
75         goto err;
76
77     return nctx;
78 err:
79     if(nctx) {
80         OPENSSL_free(nctx);
81     }
82
83     return NULL;
84 }
85
86 static int ASYNC_CTX_free(void)
87 {
88     if(ASYNC_get_ctx()) {
89         OPENSSL_free(ASYNC_get_ctx());
90     }
91
92     if(!ASYNC_set_ctx(NULL))
93         return 0;
94
95     return 1;
96 }
97
98 static ASYNC_JOB *ASYNC_JOB_new(void)
99 {
100     ASYNC_JOB *job = NULL;
101     int pipefds[2];
102
103     if(!(job = OPENSSL_malloc(sizeof (ASYNC_JOB)))) {
104         return NULL;
105     }
106
107     if(!async_pipe(pipefds)) {
108         OPENSSL_free(job);
109         return NULL;
110     }
111
112     job->wake_set = 0;
113     job->wait_fd = pipefds[0];
114     job->wake_fd = pipefds[1];
115
116     job->status = ASYNC_JOB_RUNNING;
117     job->funcargs = NULL;
118
119     return job;
120 }
121
122 static void ASYNC_JOB_free(ASYNC_JOB *job)
123 {
124     if(job) {
125         if(job->funcargs)
126             OPENSSL_free(job->funcargs);
127         ASYNC_FIBRE_free(&job->fibrectx);
128         OPENSSL_free(job);
129     }
130 }
131
132 static ASYNC_JOB *async_get_pool_job(void) {
133     ASYNC_JOB *job;
134     STACK_OF(ASYNC_JOB) *pool;
135
136     pool = async_get_pool();
137     if (pool == NULL) {
138         /*
139          * Pool has not been initialised, so init with the defaults, i.e.
140          * global pool, with no max size and no pre-created jobs
141          */
142         if (ASYNC_init_pool(0, 0) == 0)
143             return NULL;
144         pool = async_get_pool();
145     }
146
147     job = sk_ASYNC_JOB_pop(pool);
148     if (job == NULL) {
149         /* Pool is empty */
150         if (!async_pool_can_grow())
151             return NULL;
152
153         job = ASYNC_JOB_new();
154         if (job) {
155             ASYNC_FIBRE_makecontext(&job->fibrectx);
156             async_increment_pool_size();
157         }
158     }
159     return job;
160 }
161
162 static void async_release_job(ASYNC_JOB *job) {
163     if(job->funcargs)
164         OPENSSL_free(job->funcargs);
165     job->funcargs = NULL;
166     /* Ignore error return */
167     async_release_job_to_pool(job);
168 }
169
170 void ASYNC_start_func(void)
171 {
172     ASYNC_JOB *job;
173
174     while (1) {
175         /* Run the job */
176         job = ASYNC_get_ctx()->currjob;
177         job->ret = job->func(job->funcargs);
178
179         /* Stop the job */
180         job->status = ASYNC_JOB_STOPPING;
181         if(!ASYNC_FIBRE_swapcontext(&job->fibrectx,
182                                     &ASYNC_get_ctx()->dispatcher, 1)) {
183             /*
184              * Should not happen. Getting here will close the thread...can't do much
185              * about it
186              */
187         }
188     }
189 }
190
191 int ASYNC_start_job(ASYNC_JOB **job, int *ret, int (*func)(void *),
192                          void *args, size_t size)
193 {
194     if(ASYNC_get_ctx() || !ASYNC_CTX_new()) {
195         return ASYNC_ERR;
196     }
197
198     if(*job) {
199         ASYNC_get_ctx()->currjob = *job;
200     }
201
202     for (;;) {
203         if(ASYNC_get_ctx()->currjob) {
204             if(ASYNC_get_ctx()->currjob->status == ASYNC_JOB_STOPPING) {
205                 *ret = ASYNC_get_ctx()->currjob->ret;
206                 async_release_job(ASYNC_get_ctx()->currjob);
207                 ASYNC_get_ctx()->currjob = NULL;
208                 *job = NULL;
209                 ASYNC_CTX_free();
210                 return ASYNC_FINISH;
211             }
212
213             if(ASYNC_get_ctx()->currjob->status == ASYNC_JOB_PAUSING) {
214                 *job = ASYNC_get_ctx()->currjob;
215                 ASYNC_get_ctx()->currjob->status = ASYNC_JOB_PAUSED;
216                 ASYNC_CTX_free();
217                 return ASYNC_PAUSE;
218             }
219
220             if(ASYNC_get_ctx()->currjob->status == ASYNC_JOB_PAUSED) {
221                 ASYNC_get_ctx()->currjob = *job;
222                 /* Resume previous job */
223                 if(!ASYNC_FIBRE_swapcontext(&ASYNC_get_ctx()->dispatcher,
224                     &ASYNC_get_ctx()->currjob->fibrectx, 1))
225                     goto err;
226                 continue;
227             }
228
229             /* Should not happen */
230             async_release_job(ASYNC_get_ctx()->currjob);
231             ASYNC_get_ctx()->currjob = NULL;
232             *job = NULL;
233             ASYNC_CTX_free();
234             return ASYNC_ERR;
235         }
236
237         /* Start a new job */
238         if(!(ASYNC_get_ctx()->currjob = async_get_pool_job())) {
239             ASYNC_CTX_free();
240             return ASYNC_NO_JOBS;
241         }
242
243         if(args != NULL) {
244             ASYNC_get_ctx()->currjob->funcargs = OPENSSL_malloc(size);
245             if(!ASYNC_get_ctx()->currjob->funcargs) {
246                 async_release_job(ASYNC_get_ctx()->currjob);
247                 ASYNC_get_ctx()->currjob = NULL;
248                 ASYNC_CTX_free();
249                 return ASYNC_ERR;
250             }
251             memcpy(ASYNC_get_ctx()->currjob->funcargs, args, size);
252         } else {
253             ASYNC_get_ctx()->currjob->funcargs = NULL;
254         }
255
256         ASYNC_get_ctx()->currjob->func = func;
257         if(!ASYNC_FIBRE_swapcontext(&ASYNC_get_ctx()->dispatcher,
258             &ASYNC_get_ctx()->currjob->fibrectx, 1))
259             goto err;
260     }
261
262 err:
263     async_release_job(ASYNC_get_ctx()->currjob);
264     ASYNC_get_ctx()->currjob = NULL;
265     *job = NULL;
266     ASYNC_CTX_free();
267     return ASYNC_ERR;
268 }
269
270
271 int ASYNC_pause_job(void)
272 {
273     ASYNC_JOB *job;
274
275     if(!ASYNC_get_ctx() || !ASYNC_get_ctx()->currjob)
276         return 0;
277
278     job = ASYNC_get_ctx()->currjob;
279     job->status = ASYNC_JOB_PAUSING;
280
281     if(!ASYNC_FIBRE_swapcontext(&job->fibrectx,
282                                &ASYNC_get_ctx()->dispatcher, 1)) {
283         /* Error */
284         return 0;
285     }
286
287     return 1;
288 }
289
290 int ASYNC_in_job(void)
291 {
292     if(ASYNC_get_ctx())
293         return 1;
294
295     return 0;
296 }
297
298 int ASYNC_init_pool(size_t max_size, size_t init_size)
299 {
300     STACK_OF(ASYNC_JOB) *pool;
301     size_t curr_size = 0;
302
303     if (init_size > max_size)
304         return 0;
305
306     pool = sk_ASYNC_JOB_new_null();
307     if (pool == NULL) {
308         return 0;
309     }
310     /* Pre-create jobs as required */
311     while (init_size) {
312         ASYNC_JOB *job;
313         job = ASYNC_JOB_new();
314         if (job) {
315             ASYNC_FIBRE_makecontext(&job->fibrectx);
316             job->funcargs = NULL;
317             sk_ASYNC_JOB_push(pool, job);
318             curr_size++;
319             init_size--;
320         } else {
321             /*
322              * Not actually fatal because we already created the pool, just skip
323              * creation of any more jobs
324              */
325             init_size = 0;
326         }
327     }
328
329     async_set_pool(pool, curr_size, max_size);
330
331     return 1;
332 }
333
334 void ASYNC_free_pool(void)
335 {
336     ASYNC_JOB *job;
337     STACK_OF(ASYNC_JOB) *pool;
338
339     pool = async_get_pool();
340     if (pool == NULL)
341         return;
342     do {
343         job = sk_ASYNC_JOB_pop(pool);
344         ASYNC_JOB_free(job);
345     } while (job);
346     async_release_pool();
347 }
348
349 ASYNC_JOB *ASYNC_get_current_job(void)
350 {
351     ASYNC_CTX *ctx;
352     if((ctx = ASYNC_get_ctx()) == NULL)
353         return NULL;
354
355     return ctx->currjob;
356 }
357
358 int ASYNC_get_wait_fd(ASYNC_JOB *job)
359 {
360     return job->wait_fd;
361 }
362
363 void ASYNC_wake(ASYNC_JOB *job)
364 {
365     char dummy = 0;
366
367     if (job->wake_set)
368         return;
369     async_write1(job->wake_fd, &dummy);
370     job->wake_set = 1;
371 }
372
373 void ASYNC_clear_wake(ASYNC_JOB *job)
374 {
375     char dummy = 0;
376     if (!job->wake_set)
377         return;
378     async_read1(job->wait_fd, &dummy);
379     job->wake_set = 0;
380 }