1/*
2 * Copyright 2016-2022 The OpenSSL Project Authors. All Rights Reserved.
3 *
4 * Licensed under the Apache License 2.0 (the "License").  You may not use
5 * this file except in compliance with the License.  You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
8 */
9
10/* We need to use the OPENSSL_fork_*() deprecated APIs */
11#define OPENSSL_SUPPRESS_DEPRECATED
12
13#include <openssl/crypto.h>
14#include "internal/cryptlib.h"
15
16#if defined(__sun)
17# include <atomic.h>
18#endif
19
20#if defined(__apple_build_version__) && __apple_build_version__ < 6000000
21/*
22 * OS/X 10.7 and 10.8 had a weird version of clang which has __ATOMIC_ACQUIRE and
23 * __ATOMIC_ACQ_REL but which expects only one parameter for __atomic_is_lock_free()
24 * rather than two which has signature __atomic_is_lock_free(sizeof(_Atomic(T))).
25 * All of this makes impossible to use __atomic_is_lock_free here.
26 *
27 * See: https://github.com/llvm/llvm-project/commit/a4c2602b714e6c6edb98164550a5ae829b2de760
28 */
29#define BROKEN_CLANG_ATOMICS
30#endif
31
32#if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG) && !defined(OPENSSL_SYS_WINDOWS)
33
34# if defined(OPENSSL_SYS_UNIX)
35#  include <sys/types.h>
36#  include <unistd.h>
37#endif
38
39# include <assert.h>
40
41# ifdef PTHREAD_RWLOCK_INITIALIZER
42#  define USE_RWLOCK
43# endif
44
45CRYPTO_RWLOCK *CRYPTO_THREAD_lock_new(void)
46{
47# ifdef USE_RWLOCK
48    CRYPTO_RWLOCK *lock;
49
50    if ((lock = OPENSSL_zalloc(sizeof(pthread_rwlock_t))) == NULL) {
51        /* Don't set error, to avoid recursion blowup. */
52        return NULL;
53    }
54
55    if (pthread_rwlock_init(lock, NULL) != 0) {
56        OPENSSL_free(lock);
57        return NULL;
58    }
59# else
60    pthread_mutexattr_t attr;
61    CRYPTO_RWLOCK *lock;
62
63    if ((lock = OPENSSL_zalloc(sizeof(pthread_mutex_t))) == NULL) {
64        /* Don't set error, to avoid recursion blowup. */
65        return NULL;
66    }
67
68    /*
69     * We don't use recursive mutexes, but try to catch errors if we do.
70     */
71    pthread_mutexattr_init(&attr);
72#  if !defined (__TANDEM) && !defined (_SPT_MODEL_)
73#   if !defined(NDEBUG) && !defined(OPENSSL_NO_MUTEX_ERRORCHECK)
74    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);
75#   else
76    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
77#   endif
78#  else
79    /* The SPT Thread Library does not define MUTEX attributes. */
80#  endif
81
82    if (pthread_mutex_init(lock, &attr) != 0) {
83        pthread_mutexattr_destroy(&attr);
84        OPENSSL_free(lock);
85        return NULL;
86    }
87
88    pthread_mutexattr_destroy(&attr);
89# endif
90
91    return lock;
92}
93
94__owur int CRYPTO_THREAD_read_lock(CRYPTO_RWLOCK *lock)
95{
96# ifdef USE_RWLOCK
97    if (pthread_rwlock_rdlock(lock) != 0)
98        return 0;
99# else
100    if (pthread_mutex_lock(lock) != 0) {
101        assert(errno != EDEADLK && errno != EBUSY);
102        return 0;
103    }
104# endif
105
106    return 1;
107}
108
109__owur int CRYPTO_THREAD_write_lock(CRYPTO_RWLOCK *lock)
110{
111# ifdef USE_RWLOCK
112    if (pthread_rwlock_wrlock(lock) != 0)
113        return 0;
114# else
115    if (pthread_mutex_lock(lock) != 0) {
116        assert(errno != EDEADLK && errno != EBUSY);
117        return 0;
118    }
119# endif
120
121    return 1;
122}
123
124int CRYPTO_THREAD_unlock(CRYPTO_RWLOCK *lock)
125{
126# ifdef USE_RWLOCK
127    if (pthread_rwlock_unlock(lock) != 0)
128        return 0;
129# else
130    if (pthread_mutex_unlock(lock) != 0) {
131        assert(errno != EPERM);
132        return 0;
133    }
134# endif
135
136    return 1;
137}
138
139void CRYPTO_THREAD_lock_free(CRYPTO_RWLOCK *lock)
140{
141    if (lock == NULL)
142        return;
143
144# ifdef USE_RWLOCK
145    pthread_rwlock_destroy(lock);
146# else
147    pthread_mutex_destroy(lock);
148# endif
149    OPENSSL_free(lock);
150
151    return;
152}
153
154int CRYPTO_THREAD_run_once(CRYPTO_ONCE *once, void (*init)(void))
155{
156    if (pthread_once(once, init) != 0)
157        return 0;
158
159    return 1;
160}
161
162int CRYPTO_THREAD_init_local(CRYPTO_THREAD_LOCAL *key, void (*cleanup)(void *))
163{
164    if (pthread_key_create(key, cleanup) != 0)
165        return 0;
166
167    return 1;
168}
169
170void *CRYPTO_THREAD_get_local(CRYPTO_THREAD_LOCAL *key)
171{
172    return pthread_getspecific(*key);
173}
174
175int CRYPTO_THREAD_set_local(CRYPTO_THREAD_LOCAL *key, void *val)
176{
177    if (pthread_setspecific(*key, val) != 0)
178        return 0;
179
180    return 1;
181}
182
183int CRYPTO_THREAD_cleanup_local(CRYPTO_THREAD_LOCAL *key)
184{
185    if (pthread_key_delete(*key) != 0)
186        return 0;
187
188    return 1;
189}
190
191CRYPTO_THREAD_ID CRYPTO_THREAD_get_current_id(void)
192{
193    return pthread_self();
194}
195
196int CRYPTO_THREAD_compare_id(CRYPTO_THREAD_ID a, CRYPTO_THREAD_ID b)
197{
198    return pthread_equal(a, b);
199}
200
201int CRYPTO_atomic_add(int *val, int amount, int *ret, CRYPTO_RWLOCK *lock)
202{
203# if defined(__GNUC__) && defined(__ATOMIC_ACQ_REL) && !defined(BROKEN_CLANG_ATOMICS)
204    if (__atomic_is_lock_free(sizeof(*val), val)) {
205        *ret = __atomic_add_fetch(val, amount, __ATOMIC_ACQ_REL);
206        return 1;
207    }
208# elif defined(__sun) && (defined(__SunOS_5_10) || defined(__SunOS_5_11))
209    /* This will work for all future Solaris versions. */
210    if (ret != NULL) {
211        *ret = atomic_add_int_nv((volatile unsigned int *)val, amount);
212        return 1;
213    }
214# endif
215    if (lock == NULL || !CRYPTO_THREAD_write_lock(lock))
216        return 0;
217
218    *val += amount;
219    *ret  = *val;
220
221    if (!CRYPTO_THREAD_unlock(lock))
222        return 0;
223
224    return 1;
225}
226
227int CRYPTO_atomic_or(uint64_t *val, uint64_t op, uint64_t *ret,
228                     CRYPTO_RWLOCK *lock)
229{
230# if defined(__GNUC__) && defined(__ATOMIC_ACQ_REL) && !defined(BROKEN_CLANG_ATOMICS)
231    if (__atomic_is_lock_free(sizeof(*val), val)) {
232        *ret = __atomic_or_fetch(val, op, __ATOMIC_ACQ_REL);
233        return 1;
234    }
235# elif defined(__sun) && (defined(__SunOS_5_10) || defined(__SunOS_5_11))
236    /* This will work for all future Solaris versions. */
237    if (ret != NULL) {
238        *ret = atomic_or_64_nv(val, op);
239        return 1;
240    }
241# endif
242    if (lock == NULL || !CRYPTO_THREAD_write_lock(lock))
243        return 0;
244    *val |= op;
245    *ret  = *val;
246
247    if (!CRYPTO_THREAD_unlock(lock))
248        return 0;
249
250    return 1;
251}
252
253int CRYPTO_atomic_load(uint64_t *val, uint64_t *ret, CRYPTO_RWLOCK *lock)
254{
255# if defined(__GNUC__) && defined(__ATOMIC_ACQUIRE) && !defined(BROKEN_CLANG_ATOMICS)
256    if (__atomic_is_lock_free(sizeof(*val), val)) {
257        __atomic_load(val, ret, __ATOMIC_ACQUIRE);
258        return 1;
259    }
260# elif defined(__sun) && (defined(__SunOS_5_10) || defined(__SunOS_5_11))
261    /* This will work for all future Solaris versions. */
262    if (ret != NULL) {
263        *ret = atomic_or_64_nv(val, 0);
264        return 1;
265    }
266# endif
267    if (lock == NULL || !CRYPTO_THREAD_read_lock(lock))
268        return 0;
269    *ret  = *val;
270    if (!CRYPTO_THREAD_unlock(lock))
271        return 0;
272
273    return 1;
274}
275# ifndef FIPS_MODULE
276int openssl_init_fork_handlers(void)
277{
278    return 1;
279}
280# endif /* FIPS_MODULE */
281
282int openssl_get_fork_id(void)
283{
284    return getpid();
285}
286#endif
287