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_PTHREADS)
18
19 #include <pthread.h>
20 #include <stdlib.h>
21 #include <string.h>
22
23 #include <openssl/mem.h>
24 #include <openssl/type_check.h>
25
26
27 OPENSSL_STATIC_ASSERT(sizeof(CRYPTO_MUTEX) >= sizeof(pthread_rwlock_t),
28 "CRYPTO_MUTEX is too small");
29 #if defined(__GNUC__) || defined(__clang__)
30 OPENSSL_STATIC_ASSERT(alignof(CRYPTO_MUTEX) >= alignof(pthread_rwlock_t),
31 "CRYPTO_MUTEX has insufficient alignment");
32 #endif
33
CRYPTO_MUTEX_init(CRYPTO_MUTEX * lock)34 void CRYPTO_MUTEX_init(CRYPTO_MUTEX *lock) {
35 if (pthread_rwlock_init((pthread_rwlock_t *) lock, NULL) != 0) {
36 abort();
37 }
38 }
39
CRYPTO_MUTEX_lock_read(CRYPTO_MUTEX * lock)40 void CRYPTO_MUTEX_lock_read(CRYPTO_MUTEX *lock) {
41 if (pthread_rwlock_rdlock((pthread_rwlock_t *) lock) != 0) {
42 abort();
43 }
44 }
45
CRYPTO_MUTEX_lock_write(CRYPTO_MUTEX * lock)46 void CRYPTO_MUTEX_lock_write(CRYPTO_MUTEX *lock) {
47 if (pthread_rwlock_wrlock((pthread_rwlock_t *) lock) != 0) {
48 abort();
49 }
50 }
51
CRYPTO_MUTEX_unlock_read(CRYPTO_MUTEX * lock)52 void CRYPTO_MUTEX_unlock_read(CRYPTO_MUTEX *lock) {
53 if (pthread_rwlock_unlock((pthread_rwlock_t *) lock) != 0) {
54 abort();
55 }
56 }
57
CRYPTO_MUTEX_unlock_write(CRYPTO_MUTEX * lock)58 void CRYPTO_MUTEX_unlock_write(CRYPTO_MUTEX *lock) {
59 if (pthread_rwlock_unlock((pthread_rwlock_t *) lock) != 0) {
60 abort();
61 }
62 }
63
CRYPTO_MUTEX_cleanup(CRYPTO_MUTEX * lock)64 void CRYPTO_MUTEX_cleanup(CRYPTO_MUTEX *lock) {
65 pthread_rwlock_destroy((pthread_rwlock_t *) lock);
66 }
67
CRYPTO_STATIC_MUTEX_lock_read(struct CRYPTO_STATIC_MUTEX * lock)68 void CRYPTO_STATIC_MUTEX_lock_read(struct CRYPTO_STATIC_MUTEX *lock) {
69 if (pthread_rwlock_rdlock(&lock->lock) != 0) {
70 abort();
71 }
72 }
73
CRYPTO_STATIC_MUTEX_lock_write(struct CRYPTO_STATIC_MUTEX * lock)74 void CRYPTO_STATIC_MUTEX_lock_write(struct CRYPTO_STATIC_MUTEX *lock) {
75 if (pthread_rwlock_wrlock(&lock->lock) != 0) {
76 abort();
77 }
78 }
79
CRYPTO_STATIC_MUTEX_unlock_read(struct CRYPTO_STATIC_MUTEX * lock)80 void CRYPTO_STATIC_MUTEX_unlock_read(struct CRYPTO_STATIC_MUTEX *lock) {
81 if (pthread_rwlock_unlock(&lock->lock) != 0) {
82 abort();
83 }
84 }
85
CRYPTO_STATIC_MUTEX_unlock_write(struct CRYPTO_STATIC_MUTEX * lock)86 void CRYPTO_STATIC_MUTEX_unlock_write(struct CRYPTO_STATIC_MUTEX *lock) {
87 if (pthread_rwlock_unlock(&lock->lock) != 0) {
88 abort();
89 }
90 }
91
CRYPTO_once(CRYPTO_once_t * once,void (* init)(void))92 void CRYPTO_once(CRYPTO_once_t *once, void (*init)(void)) {
93 if (pthread_once(once, init) != 0) {
94 abort();
95 }
96 }
97
98 static pthread_mutex_t g_destructors_lock = PTHREAD_MUTEX_INITIALIZER;
99 static thread_local_destructor_t g_destructors[NUM_OPENSSL_THREAD_LOCALS];
100
101 // thread_local_destructor is called when a thread exits. It releases thread
102 // local data for that thread only.
thread_local_destructor(void * arg)103 static void thread_local_destructor(void *arg) {
104 if (arg == NULL) {
105 return;
106 }
107
108 thread_local_destructor_t destructors[NUM_OPENSSL_THREAD_LOCALS];
109 if (pthread_mutex_lock(&g_destructors_lock) != 0) {
110 return;
111 }
112 OPENSSL_memcpy(destructors, g_destructors, sizeof(destructors));
113 pthread_mutex_unlock(&g_destructors_lock);
114
115 unsigned i;
116 void **pointers = arg;
117 for (i = 0; i < NUM_OPENSSL_THREAD_LOCALS; i++) {
118 if (destructors[i] != NULL) {
119 destructors[i](pointers[i]);
120 }
121 }
122
123 OPENSSL_free(pointers);
124 }
125
126 static pthread_once_t g_thread_local_init_once = PTHREAD_ONCE_INIT;
127 static pthread_key_t g_thread_local_key;
128 static int g_thread_local_key_created = 0;
129
thread_local_init(void)130 static void thread_local_init(void) {
131 g_thread_local_key_created =
132 pthread_key_create(&g_thread_local_key, thread_local_destructor) == 0;
133 }
134
CRYPTO_get_thread_local(thread_local_data_t index)135 void *CRYPTO_get_thread_local(thread_local_data_t index) {
136 CRYPTO_once(&g_thread_local_init_once, thread_local_init);
137 if (!g_thread_local_key_created) {
138 return NULL;
139 }
140
141 void **pointers = pthread_getspecific(g_thread_local_key);
142 if (pointers == NULL) {
143 return NULL;
144 }
145 return pointers[index];
146 }
147
CRYPTO_set_thread_local(thread_local_data_t index,void * value,thread_local_destructor_t destructor)148 int CRYPTO_set_thread_local(thread_local_data_t index, void *value,
149 thread_local_destructor_t destructor) {
150 CRYPTO_once(&g_thread_local_init_once, thread_local_init);
151 if (!g_thread_local_key_created) {
152 destructor(value);
153 return 0;
154 }
155
156 void **pointers = pthread_getspecific(g_thread_local_key);
157 if (pointers == NULL) {
158 pointers = OPENSSL_malloc(sizeof(void *) * NUM_OPENSSL_THREAD_LOCALS);
159 if (pointers == NULL) {
160 destructor(value);
161 return 0;
162 }
163 OPENSSL_memset(pointers, 0, sizeof(void *) * NUM_OPENSSL_THREAD_LOCALS);
164 if (pthread_setspecific(g_thread_local_key, pointers) != 0) {
165 OPENSSL_free(pointers);
166 destructor(value);
167 return 0;
168 }
169 }
170
171 if (pthread_mutex_lock(&g_destructors_lock) != 0) {
172 destructor(value);
173 return 0;
174 }
175 g_destructors[index] = destructor;
176 pthread_mutex_unlock(&g_destructors_lock);
177
178 pointers[index] = value;
179 return 1;
180 }
181
182 #endif // OPENSSL_PTHREADS
183