Commit b1f1e7ae authored by Matt Caswell's avatar Matt Caswell
Browse files

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: default avatarRichard Levitte <levitte@openssl.org>
parent 48fe8ab0

crypto/init.c

+80 −131
Original line number Diff line number Diff line
@@ -55,6 +55,7 @@ 
 *

 */



#include <internal/threads.h>

#include <internal/cryptlib_int.h>

#include <openssl/err.h>

#include <openssl/rand.h>
@@ -76,16 +77,6 @@ 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)

{
@@ -119,57 +110,6 @@ static struct thread_local_inits_st *ossl_init_get_thread_local(int alloc) 


# 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)
@@ -212,14 +152,6 @@ static struct thread_local_inits_st *ossl_init_get_thread_local(int alloc) 


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 void ossl_init_thread_stop_wrap(void *local)

{

    ossl_init_thread_stop((struct thread_local_inits_st *)local);
@@ -264,7 +196,7 @@ struct ossl_init_stop_st { 


static OPENSSL_INIT_STOP *stop_handlers = 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)

{
@@ -279,7 +211,7 @@ static void ossl_init_base(void) 
    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 +235,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 +256,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 +283,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 +307,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 +321,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 +333,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 +346,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 +357,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 +369,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 +381,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 +392,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 +417,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)

{
@@ -661,79 +593,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) {

        int ret;

        CRYPTO_w_lock(CRYPTO_LOCK_INIT);

        config_filename = (settings == NULL) ? NULL : settings->config_name;

        ossl_init_once_run(&config, ossl_init_config);

        ret = CRYPTO_THREAD_run_once(&config, ossl_init_config);

        CRYPTO_w_unlock(CRYPTO_LOCK_INIT);

        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 +692,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;

}

ssl/ssl_init.c

+13 −84
Original line number Diff line number Diff line
@@ -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;

}