[openssl-commits] [openssl] master update

Matt Caswell matt at openssl.org
Mon Mar 7 17:19:14 UTC 2016


The branch master has been updated
       via  c292b105b1d0a627091480d3e4f6122b22a46385 (commit)
       via  a072ed0c882caa5c0b1742262ef7f4aa1e0e04a5 (commit)
       via  b1f1e7aebad6ece6d878ca7e823b4ad92e2415f3 (commit)
      from  48fe8ab02e7080a5557e287a5190cbbd40021a98 (commit)


- Log -----------------------------------------------------------------
commit c292b105b1d0a627091480d3e4f6122b22a46385
Author: Matt Caswell <matt at openssl.org>
Date:   Mon Mar 7 14:39:22 2016 +0000

    Remove use of CRYPTO_LOCK_INIT in init code
    
    Swap the use of CRYPTO_LOCK_INIT in the init code to use the new threading
    API mechanism for locking.
    
    Reviewed-by: Richard Levitte <levitte at openssl.org>

commit a072ed0c882caa5c0b1742262ef7f4aa1e0e04a5
Author: Matt Caswell <matt at openssl.org>
Date:   Wed Mar 2 15:23:57 2016 +0000

    Swap the init code to use the new Thread API thread locals
    
    The init code was using its own thread local code. Now we have a central
    API for it we should use that instead.
    
    Reviewed-by: Richard Levitte <levitte at openssl.org>

commit b1f1e7aebad6ece6d878ca7e823b4ad92e2415f3
Author: Matt Caswell <matt at openssl.org>
Date:   Wed Mar 2 14:51:00 2016 +0000

    Swap the init code to use CRYPTO_ONCE
    
    The init code was using its own "once" implementation. Now that we have
    the new thread API we should use that instead.
    
    Reviewed-by: Richard Levitte <levitte at openssl.org>

-----------------------------------------------------------------------

Summary of changes:
 crypto/init.c            | 328 ++++++++++++++---------------------------------
 crypto/lock.c            |   3 +-
 include/openssl/crypto.h |   3 +-
 ssl/ssl_init.c           |  97 ++------------
 4 files changed, 113 insertions(+), 318 deletions(-)

diff --git a/crypto/init.c b/crypto/init.c
index 2c0bde6..44acd4f 100644
--- a/crypto/init.c
+++ b/crypto/init.c
@@ -55,6 +55,7 @@
  *
  */
 
+#include <internal/threads.h>
 #include <internal/cryptlib_int.h>
 #include <openssl/err.h>
 #include <openssl/rand.h>
@@ -74,188 +75,29 @@ static int stopped = 0;
 
 static void ossl_init_thread_stop(struct thread_local_inits_st *locals);
 
