| /* |
| * Copyright 2015-2020 The OpenSSL Project Authors. All Rights Reserved. |
| * |
| * Licensed under the Apache License 2.0 (the "License"). You may not use |
| * this file except in compliance with the License. You can obtain a copy |
| * in the file LICENSE in the source distribution or at |
| * https://www.openssl.org/source/license.html |
| */ |
| |
| /* This must be the first #include file */ |
| #include "../async_local.h" |
| |
| #ifdef ASYNC_POSIX |
| |
| # include <stddef.h> |
| # include <unistd.h> |
| # include <openssl/err.h> |
| # include <openssl/crypto.h> |
| |
| #define STACKSIZE 32768 |
| |
| static CRYPTO_RWLOCK *async_mem_lock; |
| |
| static void *async_stack_alloc(size_t *num); |
| static void async_stack_free(void *addr); |
| |
| int async_local_init(void) |
| { |
| async_mem_lock = CRYPTO_THREAD_lock_new(); |
| return async_mem_lock != NULL; |
| } |
| |
| void async_local_deinit(void) |
| { |
| CRYPTO_THREAD_lock_free(async_mem_lock); |
| } |
| |
| static int allow_customize = 1; |
| static ASYNC_stack_alloc_fn stack_alloc_impl = async_stack_alloc; |
| static ASYNC_stack_free_fn stack_free_impl = async_stack_free; |
| |
| int ASYNC_is_capable(void) |
| { |
| ucontext_t ctx; |
| |
| /* |
| * Some platforms provide getcontext() but it does not work (notably |
| * MacOSX PPC64). Check for a working getcontext(); |
| */ |
| return getcontext(&ctx) == 0; |
| } |
| |
| int ASYNC_set_mem_functions(ASYNC_stack_alloc_fn alloc_fn, |
| ASYNC_stack_free_fn free_fn) |
| { |
| OPENSSL_init_crypto(OPENSSL_INIT_ASYNC, NULL); |
| |
| if (!CRYPTO_THREAD_write_lock(async_mem_lock)) |
| return 0; |
| if (!allow_customize) { |
| CRYPTO_THREAD_unlock(async_mem_lock); |
| return 0; |
| } |
| CRYPTO_THREAD_unlock(async_mem_lock); |
| |
| if (alloc_fn != NULL) |
| stack_alloc_impl = alloc_fn; |
| if (free_fn != NULL) |
| stack_free_impl = free_fn; |
| return 1; |
| } |
| |
| void ASYNC_get_mem_functions(ASYNC_stack_alloc_fn *alloc_fn, |
| ASYNC_stack_free_fn *free_fn) |
| { |
| if (alloc_fn != NULL) |
| *alloc_fn = stack_alloc_impl; |
| if (free_fn != NULL) |
| *free_fn = stack_free_impl; |
| } |
| |
| static void *async_stack_alloc(size_t *num) |
| { |
| return OPENSSL_malloc(*num); |
| } |
| |
| static void async_stack_free(void *addr) |
| { |
| OPENSSL_free(addr); |
| } |
| |
| void async_local_cleanup(void) |
| { |
| } |
| |
| int async_fibre_makecontext(async_fibre *fibre) |
| { |
| #ifndef USE_SWAPCONTEXT |
| fibre->env_init = 0; |
| #endif |
| if (getcontext(&fibre->fibre) == 0) { |
| size_t num = STACKSIZE; |
| |
| /* |
| * Disallow customisation after the first |
| * stack is allocated. |
| */ |
| if (allow_customize) { |
| if (!CRYPTO_THREAD_write_lock(async_mem_lock)) |
| return 0; |
| allow_customize = 0; |
| CRYPTO_THREAD_unlock(async_mem_lock); |
| } |
| |
| fibre->fibre.uc_stack.ss_sp = stack_alloc_impl(&num); |
| if (fibre->fibre.uc_stack.ss_sp != NULL) { |
| fibre->fibre.uc_stack.ss_size = num; |
| fibre->fibre.uc_link = NULL; |
| makecontext(&fibre->fibre, async_start_func, 0); |
| return 1; |
| } |
| ERR_raise(ERR_LIB_ASYNC, ERR_R_MALLOC_FAILURE); |
| } else { |
| fibre->fibre.uc_stack.ss_sp = NULL; |
| } |
| return 0; |
| } |
| |
| void async_fibre_free(async_fibre *fibre) |
| { |
| stack_free_impl(fibre->fibre.uc_stack.ss_sp); |
| fibre->fibre.uc_stack.ss_sp = NULL; |
| } |
| |
| #endif |