diff options
author | Alessandro Ghedini <alessandro@ghedini.me> | 2015-10-25 17:43:55 +0100 |
---|---|---|
committer | Matt Caswell <matt@openssl.org> | 2016-02-26 10:00:36 +0000 |
commit | 71a04cfca03bf6d5a93ad3ffd23e0fb9e0da2919 (patch) | |
tree | f0c49fffc439de585b85ad95f94ebfd50fafce90 | |
parent | bdcd83e1272c84f3de576f793ba03fdc2c21a557 (diff) |
Implement new multi-threading API
Reviewed-by: Rich Salz <rsalz@openssl.org>
Reviewed-by: Matt Caswell <matt@openssl.org>
-rw-r--r-- | crypto/Makefile.in | 2 | ||||
-rw-r--r-- | crypto/build.info | 1 | ||||
-rw-r--r-- | crypto/threads_none.c | 165 | ||||
-rw-r--r-- | crypto/threads_pthread.c | 167 | ||||
-rw-r--r-- | crypto/threads_win.c | 190 | ||||
-rw-r--r-- | doc/crypto/threads.pod | 187 | ||||
-rw-r--r-- | include/internal/threads.h | 92 | ||||
-rw-r--r-- | include/openssl/crypto.h | 10 | ||||
-rw-r--r-- | test/Makefile.in | 12 | ||||
-rw-r--r-- | test/build.info | 6 | ||||
-rwxr-xr-x | test/recipes/90-test_threads.t | 5 | ||||
-rw-r--r-- | test/threadstest.c | 283 | ||||
-rwxr-xr-x | util/libeay.num | 13 | ||||
-rwxr-xr-x | util/mkdef.pl | 1 |
14 files changed, 974 insertions, 160 deletions
diff --git a/crypto/Makefile.in b/crypto/Makefile.in index c8184e5a5c..c29d44c7d3 100644 --- a/crypto/Makefile.in +++ b/crypto/Makefile.in @@ -34,9 +34,11 @@ LIB= $(TOP)/libcrypto.a SHARED_LIB= libcrypto$(SHLIB_EXT) LIBSRC= cryptlib.c mem.c mem_clr.c mem_dbg.c cversion.c ex_data.c cpt_err.c \ ebcdic.c uid.c o_time.c o_str.c o_dir.c thr_id.c lock.c \ + threads_pthread.c threads_win.c threads_none.c \ o_init.c o_fips.c mem_sec.c init.c LIBOBJ= cryptlib.o mem.o mem_dbg.o cversion.o ex_data.o cpt_err.o \ ebcdic.o uid.o o_time.o o_str.o o_dir.o thr_id.o lock.o \ + threads_pthread.o threads_win.o threads_none.o \ o_init.o o_fips.o mem_sec.o init.o $(CPUID_OBJ) SRC= $(LIBSRC) diff --git a/crypto/build.info b/crypto/build.info index a3ea7f0e0d..24a009a475 100644 --- a/crypto/build.info +++ b/crypto/build.info @@ -3,6 +3,7 @@ LIBS=../libcrypto SOURCE[../libcrypto]=\ cryptlib.c mem.c mem_dbg.c cversion.c ex_data.c cpt_err.c \ ebcdic.c uid.c o_time.c o_str.c o_dir.c thr_id.c lock.c \ + threads_pthread.c threads_win.c threads_none.c \ o_init.c o_fips.c mem_sec.c init.c {- $target{cpuid_asm_src} -} EXTRA= ../ms/uplink-x86.pl ../ms/uplink.c ../ms/applink.c \ x86cpuid.pl x86_64cpuid.pl ia64cpuid.S \ diff --git a/crypto/threads_none.c b/crypto/threads_none.c new file mode 100644 index 0000000000..4e3b7a52e8 --- /dev/null +++ b/crypto/threads_none.c @@ -0,0 +1,165 @@ +/* ==================================================================== + * Copyright (c) 2016 The OpenSSL Project. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * 3. All advertising materials mentioning features or use of this + * software must display the following acknowledgment: + * "This product includes software developed by the OpenSSL Project + * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" + * + * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to + * endorse or promote products derived from this software without + * prior written permission. For written permission, please contact + * openssl-core@openssl.org. + * + * 5. Products derived from this software may not be called "OpenSSL" + * nor may "OpenSSL" appear in their names without prior written + * permission of the OpenSSL Project. + * + * 6. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by the OpenSSL Project + * for use in the OpenSSL Toolkit (http://www.openssl.org/)" + * + * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY + * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR + * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED + * OF THE POSSIBILITY OF SUCH DAMAGE. + * ==================================================================== + */ + +#include <openssl/crypto.h> +#include "internal/threads.h" + +#if !defined(OPENSSL_THREADS) || defined(CRYPTO_TDEBUG) + +CRYPTO_RWLOCK *CRYPTO_THREAD_lock_new(void) +{ + CRYPTO_RWLOCK *lock = OPENSSL_zalloc(sizeof(unsigned int)); + if (lock == NULL) + return NULL; + + *(unsigned int *)lock = 1; + + return lock; +} + +int CRYPTO_THREAD_read_lock(CRYPTO_RWLOCK *lock) +{ + OPENSSL_assert(*(unsigned int *)lock == 1); + return 1; +} + +int CRYPTO_THREAD_write_lock(CRYPTO_RWLOCK *lock) +{ + OPENSSL_assert(*(unsigned int *)lock == 1); + return 1; +} + +int CRYPTO_THREAD_unlock(CRYPTO_RWLOCK *lock) +{ + OPENSSL_assert(*(unsigned int *)lock == 1); + return 1; +} + +void CRYPTO_THREAD_lock_free(CRYPTO_RWLOCK *lock) { + if (lock == NULL) + return; + + *(unsigned int *)lock = 0; + OPENSSL_free(lock); + + return; +} + +int CRYPTO_THREAD_run_once(CRYPTO_ONCE *once, void (*init)(void)) +{ + if (*once != 0) + return 1; + + init(); + *once = 1; + + return 1; +} + +#define OPENSSL_CRYPTO_THREAD_LOCAL_KEY_MAX 256 + +static void *thread_local_storage[OPENSSL_CRYPTO_THREAD_LOCAL_KEY_MAX]; + +int CRYPTO_THREAD_init_local(CRYPTO_THREAD_LOCAL *key, void (*cleanup)(void *)) +{ + static unsigned int thread_local_key = 0; + + if (thread_local_key >= OPENSSL_CRYPTO_THREAD_LOCAL_KEY_MAX) + return 0; + + *key = thread_local_key++; + + thread_local_storage[*key] = NULL; + + return 1; +} + +void *CRYPTO_THREAD_get_local(CRYPTO_THREAD_LOCAL *key) +{ + if (*key >= OPENSSL_CRYPTO_THREAD_LOCAL_KEY_MAX) + return NULL; + + return thread_local_storage[*key]; +} + +int CRYPTO_THREAD_set_local(CRYPTO_THREAD_LOCAL *key, void *val) +{ + if (*key >= OPENSSL_CRYPTO_THREAD_LOCAL_KEY_MAX) + return 0; + + thread_local_storage[*key] = val; + + return 1; +} + +int CRYPTO_THREAD_cleanup_local(CRYPTO_THREAD_LOCAL *key) +{ + *key = OPENSSL_CRYPTO_THREAD_LOCAL_KEY_MAX + 1; + return 1; +} + +CRYPTO_THREAD_ID CRYPTO_THREAD_get_current_id(void) +{ + return 0; +} + +int CRYPTO_THREAD_compare_id(CRYPTO_THREAD_ID a, CRYPTO_THREAD_ID b) +{ + return (a == b); +} + +int CRYPTO_atomic_add(int *val, int amount, int *ret, CRYPTO_RWLOCK *lock) +{ + *val += amount; + *ret = *val; + + return 1; +} + +#endif diff --git a/crypto/threads_pthread.c b/crypto/threads_pthread.c new file mode 100644 index 0000000000..2b32e142ae --- /dev/null +++ b/crypto/threads_pthread.c @@ -0,0 +1,167 @@ +/* ==================================================================== + * Copyright (c) 2016 The OpenSSL Project. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * 3. All advertising materials mentioning features or use of this + * software must display the following acknowledgment: + * "This product includes software developed by the OpenSSL Project + * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" + * + * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to + * endorse or promote products derived from this software without + * prior written permission. For written permission, please contact + * openssl-core@openssl.org. + * + * 5. Products derived from this software may not be called "OpenSSL" + * nor may "OpenSSL" appear in their names without prior written + * permission of the OpenSSL Project. + * + * 6. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by the OpenSSL Project + * for use in the OpenSSL Toolkit (http://www.openssl.org/)" + * + * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY + * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR + * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED + * OF THE POSSIBILITY OF SUCH DAMAGE. + * ==================================================================== + */ + +#include <openssl/crypto.h> +#include "internal/threads.h" + +#if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG) && !defined(OPENSSL_SYS_WINDOWS) + +CRYPTO_RWLOCK *CRYPTO_THREAD_lock_new(void) +{ + CRYPTO_RWLOCK *lock = OPENSSL_zalloc(sizeof(pthread_rwlock_t)); + if (lock == NULL) + return NULL; + + if (pthread_rwlock_init(lock, NULL) != 0) + return NULL; + + return lock; +} + +int CRYPTO_THREAD_read_lock(CRYPTO_RWLOCK *lock) +{ + if (pthread_rwlock_rdlock(lock) != 0) + return 0; + + return 1; +} + +int CRYPTO_THREAD_write_lock(CRYPTO_RWLOCK *lock) +{ + if (pthread_rwlock_wrlock(lock) != 0) + return 0; + + return 1; +} + +int CRYPTO_THREAD_unlock(CRYPTO_RWLOCK *lock) +{ + if (pthread_rwlock_unlock(lock) != 0) + return 0; + + return 1; +} + +void CRYPTO_THREAD_lock_free(CRYPTO_RWLOCK *lock) +{ + if (lock == NULL) + return; + + pthread_rwlock_destroy(lock); + OPENSSL_free(lock); + + return; +} + +int CRYPTO_THREAD_run_once(CRYPTO_ONCE *once, void (*init)(void)) +{ + if (pthread_once(once, init) != 0) + return 0; + + return 1; +} + +int CRYPTO_THREAD_init_local(CRYPTO_THREAD_LOCAL *key, void (*cleanup)(void *)) +{ + if (pthread_key_create(key, cleanup) != 0) + return 0; + + return 1; +} + +void *CRYPTO_THREAD_get_local(CRYPTO_THREAD_LOCAL *key) +{ + return pthread_getspecific(*key); +} + +int CRYPTO_THREAD_set_local(CRYPTO_THREAD_LOCAL *key, void *val) +{ + if (pthread_setspecific(*key, val) != 0) + return 0; + + return 1; +} + +int CRYPTO_THREAD_cleanup_local(CRYPTO_THREAD_LOCAL *key) +{ + if (pthread_key_delete(*key) != 0) + return 0; + + return 1; +} + +CRYPTO_THREAD_ID CRYPTO_THREAD_get_current_id(void) +{ + return pthread_self(); +} + +int CRYPTO_THREAD_compare_id(CRYPTO_THREAD_ID a, CRYPTO_THREAD_ID b) +{ + return pthread_equal(a, b); +} + +int CRYPTO_atomic_add(int *val, int amount, int *ret, CRYPTO_RWLOCK *lock) +{ +#ifdef __ATOMIC_RELAXED + *ret = __atomic_add_fetch(val, amount, __ATOMIC_RELAXED); +#else + if (!CRYPTO_THREAD_write_lock(lock)) + return 0; + + *val += amount; + *ret = *val; + + if (!CRYPTO_THREAD_unlock(lock)) + return 0; +#endif + + return 1; +} + +#endif diff --git a/crypto/threads_win.c b/crypto/threads_win.c new file mode 100644 index 0000000000..bee628ff81 --- /dev/null +++ b/crypto/threads_win.c @@ -0,0 +1,190 @@ +/* ==================================================================== + * Copyright (c) 2016 The OpenSSL Project. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * 3. All advertising materials mentioning features or use of this + * software must display the following acknowledgment: + * "This product includes software developed by the OpenSSL Project + * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" + * + * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to + * endorse or promote products derived from this software without + * prior written permission. For written permission, please contact + * openssl-core@openssl.org. + * + * 5. Products derived from this software may not be called "OpenSSL" + * nor may "OpenSSL" appear in their names without prior written + * permission of the OpenSSL Project. + * + * 6. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by the OpenSSL Project + * for use in the OpenSSL Toolkit (http://www.openssl.org/)" + * + * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY + * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR + * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED + * OF THE POSSIBILITY OF SUCH DAMAGE. + * ==================================================================== + */ + +#include <openssl/crypto.h> +#include "internal/threads.h" + +#if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG) && defined(OPENSSL_SYS_WINDOWS) + +CRYPTO_RWLOCK *CRYPTO_THREAD_lock_new(void) +{ + CRYPTO_RWLOCK *lock = OPENSSL_zalloc(sizeof(CRITICAL_SECTION)); + if (lock == NULL) + return NULL; + + /* 0x400 is the spin count value suggested in the documentation */ + if (!InitializeCriticalSectionAndSpinCount(lock, 0x400)) + return NULL; + + return lock; +} + +int CRYPTO_THREAD_read_lock(CRYPTO_RWLOCK *lock) +{ + EnterCriticalSection(lock); + return 1; +} + +int CRYPTO_THREAD_write_lock(CRYPTO_RWLOCK *lock) +{ + EnterCriticalSection(lock); + return 1; +} + +int CRYPTO_THREAD_unlock(CRYPTO_RWLOCK *lock) +{ + LeaveCriticalSection(lock); + return 1; +} + +void CRYPTO_THREAD_lock_free(CRYPTO_RWLOCK *lock) +{ + if (lock == NULL) + return; + + DeleteCriticalSection(lock); + OPENSSL_free(lock); + + return; +} + +# if _WIN32_WINNT < 0x0600 + +# define ONCE_UNINITED 0 +# define ONCE_ININIT 1 +# define ONCE_DONE 2 + +int CRYPTO_THREAD_run_once(CRYPTO_ONCE *once, void (*init)(void)) +{ + LONG volatile *lock = (LONG *)once; + LONG result; + + if (*lock == ONCE_DONE) + return 1; + + do { + result = InterlockedCompareExchange(lock, ONCE_ININIT, ONCE_UNINITED); + if (result == ONCE_UNINITED) { + init(); + *lock = ONCE_DONE; + return 1; + } + } while (result == ONCE_ININIT); + + return (*lock == ONCE_DONE); +} + +# else + +BOOL CALLBACK once_cb(PINIT_ONCE once, PVOID p, PVOID *pp) +{ + void (*init)(void) = p; + + init(); + + return TRUE; +} + +void CRYPTO_THREAD_run_once(CRYPTO_ONCE *once, void (*init)(void)) +{ + if (InitOnceExecuteOnce(once, once_cb, init, NULL)) + return 0; + + return 1; +} + +# endif + +int CRYPTO_THREAD_init_local(CRYPTO_THREAD_LOCAL *key, void (*cleanup)(void *)) +{ + *key = TlsAlloc(); + if (*key == TLS_OUT_OF_INDEXES) + return 0; + + return 1; +} + +void *CRYPTO_THREAD_get_local(CRYPTO_THREAD_LOCAL *key) +{ + return TlsGetValue(*key); +} + +int CRYPTO_THREAD_set_local(CRYPTO_THREAD_LOCAL *key, void *val) +{ + if (TlsSetValue(*key, val) == 0) + return 0; + + return 1; +} + +int CRYPTO_THREAD_cleanup_local(CRYPTO_THREAD_LOCAL *key) +{ + if (TlsFree(*key) == 0) + return 0; + + return 1; +} + +CRYPTO_THREAD_ID CRYPTO_THREAD_get_current_id(void) +{ + return GetCurrentThreadId(); +} + +int CRYPTO_THREAD_compare_id(CRYPTO_THREAD_ID a, CRYPTO_THREAD_ID b) +{ + return (a == b); +} + +int CRYPTO_atomic_add(int *val, int amount, int *ret, CRYPTO_RWLOCK *lock) +{ + *ret = InterlockedExchangeAdd(val, amount) + amount; + return 1; +} + +#endif diff --git a/doc/crypto/threads.pod b/doc/crypto/threads.pod index 9ee75b3843..90c57098a4 100644 --- a/doc/crypto/threads.pod +++ b/doc/crypto/threads.pod @@ -2,176 +2,66 @@ =head1 NAME -CRYPTO_THREADID_set_callback, CRYPTO_THREADID_get_callback, -CRYPTO_THREADID_current, CRYPTO_THREADID_cmp, CRYPTO_THREADID_cpy, -CRYPTO_THREADID_hash, CRYPTO_set_locking_callback, CRYPTO_num_locks, -CRYPTO_set_dynlock_create_callback, CRYPTO_set_dynlock_lock_callback, -CRYPTO_set_dynlock_destroy_callback, CRYPTO_get_new_dynlockid, -CRYPTO_destroy_dynlockid, CRYPTO_lock - OpenSSL thread support +CRYPTO_THREAD_lock_new, CRYPTO_THREAD_read_lock, CRYPTO_THREAD_write_lock, +CRYPTO_THREAD_unlock, CRYPTO_THREAD_lock_free, CRYPTO_atomic_add - OpenSSL thread support =head1 SYNOPSIS #include <openssl/crypto.h> - /* Don't use this structure directly. */ - typedef struct crypto_threadid_st - { - void *ptr; - unsigned long val; - } CRYPTO_THREADID; - /* Only use CRYPTO_THREADID_set_[numeric|pointer]() within callbacks */ - void CRYPTO_THREADID_set_numeric(CRYPTO_THREADID *id, unsigned long val); - void CRYPTO_THREADID_set_pointer(CRYPTO_THREADID *id, void *ptr); - int CRYPTO_THREADID_set_callback(void (*threadid_func)(CRYPTO_THREADID *)); - void (*CRYPTO_THREADID_get_callback(void))(CRYPTO_THREADID *); - void CRYPTO_THREADID_current(CRYPTO_THREADID *id); - int CRYPTO_THREADID_cmp(const CRYPTO_THREADID *a, - const CRYPTO_THREADID *b); - void CRYPTO_THREADID_cpy(CRYPTO_THREADID *dest, - const CRYPTO_THREADID *src); - unsigned long CRYPTO_THREADID_hash(const CRYPTO_THREADID *id); - - int CRYPTO_num_locks(void); - - /* struct CRYPTO_dynlock_value needs to be defined by the user */ - struct CRYPTO_dynlock_value; - - void CRYPTO_set_dynlock_create_callback(struct CRYPTO_dynlock_value * - (*dyn_create_function)(const char *file, int line)); - void CRYPTO_set_dynlock_lock_callback(void (*dyn_lock_function) - (int mode, struct CRYPTO_dynlock_value *l, - const char *file, int line)); - void CRYPTO_set_dynlock_destroy_callback(void (*dyn_destroy_function) - (struct CRYPTO_dynlock_value *l, const char *file, int line)); - - int CRYPTO_get_new_dynlockid(void); - - void CRYPTO_destroy_dynlockid(int i); - - void CRYPTO_lock(int mode, int n, const char *file, int line); - - #define CRYPTO_w_lock(type) \ - CRYPTO_lock(CRYPTO_LOCK|CRYPTO_WRITE,type,OPENSSL_FILE,OPENSSL_LINE) - #define CRYPTO_w_unlock(type) \ - CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_WRITE,type,OPENSSL_FILE,OPENSSL_LINE) - #define CRYPTO_r_lock(type) \ - CRYPTO_lock(CRYPTO_LOCK|CRYPTO_READ,type,OPENSSL_FILE,OPENSSL_LINE) - #define CRYPTO_r_unlock(type) \ - CRYPTO_lock(CRYPTO_UNLOCK|CRYPTO_READ,type,OPENSSL_FILE,OPENSSL_LINE) - #define CRYPTO_add(addr,amount,type) \ - CRYPTO_add_lock(addr,amount,type,OPENSSL_FILE,OPENSSL_LINE) + CRYPTO_RWLOCK *CRYPTO_THREAD_lock_new(void); + int CRYPTO_THREAD_read_lock(CRYPTO_RWLOCK *lock); + int CRYPTO_THREAD_write_lock(CRYPTO_RWLOCK *lock); + int CRYPTO_THREAD_unlock(CRYPTO_RWLOCK *lock); + void CRYPTO_THREAD_lock_free(CRYPTO_RWLOCK *lock); + + int CRYPTO_atomic_add(int *val, int amount, int *ret, CRYPTO_RWLOCK *lock); =head1 DESCRIPTION -OpenSSL can safely be used in multi-threaded applications provided -that at least two callback functions are set, locking_function and -threadid_func. - -locking_function(int mode, int n, const char *file, int line) is -needed to perform locking on shared data structures. -(Note that OpenSSL uses a number of global data structures that -will be implicitly shared whenever multiple threads use OpenSSL.) -Multi-threaded applications will crash at random if it is not set. - -locking_function() must be able to handle up to CRYPTO_num_locks() -different mutex locks. It sets the B<n>-th lock if B<mode> & -B<CRYPTO_LOCK>, and releases it otherwise. - -B<file> and B<line> are the file number of the function setting the -lock. They can be useful for debugging. - -threadid_func(CRYPTO_THREADID *id) is needed to record the currently-executing -thread's identifier into B<id>. The implementation of this callback should not -fill in B<id> directly, but should use CRYPTO_THREADID_set_numeric() if thread -IDs are numeric, or CRYPTO_THREADID_set_pointer() if they are pointer-based. -The B<id> must be unique for the duration of the execution of the program. -If the application does not register such a callback using -CRYPTO_THREADID_set_callback(), then a default implementation is used - on -Windows this uses the system's default thread identifying APIs, and on -all other platforms it uses the address of B<errno>. The latter is satisfactory -for thread-safety if and only if the platform has a thread-local error number -facility. - -Once threadid_func() is registered, or if the built-in default implementation is -to be used; +OpenSSL can be safely used in multi-threaded applications provided that +support for the underlying OS threading API is built-in. Currently, OpenSSL +supports the pthread and Windows APIs. OpenSSL can also be built without +any multi-threading support, for example on platforms that don't provide +any threading support or that provide a threading API that is not yet +supported by OpenSSL. + +The following multi-threading function are provided: =over 4 =item * -CRYPTO_THREADID_current() records the currently-executing thread ID into the -given B<id> object. +CRYPTO_THREAD_lock_new() allocates, initializes and returns a new read/write +lock. =item * -CRYPTO_THREADID_cmp() compares two thread IDs (returning zero for equality, ie. -the same semantics as memcmp()). +CRYPTO_THREAD_read_lock() locks the provided B<lock> for reading. =item * -CRYPTO_THREADID_cpy() duplicates a thread ID value, +CRYPTO_THREAD_write_lock() locks the provided B<lock> for writing. =item * -CRYPTO_THREADID_hash() returns a numeric value usable as a hash-table key. This -is usually the exact numeric or pointer-based thread ID used internally, however -this also handles the unusual case where pointers are larger than 'long' -variables and the platform's thread IDs are pointer-based - in this case, mixing -is done to attempt to produce a unique numeric value even though it is not as -wide as the platform's true thread IDs. - -=back - -Additionally, OpenSSL supports dynamic locks, and sometimes, some parts -of OpenSSL need it for better performance. To enable this, the following -is required: - -=over 4 +CRYPTO_THREAD_unlock() unlocks the previously locked B<lock>. =item * -Three additional callback function, dyn_create_function, dyn_lock_function -and dyn_destroy_function. +CRYPTO_THREAD_lock_frees() frees the provided B<lock>. =item * -A structure defined with the data that each lock needs to handle. +CRYPTO_atomic_add() atomically adds B<amount> to B<val> and returns the +result of the operation in B<ret>. B<lock> will be locked, unless atomic +operations are supported on the specific platform. Because of this, if a +variable is modified by CRYPTO_atomic_add() then CRYPTO_atomic_add() must +be the only way that the variable is modified. =back -struct CRYPTO_dynlock_value has to be defined to contain whatever structure -is needed to handle locks. - -dyn_create_function(const char *file, int line) is needed to create a -lock. Multi-threaded applications might crash at random if it is not set. - -dyn_lock_function(int mode, CRYPTO_dynlock *l, const char *file, int line) -is needed to perform locking off dynamic lock numbered n. Multi-threaded -applications might crash at random if it is not set. - -dyn_destroy_function(CRYPTO_dynlock *l, const char *file, int line) is -needed to destroy the lock l. Multi-threaded applications might crash at -random if it is not set. - -CRYPTO_get_new_dynlockid() is used to create locks. It will call -dyn_create_function for the actual creation. - -CRYPTO_destroy_dynlockid() is used to destroy locks. It will call -dyn_destroy_function for the actual destruction. - -CRYPTO_lock() is used to lock and unlock the locks. mode is a bitfield -describing what should be done with the lock. n is the number of the -lock as returned from CRYPTO_get_new_dynlockid(). mode can be combined -from the following values. These values are pairwise exclusive, with -undefined behaviour if misused (for example, CRYPTO_READ and CRYPTO_WRITE -should not be used together): - - CRYPTO_LOCK 0x01 - CRYPTO_UNLOCK 0x02 - CRYPTO_READ 0x04 - CRYPTO_WRITE 0x08 - =head1 RETURN VALUES -CRYPTO_num_locks() returns the required number of locks. +CRYPTO_THREAD_lock_new() returns the allocated lock, or NULL on error. -CRYPTO_get_new_dynlockid() returns the index to the newly created lock. +CRYPTO_THREAD_lock_frees() returns no value. -The other functions return no values. +The other functions return 1 on success or 0 on error. =head1 NOTES @@ -185,21 +75,6 @@ You can find out if OpenSSL was configured with thread support: // no thread support #endif -Also, dynamic locks are currently not used internally by OpenSSL, but -may do so in the future. - -=head1 EXAMPLES - -B<crypto/threads/mttest.c> shows examples of the callback functions on -Solaris, Irix and Win32. - -=head1 HISTORY - -B<CRYPTO_THREADID> and associated functions were introduced in OpenSSL 1.0.0 -to replace (actually, deprecate) the previous CRYPTO_set_id_callback(), -CRYPTO_get_id_callback(), and CRYPTO_thread_id() functions which assumed -thread IDs to always be represented by 'unsigned long'. - =head1 SEE ALSO L<crypto(3)> diff --git a/include/internal/threads.h b/include/internal/threads.h new file mode 100644 index 0000000000..78977281d7 --- /dev/null +++ b/include/internal/threads.h @@ -0,0 +1,92 @@ +/* ==================================================================== + * Copyright (c) 2016 The OpenSSL Project. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * 3. All advertising materials mentioning features or use of this + * software must display the following acknowledgment: + * "This product includes software developed by the OpenSSL Project + * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" + * + * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to + * endorse or promote products derived from this software without + * prior written permission. For written permission, please contact + * licensing@OpenSSL.org. + * + * 5. Products derived from this software may not be called "OpenSSL" + * nor may "OpenSSL" appear in their names without prior written + * permission of the OpenSSL Project. + * + * 6. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by the OpenSSL Project + * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" + * + * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY + * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR + * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED + * OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef HEADER_INTERNAL_THREADS_H +# define HEADER_INTERNAL_THREADS_H + +#include "e_os.h" + +# if !defined(OPENSSL_THREADS) || defined(CRYPTO_TDEBUG) +typedef unsigned int CRYPTO_ONCE; +typedef unsigned int CRYPTO_THREAD_LOCAL; +typedef unsigned int CRYPTO_THREAD_ID; + +# define CRYPTO_ONCE_STATIC_INIT 0 +# elif defined(OPENSSL_SYS_WINDOWS) +# include <windows.h> +typedef DWORD CRYPTO_THREAD_LOCAL; +typedef DWORD CRYPTO_THREAD_ID; + +# if _WIN32_WINNT < 0x0600 +typedef LONG CRYPTO_ONCE; +# define CRYPTO_ONCE_STATIC_INIT 0 +# else +typedef INIT_ONCE CRYPTO_ONCE; +# define CRYPTO_ONCE_STATIC_INIT INIT_ONCE_STATIC_INIT +# endif + +# else +# include <pthread.h> +typedef pthread_once_t CRYPTO_ONCE; +typedef pthread_key_t CRYPTO_THREAD_LOCAL; +typedef pthread_t CRYPTO_THREAD_ID; + +# define CRYPTO_ONCE_STATIC_INIT PTHREAD_ONCE_INIT +# endif + +int CRYPTO_THREAD_run_once(CRYPTO_ONCE *once, void (*init)(void)); + +int CRYPTO_THREAD_init_local(CRYPTO_THREAD_LOCAL *key, void (*cleanup)(void *)); +void *CRYPTO_THREAD_get_local(CRYPTO_THREAD_LOCAL *key); +int CRYPTO_THREAD_set_local(CRYPTO_THREAD_LOCAL *key, void *val); +int CRYPTO_THREAD_cleanup_local(CRYPTO_THREAD_LOCAL *key); + +CRYPTO_THREAD_ID CRYPTO_THREAD_get_current_id(void); +int CRYPTO_THREAD_compare_id(CRYPTO_THREAD_ID a, CRYPTO_THREAD_ID b); + +#endif diff --git a/include/openssl/crypto.h b/include/openssl/crypto.h index 2cabcc8856..fb6a2b9ec4 100644 --- a/include/openssl/crypto.h +++ b/include/openssl/crypto.h @@ -245,6 +245,16 @@ typedef struct { struct CRYPTO_dynlock_value *data; } CRYPTO_dynlock; +typedef void CRYPTO_RWLOCK; + +CRYPTO_RWLOCK *CRYPTO_THREAD_lock_new(void); +int CRYPTO_THREAD_read_lock(CRYPTO_RWLOCK *lock); +int CRYPTO_THREAD_write_lock(CRYPTO_RWLOCK *lock); +int CRYPTO_THREAD_unlock(CRYPTO_RWLOCK *lock); +void CRYPTO_THREAD_lock_free(CRYPTO_RWLOCK *lock); + +int CRYPTO_atomic_add(int *val, int amount, int *ret, CRYPTO_RWLOCK *lock); |