-/* Implement "once" functionality */
-#if !defined(OPENSSL_THREADS)
-typedef int OPENSSL_INIT_ONCE;
-# define OPENSSL_INIT_ONCE_STATIC_INIT          0
-
-static void ossl_init_once_run(OPENSSL_INIT_ONCE *once, void (*init)(void))
-{
-    if (*once == OPENSSL_INIT_ONCE_STATIC_INIT) {
-        *once = 1;
-        init();
-    }
-}
-
-static int ossl_init_setup_thread_stop(void)
-{
-    /*
-     * There are no threads to stop. Do nothing.
-     */
-    return 1;
-}
-
-static void ossl_init_thread_stop_cleanup(void)
-{
-}
-
-static struct thread_local_inits_st *local = NULL;
-static struct thread_local_inits_st *ossl_init_get_thread_local(int alloc)
-{
-    struct thread_local_inits_st *tmp;
-
-    tmp = local;
-
-    if (local == NULL && alloc)
-        tmp = local = OPENSSL_zalloc(sizeof(*local));
-
-    if (!alloc)
-        local = NULL;
-
-    return tmp;
-}
-
-#elif defined(OPENSSL_SYS_WINDOWS)
-
-# include <windows.h>
-
-# if _WIN32_WINNT < 0x0600
-
-/*
- * Versions before 0x0600 (Windows Vista, Windows Server 2008 or later) do not
- * have InitOnceExecuteOnce, so we fall back to using a spinlock instead.
- */
-typedef LONG OPENSSL_INIT_ONCE;
-#  define OPENSSL_INIT_ONCE_STATIC_INIT          0
-
-#  define ONCE_UNINITED     0
-#  define ONCE_ININIT       1
-#  define ONCE_DONE         2
-
-static void ossl_init_once_run(OPENSSL_INIT_ONCE *once, void (*init)(void))
-{
-    LONG volatile *lock = (LONG *)once;
-    LONG result;
-
-    if (*lock == ONCE_DONE)
-        return;
-
-    do {
-        result = InterlockedCompareExchange(lock, ONCE_ININIT, ONCE_UNINITED);
-        if (result == ONCE_UNINITED) {
-            init();
-            *lock = ONCE_DONE;
-            return;
-        }
-    } while (result == ONCE_ININIT);
-}
-
-# else
-
-typedef INIT_ONCE OPENSSL_INIT_ONCE;
-#  define OPENSSL_INIT_ONCE_STATIC_INIT          INIT_ONCE_STATIC_INIT
-
-static BOOL CALLBACK once_cb(PINIT_ONCE once, PVOID initfp, PVOID *unused)
-{
-    void (*init)(void) = initfp;
-
-    init();
-
-    return TRUE;
-}
-
-static void ossl_init_once_run(OPENSSL_INIT_ONCE *once, void (*init)(void))
-{
-    InitOnceExecuteOnce((INIT_ONCE *)once, once_cb, init, NULL);
-}
-# endif
-
-static DWORD threadstopkey = TLS_OUT_OF_INDEXES;
-
-static int ossl_init_setup_thread_stop(void)
-{
-    /*
-     * We use a dummy thread local key here. We use the destructor to detect
-     * when the thread is going to stop
-     */
-    threadstopkey = TlsAlloc();
-    if (threadstopkey == TLS_OUT_OF_INDEXES)
-        return 0;
-
-    return 1;
-}
-
-static void ossl_init_thread_stop_cleanup(void)
-{
-    if (threadstopkey != TLS_OUT_OF_INDEXES) {
-        TlsFree(threadstopkey);
-    }
-}
-
-static struct thread_local_inits_st *ossl_init_get_thread_local(int alloc)
-{
-    struct thread_local_inits_st *local = TlsGetValue(threadstopkey);
-
-    if (local == NULL && alloc) {
-        local = OPENSSL_zalloc(sizeof *local);
-        TlsSetValue(threadstopkey, local);
-    }
-    if (!alloc) {
-        TlsSetValue(threadstopkey, NULL);
-    }
-
-    return local;
-}
-
-#else /* pthreads */
-# include <pthread.h>
-
-static pthread_key_t threadstopkey;
-
-typedef pthread_once_t OPENSSL_INIT_ONCE;
-# define OPENSSL_INIT_ONCE_STATIC_INIT          PTHREAD_ONCE_INIT
-
-static void ossl_init_once_run(OPENSSL_INIT_ONCE *once, void (*init)(void))
-{
-    pthread_once(once, init);
-}
+static CRYPTO_THREAD_LOCAL threadstopkey;
 
 static void ossl_init_thread_stop_wrap(void *local)
 {
     ossl_init_thread_stop((struct thread_local_inits_st *)local);
 }
 
-static int ossl_init_setup_thread_stop(void)
-{
-    /*
-     * We use a dummy thread local key here. We use the destructor to detect
-     * when the thread is going to stop
-     */
-    return (pthread_key_create(&threadstopkey,
-                               ossl_init_thread_stop_wrap) == 0);
-}
-
-static void ossl_init_thread_stop_cleanup(void)
-{
-}
-
 static struct thread_local_inits_st *ossl_init_get_thread_local(int alloc)
 {
-    struct thread_local_inits_st *local = pthread_getspecific(threadstopkey);
+    struct thread_local_inits_st *local =
+        CRYPTO_THREAD_get_local(&threadstopkey);
 
     if (local == NULL && alloc) {
         local = OPENSSL_zalloc(sizeof *local);
-        pthread_setspecific(threadstopkey, local);
+        CRYPTO_THREAD_set_local(&threadstopkey, local);
     }
     if (!alloc) {
-        pthread_setspecific(threadstopkey, NULL);
+        CRYPTO_THREAD_set_local(&threadstopkey, NULL);
     }
 
     return local;
 }
 
