d7c5dfb233
Historically, OpenSSL has used callbacks for anything thread related, but we don't actually have that many threading libraries to worry about: just pthreads and Windows (I hope). That suggests that it's quite reasonable to handle threading ourselves, and eliminate the need for users to remember to install the thread callbacks. The first user of this would be ERR, which currently simulates thread-local storage using a lock around a hash table keyed by the TID. (Although I suspect that change will need some CMake work in order that libpthread is automatically included with libcrypto when linking tests etc, but not on Windows and without lots of ifs.) Change-Id: I4dd088e3794506747f875c1f3e92b9bc6700fad2 Reviewed-on: https://boringssl-review.googlesource.com/4010 Reviewed-by: Adam Langley <agl@google.com>
112 lines
3.2 KiB
C
112 lines
3.2 KiB
C
/* Copyright (c) 2015, Google Inc.
|
|
*
|
|
* Permission to use, copy, modify, and/or distribute this software for any
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
* copyright notice and this permission notice appear in all copies.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
|
|
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
|
|
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
|
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
|
|
|
|
#include "internal.h"
|
|
|
|
#if !defined(OPENSSL_WINDOWS)
|
|
|
|
#include <pthread.h>
|
|
#include <string.h>
|
|
|
|
#include <openssl/mem.h>
|
|
|
|
|
|
void CRYPTO_once(CRYPTO_once_t *once, void (*init)(void)) {
|
|
pthread_once(once, init);
|
|
}
|
|
|
|
static pthread_mutex_t g_destructors_lock = PTHREAD_MUTEX_INITIALIZER;
|
|
static thread_local_destructor_t g_destructors[NUM_OPENSSL_THREAD_LOCALS];
|
|
|
|
static void thread_local_destructor(void *arg) {
|
|
if (arg == NULL) {
|
|
return;
|
|
}
|
|
|
|
thread_local_destructor_t destructors[NUM_OPENSSL_THREAD_LOCALS];
|
|
if (pthread_mutex_lock(&g_destructors_lock) != 0) {
|
|
return;
|
|
}
|
|
memcpy(destructors, g_destructors, sizeof(destructors));
|
|
pthread_mutex_unlock(&g_destructors_lock);
|
|
|
|
unsigned i;
|
|
void **pointers = arg;
|
|
for (i = 0; i < NUM_OPENSSL_THREAD_LOCALS; i++) {
|
|
if (destructors[i] != NULL) {
|
|
destructors[i](pointers[i]);
|
|
}
|
|
}
|
|
|
|
OPENSSL_free(pointers);
|
|
}
|
|
|
|
static pthread_once_t g_thread_local_init_once = PTHREAD_ONCE_INIT;
|
|
static pthread_key_t g_thread_local_key;
|
|
static int g_thread_local_failed = 0;
|
|
|
|
static void thread_local_init(void) {
|
|
g_thread_local_failed =
|
|
pthread_key_create(&g_thread_local_key, thread_local_destructor) != 0;
|
|
}
|
|
|
|
void *CRYPTO_get_thread_local(thread_local_data_t index) {
|
|
CRYPTO_once(&g_thread_local_init_once, thread_local_init);
|
|
if (g_thread_local_failed) {
|
|
return NULL;
|
|
}
|
|
|
|
void **pointers = pthread_getspecific(g_thread_local_key);
|
|
if (pointers == NULL) {
|
|
return NULL;
|
|
}
|
|
return pointers[index];
|
|
}
|
|
|
|
int CRYPTO_set_thread_local(thread_local_data_t index, void *value,
|
|
thread_local_destructor_t destructor) {
|
|
CRYPTO_once(&g_thread_local_init_once, thread_local_init);
|
|
if (g_thread_local_failed) {
|
|
destructor(value);
|
|
return 0;
|
|
}
|
|
|
|
void **pointers = pthread_getspecific(g_thread_local_key);
|
|
if (pointers == NULL) {
|
|
pointers = OPENSSL_malloc(sizeof(void *) * NUM_OPENSSL_THREAD_LOCALS);
|
|
if (pointers == NULL) {
|
|
destructor(value);
|
|
return 0;
|
|
}
|
|
memset(pointers, 0, sizeof(void *) * NUM_OPENSSL_THREAD_LOCALS);
|
|
if (pthread_setspecific(g_thread_local_key, pointers) != 0) {
|
|
OPENSSL_free(pointers);
|
|
destructor(value);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if (pthread_mutex_lock(&g_destructors_lock) != 0) {
|
|
destructor(value);
|
|
return 0;
|
|
}
|
|
g_destructors[index] = destructor;
|
|
pthread_mutex_unlock(&g_destructors_lock);
|
|
|
|
pointers[index] = value;
|
|
return 1;
|
|
}
|
|
|
|
#endif /* !OPENSSL_WINDOWS */
|