legacy-libs/grpc-cloned/deps/grpc/third_party/boringssl/crypto/thread_win.c

   1 /* Copyright (c) 2015, Google Inc.
   2  *
   3  * Permission to use, copy, modify, and/or distribute this software for any
   4  * purpose with or without fee is hereby granted, provided that the above
   5  * copyright notice and this permission notice appear in all copies.
   6  *
   7  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   8  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   9  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  10  * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  11  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  12  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  13  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
  14
  15 #include "internal.h"
  16
  17 #if defined(OPENSSL_WINDOWS_THREADS)
  18
  19 OPENSSL_MSVC_PRAGMA(warning(push, 3))
  20 #include <windows.h>
  21 OPENSSL_MSVC_PRAGMA(warning(pop))
  22
  23 #include <stdlib.h>
  24 #include <string.h>
  25
  26 #include <openssl/mem.h>
  27 #include <openssl/type_check.h>
  28
  29
  30 OPENSSL_COMPILE_ASSERT(sizeof(CRYPTO_MUTEX) >= sizeof(SRWLOCK),
  31                        CRYPTO_MUTEX_too_small);
  32
  33 static BOOL CALLBACK call_once_init(INIT_ONCE *once, void *arg, void **out) {
  34   void (**init)(void) = (void (**)(void))arg;
  35   (**init)();
  36   return TRUE;
  37 }
  38
  39 void CRYPTO_once(CRYPTO_once_t *once, void (*init)(void)) {
  40   if (!InitOnceExecuteOnce(once, call_once_init, &init, NULL)) {
  41     abort();
  42   }
  43 }
  44
  45 void CRYPTO_MUTEX_init(CRYPTO_MUTEX *lock) {
  46   InitializeSRWLock((SRWLOCK *) lock);
  47 }
  48
  49 void CRYPTO_MUTEX_lock_read(CRYPTO_MUTEX *lock) {
  50   AcquireSRWLockShared((SRWLOCK *) lock);
  51 }
  52
  53 void CRYPTO_MUTEX_lock_write(CRYPTO_MUTEX *lock) {
  54   AcquireSRWLockExclusive((SRWLOCK *) lock);
  55 }
  56
  57 void CRYPTO_MUTEX_unlock_read(CRYPTO_MUTEX *lock) {
  58   ReleaseSRWLockShared((SRWLOCK *) lock);
  59 }
  60
  61 void CRYPTO_MUTEX_unlock_write(CRYPTO_MUTEX *lock) {
  62   ReleaseSRWLockExclusive((SRWLOCK *) lock);
  63 }
  64
  65 void CRYPTO_MUTEX_cleanup(CRYPTO_MUTEX *lock) {
  66   // SRWLOCKs require no cleanup.
  67 }
  68
  69 void CRYPTO_STATIC_MUTEX_lock_read(struct CRYPTO_STATIC_MUTEX *lock) {
  70   AcquireSRWLockShared(&lock->lock);
  71 }
  72
  73 void CRYPTO_STATIC_MUTEX_lock_write(struct CRYPTO_STATIC_MUTEX *lock) {
  74   AcquireSRWLockExclusive(&lock->lock);
  75 }
  76
  77 void CRYPTO_STATIC_MUTEX_unlock_read(struct CRYPTO_STATIC_MUTEX *lock) {
  78   ReleaseSRWLockShared(&lock->lock);
  79 }
  80
  81 void CRYPTO_STATIC_MUTEX_unlock_write(struct CRYPTO_STATIC_MUTEX *lock) {
  82   ReleaseSRWLockExclusive(&lock->lock);
  83 }
  84
  85 static CRITICAL_SECTION g_destructors_lock;
  86 static thread_local_destructor_t g_destructors[NUM_OPENSSL_THREAD_LOCALS];
  87
  88 static CRYPTO_once_t g_thread_local_init_once = CRYPTO_ONCE_INIT;
  89 static DWORD g_thread_local_key;
  90 static int g_thread_local_failed;
  91
  92 static void thread_local_init(void) {
  93   if (!InitializeCriticalSectionAndSpinCount(&g_destructors_lock, 0x400)) {
  94     g_thread_local_failed = 1;
  95     return;
  96   }
  97   g_thread_local_key = TlsAlloc();
  98   g_thread_local_failed = (g_thread_local_key == TLS_OUT_OF_INDEXES);
  99 }
 100
 101 static void NTAPI thread_local_destructor(PVOID module, DWORD reason,
 102                                           PVOID reserved) {
 103   // Only free memory on |DLL_THREAD_DETACH|, not |DLL_PROCESS_DETACH|. In
 104   // VS2015's debug runtime, the C runtime has been unloaded by the time
 105   // |DLL_PROCESS_DETACH| runs. See https://crbug.com/575795. This is consistent
 106   // with |pthread_key_create| which does not call destructors on process exit,
 107   // only thread exit.
 108   if (reason != DLL_THREAD_DETACH) {
 109     return;
 110   }
 111
 112   CRYPTO_once(&g_thread_local_init_once, thread_local_init);
 113   if (g_thread_local_failed) {
 114     return;
 115   }
 116
 117   void **pointers = (void**) TlsGetValue(g_thread_local_key);
 118   if (pointers == NULL) {
 119     return;
 120   }
 121
 122   thread_local_destructor_t destructors[NUM_OPENSSL_THREAD_LOCALS];
 123
 124   EnterCriticalSection(&g_destructors_lock);
 125   OPENSSL_memcpy(destructors, g_destructors, sizeof(destructors));
 126   LeaveCriticalSection(&g_destructors_lock);
 127
 128   unsigned i;
 129   for (i = 0; i < NUM_OPENSSL_THREAD_LOCALS; i++) {
 130     if (destructors[i] != NULL) {
 131       destructors[i](pointers[i]);
 132     }
 133   }
 134
 135   OPENSSL_free(pointers);
 136 }
 137
 138 // Thread Termination Callbacks.
 139 //
 140 // Windows doesn't support a per-thread destructor with its TLS primitives.
 141 // So, we build it manually by inserting a function to be called on each
 142 // thread's exit. This magic is from http://www.codeproject.com/threads/tls.asp
 143 // and it works for VC++ 7.0 and later.
 144 //
 145 // Force a reference to _tls_used to make the linker create the TLS directory
 146 // if it's not already there. (E.g. if __declspec(thread) is not used). Force
 147 // a reference to p_thread_callback_boringssl to prevent whole program
 148 // optimization from discarding the variable.
 149 #ifdef _WIN64
 150 #pragma comment(linker, "/INCLUDE:_tls_used")
 151 #pragma comment(linker, "/INCLUDE:p_thread_callback_boringssl")
 152 #else
 153 #pragma comment(linker, "/INCLUDE:__tls_used")
 154 #pragma comment(linker, "/INCLUDE:_p_thread_callback_boringssl")
 155 #endif
 156
 157 // .CRT$XLA to .CRT$XLZ is an array of PIMAGE_TLS_CALLBACK pointers that are
 158 // called automatically by the OS loader code (not the CRT) when the module is
 159 // loaded and on thread creation. They are NOT called if the module has been
 160 // loaded by a LoadLibrary() call. It must have implicitly been loaded at
 161 // process startup.
 162 //
 163 // By implicitly loaded, I mean that it is directly referenced by the main EXE
 164 // or by one of its dependent DLLs. Delay-loaded DLL doesn't count as being
 165 // implicitly loaded.
 166 //
 167 // See VC\crt\src\tlssup.c for reference.
 168
 169 // The linker must not discard p_thread_callback_boringssl. (We force a
 170 // reference to this variable with a linker /INCLUDE:symbol pragma to ensure
 171 // that.) If this variable is discarded, the OnThreadExit function will never
 172 // be called.
 173 #ifdef _WIN64
 174
 175 // .CRT section is merged with .rdata on x64 so it must be constant data.
 176 #pragma const_seg(".CRT$XLC")
 177 // When defining a const variable, it must have external linkage to be sure the
 178 // linker doesn't discard it.
 179 extern const PIMAGE_TLS_CALLBACK p_thread_callback_boringssl;
 180 const PIMAGE_TLS_CALLBACK p_thread_callback_boringssl = thread_local_destructor;
 181 // Reset the default section.
 182 #pragma const_seg()
 183
 184 #else
 185
 186 #pragma data_seg(".CRT$XLC")
 187 PIMAGE_TLS_CALLBACK p_thread_callback_boringssl = thread_local_destructor;
 188 // Reset the default section.
 189 #pragma data_seg()
 190
 191 #endif  // _WIN64
 192
 193 void *CRYPTO_get_thread_local(thread_local_data_t index) {
 194   CRYPTO_once(&g_thread_local_init_once, thread_local_init);
 195   if (g_thread_local_failed) {
 196     return NULL;
 197   }
 198
 199   void **pointers = TlsGetValue(g_thread_local_key);
 200   if (pointers == NULL) {
 201     return NULL;
 202   }
 203   return pointers[index];
 204 }
 205
 206 int CRYPTO_set_thread_local(thread_local_data_t index, void *value,
 207                             thread_local_destructor_t destructor) {
 208   CRYPTO_once(&g_thread_local_init_once, thread_local_init);
 209   if (g_thread_local_failed) {
 210     destructor(value);
 211     return 0;
 212   }
 213
 214   void **pointers = TlsGetValue(g_thread_local_key);
 215   if (pointers == NULL) {
 216     pointers = OPENSSL_malloc(sizeof(void *) * NUM_OPENSSL_THREAD_LOCALS);
 217     if (pointers == NULL) {
 218       destructor(value);
 219       return 0;
 220     }
 221     OPENSSL_memset(pointers, 0, sizeof(void *) * NUM_OPENSSL_THREAD_LOCALS);
 222     if (TlsSetValue(g_thread_local_key, pointers) == 0) {
 223       OPENSSL_free(pointers);
 224       destructor(value);
 225       return 0;
 226     }
 227   }
 228
 229   EnterCriticalSection(&g_destructors_lock);
 230   g_destructors[index] = destructor;
 231   LeaveCriticalSection(&g_destructors_lock);
 232
 233   pointers[index] = value;
 234   return 1;
 235 }
 236
 237 #endif  // OPENSSL_WINDOWS_THREADS