-#endif
-
 typedef struct ossl_init_stop_st OPENSSL_INIT_STOP;
 struct ossl_init_stop_st {
     void (*handler)(void);
@@ -263,23 +105,29 @@ struct ossl_init_stop_st {
 };
 
 static OPENSSL_INIT_STOP *stop_handlers = NULL;
+static CRYPTO_RWLOCK *init_lock = NULL;
 
-static OPENSSL_INIT_ONCE base = OPENSSL_INIT_ONCE_STATIC_INIT;
+static CRYPTO_ONCE base = CRYPTO_ONCE_STATIC_INIT;
 static int base_inited = 0;
 static void ossl_init_base(void)
 {
 #ifdef OPENSSL_INIT_DEBUG
     fprintf(stderr, "OPENSSL_INIT: ossl_init_base: Setting up stop handlers\n");
 #endif
-    ossl_init_setup_thread_stop();
+    /*
+     * We use a dummy thread local key here. We use the destructor to detect
+     * when the thread is going to stop (where that feature is available)
+     */
+    CRYPTO_THREAD_init_local(&threadstopkey, ossl_init_thread_stop_wrap);
 #ifndef OPENSSL_SYS_UEFI
     atexit(OPENSSL_cleanup);
 #endif
+    init_lock = CRYPTO_THREAD_lock_new();
     OPENSSL_cpuid_setup();
     base_inited = 1;
 }
 
-static OPENSSL_INIT_ONCE load_crypto_strings = OPENSSL_INIT_ONCE_STATIC_INIT;
+static CRYPTO_ONCE load_crypto_strings = CRYPTO_ONCE_STATIC_INIT;
 static int load_crypto_strings_inited = 0;
 static void ossl_init_no_load_crypto_strings(void)
 {
@@ -303,7 +151,7 @@ static void ossl_init_load_crypto_strings(void)
     load_crypto_strings_inited = 1;
 }
 
-static OPENSSL_INIT_ONCE add_all_ciphers = OPENSSL_INIT_ONCE_STATIC_INIT;
+static CRYPTO_ONCE add_all_ciphers = CRYPTO_ONCE_STATIC_INIT;
 static void ossl_init_add_all_ciphers(void)
 {
     /*
@@ -324,7 +172,7 @@ static void ossl_init_add_all_ciphers(void)
 #endif
 }
 
-static OPENSSL_INIT_ONCE add_all_digests = OPENSSL_INIT_ONCE_STATIC_INIT;
+static CRYPTO_ONCE add_all_digests = CRYPTO_ONCE_STATIC_INIT;
 static void ossl_init_add_all_digests(void)
 {
     /*
@@ -351,7 +199,7 @@ static void ossl_init_no_add_algs(void)
     return;
 }
 
-static OPENSSL_INIT_ONCE config = OPENSSL_INIT_ONCE_STATIC_INIT;
+static CRYPTO_ONCE config = CRYPTO_ONCE_STATIC_INIT;
 static int config_inited = 0;
 static const char *config_filename;
 static void ossl_init_config(void)
@@ -375,7 +223,7 @@ static void ossl_init_no_config(void)
 }
 
 #ifndef OPENSSL_NO_ASYNC
-static OPENSSL_INIT_ONCE async = OPENSSL_INIT_ONCE_STATIC_INIT;
+static CRYPTO_ONCE async = CRYPTO_ONCE_STATIC_INIT;
 static int async_inited = 0;
 static void ossl_init_async(void)
 {
@@ -389,7 +237,7 @@ static void ossl_init_async(void)
 
 #ifndef OPENSSL_NO_ENGINE
 static int engine_inited = 0;
-static OPENSSL_INIT_ONCE engine_openssl = OPENSSL_INIT_ONCE_STATIC_INIT;
+static CRYPTO_ONCE engine_openssl = CRYPTO_ONCE_STATIC_INIT;
 static void ossl_init_engine_openssl(void)
 {
 # ifdef OPENSSL_INIT_DEBUG
@@ -401,7 +249,7 @@ static void ossl_init_engine_openssl(void)
 }
 # if !defined(OPENSSL_NO_HW) && \
     (defined(__OpenBSD__) || defined(__FreeBSD__) || defined(HAVE_CRYPTODEV))
-static OPENSSL_INIT_ONCE engine_cryptodev = OPENSSL_INIT_ONCE_STATIC_INIT;
+static CRYPTO_ONCE engine_cryptodev = CRYPTO_ONCE_STATIC_INIT;
 static void ossl_init_engine_cryptodev(void)
 {
 #  ifdef OPENSSL_INIT_DEBUG
@@ -414,7 +262,7 @@ static void ossl_init_engine_cryptodev(void)
 # endif
 
 # ifndef OPENSSL_NO_RDRAND
-static OPENSSL_INIT_ONCE engine_rdrand = OPENSSL_INIT_ONCE_STATIC_INIT;
+static CRYPTO_ONCE engine_rdrand = CRYPTO_ONCE_STATIC_INIT;
 static void ossl_init_engine_rdrand(void)
 {
 #  ifdef OPENSSL_INIT_DEBUG
@@ -425,7 +273,7 @@ static void ossl_init_engine_rdrand(void)
     engine_inited = 1;
 }
 # endif
-static OPENSSL_INIT_ONCE engine_dynamic = OPENSSL_INIT_ONCE_STATIC_INIT;
+static CRYPTO_ONCE engine_dynamic = CRYPTO_ONCE_STATIC_INIT;
 static void ossl_init_engine_dynamic(void)
 {
 # ifdef OPENSSL_INIT_DEBUG
@@ -437,7 +285,7 @@ static void ossl_init_engine_dynamic(void)
 }
 # ifndef OPENSSL_NO_STATIC_ENGINE
 #  if !defined(OPENSSL_NO_HW) && !defined(OPENSSL_NO_HW_PADLOCK)
-static OPENSSL_INIT_ONCE engine_padlock = OPENSSL_INIT_ONCE_STATIC_INIT;
+static CRYPTO_ONCE engine_padlock = CRYPTO_ONCE_STATIC_INIT;
 static void ossl_init_engine_padlock(void)
 {
 #   ifdef OPENSSL_INIT_DEBUG
@@ -449,7 +297,7 @@ static void ossl_init_engine_padlock(void)
 }
 #  endif
 #  if defined(OPENSSL_SYS_WIN32) && !defined(OPENSSL_NO_CAPIENG)
-static OPENSSL_INIT_ONCE engine_capi = OPENSSL_INIT_ONCE_STATIC_INIT;
+static CRYPTO_ONCE engine_capi = CRYPTO_ONCE_STATIC_INIT;
 static void ossl_init_engine_capi(void)
 {
 #   ifdef OPENSSL_INIT_DEBUG
@@ -460,7 +308,7 @@ static void ossl_init_engine_capi(void)
     engine_inited = 1;
 }
 #  endif
-static OPENSSL_INIT_ONCE engine_dasync = OPENSSL_INIT_ONCE_STATIC_INIT;
+static CRYPTO_ONCE engine_dasync = CRYPTO_ONCE_STATIC_INIT;
 static void ossl_init_engine_dasync(void)
 {
 # ifdef OPENSSL_INIT_DEBUG
@@ -485,7 +333,7 @@ static void ossl_init_engine_afalg(void)
 # endif
 #endif
 
-static OPENSSL_INIT_ONCE zlib = OPENSSL_INIT_ONCE_STATIC_INIT;
+static CRYPTO_ONCE zlib = CRYPTO_ONCE_STATIC_INIT;
 static int zlib_inited = 0;
 static void ossl_init_zlib(void)
 {
@@ -579,6 +427,9 @@ void OPENSSL_cleanup(void)
         OPENSSL_free(lasthandler);
     }
     stop_handlers = NULL;
+
+    CRYPTO_THREAD_lock_free(init_lock);
+
     /*
      * We assume we are single-threaded for this function, i.e. no race
      * conditions for the various "*_inited" vars below.
@@ -620,7 +471,7 @@ void OPENSSL_cleanup(void)
         ERR_free_strings();
     }
 
-    ossl_init_thread_stop_cleanup();
+    CRYPTO_THREAD_cleanup_local(&threadstopkey);
 
 #ifdef OPENSSL_INIT_DEBUG
     fprintf(stderr, "OPENSSL_INIT: OPENSSL_INIT_library_stop: "
@@ -661,79 +512,96 @@ int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings)
         return 0;
     }
 
-    ossl_init_once_run(&base, ossl_init_base);
+    if (!CRYPTO_THREAD_run_once(&base, ossl_init_base))
+        return 0;
 
-    if (opts & OPENSSL_INIT_NO_LOAD_CRYPTO_STRINGS)
-        ossl_init_once_run(&load_crypto_strings,
-                           ossl_init_no_load_crypto_strings);
+    if ((opts & OPENSSL_INIT_NO_LOAD_CRYPTO_STRINGS)
+            && !CRYPTO_THREAD_run_once(&load_crypto_strings,
+                                       ossl_init_no_load_crypto_strings))
+        return 0;
 
-    if (opts & OPENSSL_INIT_LOAD_CRYPTO_STRINGS)
-        ossl_init_once_run(&load_crypto_strings, ossl_init_load_crypto_strings);
+    if ((opts & OPENSSL_INIT_LOAD_CRYPTO_STRINGS)
+            && !CRYPTO_THREAD_run_once(&load_crypto_strings,
+                                       ossl_init_load_crypto_strings))
+        return 0;
 
-    if (opts & OPENSSL_INIT_NO_ADD_ALL_CIPHERS)
-        ossl_init_once_run(&add_all_ciphers, ossl_init_no_add_algs);
+    if ((opts & OPENSSL_INIT_NO_ADD_ALL_CIPHERS)
+            && !CRYPTO_THREAD_run_once(&add_all_ciphers, ossl_init_no_add_algs))
+        return 0;
 
-    if (opts & OPENSSL_INIT_ADD_ALL_CIPHERS)
-        ossl_init_once_run(&add_all_ciphers, ossl_init_add_all_ciphers);
+    if ((opts & OPENSSL_INIT_ADD_ALL_CIPHERS)
+            && !CRYPTO_THREAD_run_once(&add_all_ciphers,
+                                       ossl_init_add_all_ciphers))
+        return 0;
 
-    if (opts & OPENSSL_INIT_NO_ADD_ALL_DIGESTS)
-        ossl_init_once_run(&add_all_digests, ossl_init_no_add_algs);
+    if ((opts & OPENSSL_INIT_NO_ADD_ALL_DIGESTS)
+            && !CRYPTO_THREAD_run_once(&add_all_digests, ossl_init_no_add_algs))
+        return 0;
 
-    if (opts & OPENSSL_INIT_ADD_ALL_DIGESTS)
-        ossl_init_once_run(&add_all_digests, ossl_init_add_all_digests);
+    if ((opts & OPENSSL_INIT_ADD_ALL_DIGESTS)
+            && !CRYPTO_THREAD_run_once(&add_all_digests,
+                                       ossl_init_add_all_digests))
+        return 0;
 
-    if (opts & OPENSSL_INIT_NO_LOAD_CONFIG) {
-        ossl_init_once_run(&config, ossl_init_no_config);
-    }
+    if ((opts & OPENSSL_INIT_NO_LOAD_CONFIG)
+            && !CRYPTO_THREAD_run_once(&config, ossl_init_no_config))
+        return 0;
 
     if (opts & OPENSSL_INIT_LOAD_CONFIG) {
-        CRYPTO_w_lock(CRYPTO_LOCK_INIT);
+        int ret;
+        CRYPTO_THREAD_write_lock(init_lock);
         config_filename = (settings == NULL) ? NULL : settings->config_name;
-        ossl_init_once_run(&config, ossl_init_config);
-        CRYPTO_w_unlock(CRYPTO_LOCK_INIT);
+        ret = CRYPTO_THREAD_run_once(&config, ossl_init_config);
+        CRYPTO_THREAD_unlock(init_lock);
+        if (!ret)
+            return 0;
     }
 
 #ifndef OPENSSL_NO_ASYNC
-    if (opts & OPENSSL_INIT_ASYNC) {
-        ossl_init_once_run(&async, ossl_init_async);
-    }
+    if ((opts & OPENSSL_INIT_ASYNC)
+            && !CRYPTO_THREAD_run_once(&async, ossl_init_async))
+        return 0;
 #endif
 #ifndef OPENSSL_NO_ENGINE
-    if (opts & OPENSSL_INIT_ENGINE_OPENSSL) {
-        ossl_init_once_run(&engine_openssl, ossl_init_engine_openssl);
-    }
+    if ((opts & OPENSSL_INIT_ENGINE_OPENSSL)
+            && !CRYPTO_THREAD_run_once(&engine_openssl,
+                                       ossl_init_engine_openssl))
+        return 0;
 # if !defined(OPENSSL_NO_HW) && \
     (defined(__OpenBSD__) || defined(__FreeBSD__) || defined(HAVE_CRYPTODEV))
-    if (opts & OPENSSL_INIT_ENGINE_CRYPTODEV) {
-        ossl_init_once_run(&engine_cryptodev, ossl_init_engine_cryptodev);
-    }
+    if ((opts & OPENSSL_INIT_ENGINE_CRYPTODEV)
+            && !CRYPTO_THREAD_run_once(&engine_cryptodev,
+                                       ossl_init_engine_cryptodev))
+        return 0;
 # endif
 # ifndef OPENSSL_NO_RDRAND
-    if (opts & OPENSSL_INIT_ENGINE_RDRAND) {
-        ossl_init_once_run(&engine_rdrand, ossl_init_engine_rdrand);
-    }
+    if ((opts & OPENSSL_INIT_ENGINE_RDRAND)
+            && !CRYPTO_THREAD_run_once(&engine_rdrand, ossl_init_engine_rdrand))
+        return 0;
 # endif
-    if (opts & OPENSSL_INIT_ENGINE_DYNAMIC) {
-        ossl_init_once_run(&engine_dynamic, ossl_init_engine_dynamic);
-    }
+    if ((opts & OPENSSL_INIT_ENGINE_DYNAMIC)
+            && !CRYPTO_THREAD_run_once(&engine_dynamic,
+                                       ossl_init_engine_dynamic))
+        return 0;
 # ifndef OPENSSL_NO_STATIC_ENGINE
 #  if !defined(OPENSSL_NO_HW) && !defined(OPENSSL_NO_HW_PADLOCK)
-    if (opts & OPENSSL_INIT_ENGINE_PADLOCK) {
-        ossl_init_once_run(&engine_padlock, ossl_init_engine_padlock);
-    }
+    if ((opts & OPENSSL_INIT_ENGINE_PADLOCK)
+            && CRYPTO_THREAD_run_once(&engine_padlock,
+                                      ossl_init_engine_padlock))
+        return 0;
 #  endif
 #  if defined(OPENSSL_SYS_WIN32) && !defined(OPENSSL_NO_CAPIENG)
-    if (opts & OPENSSL_INIT_ENGINE_CAPI) {
-        ossl_init_once_run(&engine_capi, ossl_init_engine_capi);
-    }
+    if ((opts & OPENSSL_INIT_ENGINE_CAPI)
+            && CRYPTO_THREAD_run_once(&engine_capi, ossl_init_engine_capi))
+        return 0;
 #  endif
-    if (opts & OPENSSL_INIT_ENGINE_DASYNC) {
-        ossl_init_once_run(&engine_dasync, ossl_init_engine_dasync);
-    }
+    if ((opts & OPENSSL_INIT_ENGINE_DASYNC)
+            && !CRYPTO_THREAD_run_once(&engine_dasync, ossl_init_engine_dasync))
+        return 0;
 #  if !defined(OPENSSL_NO_AFALGENG)
-    if (opts & OPENSSL_INIT_ENGINE_AFALG) {
-        ossl_init_once_run(&engine_afalg, ossl_init_engine_afalg);
-    }
+    if ((opts & OPENSSL_INIT_ENGINE_AFALG)
+            && !CRYPTO_THREAD_run_once(&engine_afalg, ossl_init_engine_afalg))
+        return 0;
 #  endif
 # endif
     if (opts & (OPENSSL_INIT_ENGINE_ALL_BUILTIN
@@ -743,9 +611,9 @@ int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings)
     }
 #endif
 
-    if (opts & OPENSSL_INIT_ZLIB) {
-        ossl_init_once_run(&zlib, ossl_init_zlib);
-    }
+    if ((opts & OPENSSL_INIT_ZLIB)
+            && CRYPTO_THREAD_run_once(&zlib, ossl_init_zlib))
+        return 0;
 
     return 1;
 }
diff --git a/crypto/lock.c b/crypto/lock.c
index aa34202..35f0059 100644
--- a/crypto/lock.c
+++ b/crypto/lock.c
@@ -163,8 +163,7 @@ static const char *const lock_names[CRYPTO_NUM_LOCKS] = {
     "comp",
     "fips",
     "fips2",
-    "init",
-#if CRYPTO_NUM_LOCKS != 42
+#if CRYPTO_NUM_LOCKS != 41
 # error "Inconsistency between crypto.h and cryptlib.c"
 #endif
 };
diff --git a/include/openssl/crypto.h b/include/openssl/crypto.h
index d52c14c..a881fad 100644
--- a/include/openssl/crypto.h
+++ b/include/openssl/crypto.h
@@ -205,8 +205,7 @@ extern "C" {
 # define CRYPTO_LOCK_COMP                38
 # define CRYPTO_LOCK_FIPS                39
 # define CRYPTO_LOCK_FIPS2               40
-# define CRYPTO_LOCK_INIT                41
-# define CRYPTO_NUM_LOCKS                42
+# define CRYPTO_NUM_LOCKS                41
 
 # define CRYPTO_LOCK             1
 # define CRYPTO_UNLOCK           2
diff --git a/ssl/ssl_init.c b/ssl/ssl_init.c
index 7d89ed0..413fa41 100644
--- a/ssl/ssl_init.c
+++ b/ssl/ssl_init.c
@@ -57,6 +57,7 @@
 
 #include "e_os.h"
 
+#include <internal/threads.h>
 #include <openssl/crypto.h>
 #include <openssl/evp.h>
 #include <assert.h>
@@ -64,86 +65,9 @@
 
 static int stopped;
 
-/* Implement "once" functionality */
-#if !defined(OPENSSL_THREADS)
-typedef int OPENSSL_INIT_ONCE;
-# define OPENSSL_INIT_ONCE_STATIC_INIT          0
-
-static void ossl_init_once_run(OPENSSL_INIT_ONCE *once, void (*init)(void))
-{
-    if (*once == OPENSSL_INIT_ONCE_STATIC_INIT) {
-        *once = 1;
-        init();
-    }
-}
-#elif defined(OPENSSL_SYS_WINDOWS)
-# include <windows.h>
-
-# if _WIN32_WINNT < 0x0600
-
-/*
- * Versions before 0x0600 (Windows Vista, Windows Server 2008 or later) do not
- * have InitOnceExecuteOnce, so we fall back to using a spinlock instead.
- */
-typedef LONG OPENSSL_INIT_ONCE;
-#  define OPENSSL_INIT_ONCE_STATIC_INIT          0
-
-#  define ONCE_UNINITED     0
-#  define ONCE_ININIT       1
-#  define ONCE_DONE         2
-
-static void ossl_init_once_run(OPENSSL_INIT_ONCE *once, void (*init)(void))
-{
-    LONG volatile *lock = (LONG *)once;
-    LONG result;
-
-    if (*lock == ONCE_DONE)
-        return;
-
-    do {
-        result = InterlockedCompareExchange(lock, ONCE_ININIT, ONCE_UNINITED);
-        if (result == ONCE_UNINITED) {
-            init();
-            *lock = ONCE_DONE;
-            return;
-        }
-    } while (result == ONCE_ININIT);
-}
-
-# else
-
-typedef INIT_ONCE OPENSSL_INIT_ONCE;
-#  define OPENSSL_INIT_ONCE_STATIC_INIT          INIT_ONCE_STATIC_INIT
-
-static BOOL CALLBACK once_cb(PINIT_ONCE once, PVOID initfp, PVOID *unused)
-{
-    void (*init)(void) = initfp;
-
-    init();
-
-    return TRUE;
-}
-
-static void ossl_init_once_run(OPENSSL_INIT_ONCE *once, void (*init)(void))
-{
-    InitOnceExecuteOnce((INIT_ONCE *)once, once_cb, init, NULL);
-}
-# endif
-#else /* pthreads */
-# include <pthread.h>
-
-typedef pthread_once_t OPENSSL_INIT_ONCE;
-# define OPENSSL_INIT_ONCE_STATIC_INIT          PTHREAD_ONCE_INIT
-
-static void ossl_init_once_run(OPENSSL_INIT_ONCE *once, void (*init)(void))
-{
-    pthread_once(once, init);
-}
-#endif
-
 static void ssl_library_stop(void);
 
-static OPENSSL_INIT_ONCE ssl_base = OPENSSL_INIT_ONCE_STATIC_INIT;
+static CRYPTO_ONCE ssl_base = CRYPTO_ONCE_STATIC_INIT;
 static int ssl_base_inited = 0;
 static void ossl_init_ssl_base(void)
 {
@@ -238,7 +162,7 @@ static void ossl_init_ssl_base(void)
     ssl_base_inited = 1;
 }
 
-static OPENSSL_INIT_ONCE ssl_strings = OPENSSL_INIT_ONCE_STATIC_INIT;
+static CRYPTO_ONCE ssl_strings = CRYPTO_ONCE_STATIC_INIT;
 static int ssl_strings_inited = 0;
 static void ossl_init_load_ssl_strings(void)
 {
@@ -321,13 +245,18 @@ int OPENSSL_init_ssl(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings)
                              | OPENSSL_INIT_ADD_ALL_DIGESTS, settings))
         return 0;
 
-    ossl_init_once_run(&ssl_base, ossl_init_ssl_base);
+    if (!CRYPTO_THREAD_run_once(&ssl_base, ossl_init_ssl_base))
+        return 0;
 
-    if (opts & OPENSSL_INIT_NO_LOAD_SSL_STRINGS)
-        ossl_init_once_run(&ssl_strings, ossl_init_no_load_ssl_strings);
+    if ((opts & OPENSSL_INIT_NO_LOAD_SSL_STRINGS)
+            && !CRYPTO_THREAD_run_once(&ssl_strings,
+                                       ossl_init_no_load_ssl_strings))
+        return 0;
 
-    if (opts & OPENSSL_INIT_LOAD_SSL_STRINGS)
-        ossl_init_once_run(&ssl_strings, ossl_init_load_ssl_strings);
+    if ((opts & OPENSSL_INIT_LOAD_SSL_STRINGS)
+            && !CRYPTO_THREAD_run_once(&ssl_strings,
+                                       ossl_init_load_ssl_strings))
+        return 0;
 
     return 1;
 }


More information about the openssl-commits mailing list