1/*
2 * Copyright 2016-2018 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#include <openssl/crypto.h>
11#include "internal/cryptlib.h"
12
13#if defined(__sun)
14# include <atomic.h>
15#endif
16
17#if defined(OPENSSL_THREADS) && !defined(CRYPTO_TDEBUG) && !defined(OPENSSL_SYS_WINDOWS)
18
19# if defined(OPENSSL_SYS_UNIX)
20# include <sys/types.h>
21# include <unistd.h>
22#endif
23
24# ifdef PTHREAD_RWLOCK_INITIALIZER
25# define USE_RWLOCK
26# endif
27
28CRYPTO_RWLOCK *CRYPTO_THREAD_lock_new(void)
29{
30# ifdef USE_RWLOCK
31 CRYPTO_RWLOCK *lock;
32
33 if ((lock = OPENSSL_zalloc(sizeof(pthread_rwlock_t))) == NULL) {
34 /* Don't set error, to avoid recursion blowup. */
35 return NULL;
36 }
37
38 if (pthread_rwlock_init(lock, NULL) != 0) {
39 OPENSSL_free(lock);
40 return NULL;
41 }
42# else
43 pthread_mutexattr_t attr;
44 CRYPTO_RWLOCK *lock;
45
46 if ((lock = OPENSSL_zalloc(sizeof(pthread_mutex_t))) == NULL) {
47 /* Don't set error, to avoid recursion blowup. */
48 return NULL;
49 }
50
51 pthread_mutexattr_init(&attr);
52 pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
53
54 if (pthread_mutex_init(lock, &attr) != 0) {
55 pthread_mutexattr_destroy(&attr);
56 OPENSSL_free(lock);
57 return NULL;
58 }
59
60 pthread_mutexattr_destroy(&attr);
61# endif
62
63 return lock;
64}
65
66int CRYPTO_THREAD_read_lock(CRYPTO_RWLOCK *lock)
67{
68# ifdef USE_RWLOCK
69 if (pthread_rwlock_rdlock(lock) != 0)
70 return 0;
71# else
72 if (pthread_mutex_lock(lock) != 0)
73 return 0;
74# endif
75
76 return 1;
77}
78
79int CRYPTO_THREAD_write_lock(CRYPTO_RWLOCK *lock)
80{
81# ifdef USE_RWLOCK
82 if (pthread_rwlock_wrlock(lock) != 0)
83 return 0;
84# else
85 if (pthread_mutex_lock(lock) != 0)
86 return 0;
87# endif
88
89 return 1;
90}
91
92int CRYPTO_THREAD_unlock(CRYPTO_RWLOCK *lock)
93{
94# ifdef USE_RWLOCK
95 if (pthread_rwlock_unlock(lock) != 0)
96 return 0;
97# else
98 if (pthread_mutex_unlock(lock) != 0)
99 return 0;
100# endif
101
102 return 1;
103}
104
105void CRYPTO_THREAD_lock_free(CRYPTO_RWLOCK *lock)
106{
107 if (lock == NULL)
108 return;
109
110# ifdef USE_RWLOCK
111 pthread_rwlock_destroy(lock);
112# else
113 pthread_mutex_destroy(lock);
114# endif
115 OPENSSL_free(lock);
116
117 return;
118}
119
120int CRYPTO_THREAD_run_once(CRYPTO_ONCE *once, void (*init)(void))
121{
122 if (pthread_once(once, init) != 0)
123 return 0;
124
125 return 1;
126}
127
128int CRYPTO_THREAD_init_local(CRYPTO_THREAD_LOCAL *key, void (*cleanup)(void *))
129{
130 if (pthread_key_create(key, cleanup) != 0)
131 return 0;
132
133 return 1;
134}
135
136void *CRYPTO_THREAD_get_local(CRYPTO_THREAD_LOCAL *key)
137{
138 return pthread_getspecific(*key);
139}
140
141int CRYPTO_THREAD_set_local(CRYPTO_THREAD_LOCAL *key, void *val)
142{
143 if (pthread_setspecific(*key, val) != 0)
144 return 0;
145
146 return 1;
147}
148
149int CRYPTO_THREAD_cleanup_local(CRYPTO_THREAD_LOCAL *key)
150{
151 if (pthread_key_delete(*key) != 0)
152 return 0;
153
154 return 1;
155}
156
157CRYPTO_THREAD_ID CRYPTO_THREAD_get_current_id(void)
158{
159 return pthread_self();
160}
161
162int CRYPTO_THREAD_compare_id(CRYPTO_THREAD_ID a, CRYPTO_THREAD_ID b)
163{
164 return pthread_equal(a, b);
165}
166
167int CRYPTO_atomic_add(int *val, int amount, int *ret, CRYPTO_RWLOCK *lock)
168{
169# if defined(__GNUC__) && defined(__ATOMIC_ACQ_REL)
170 if (__atomic_is_lock_free(sizeof(*val), val)) {
171 *ret = __atomic_add_fetch(val, amount, __ATOMIC_ACQ_REL);
172 return 1;
173 }
174# elif defined(__sun) && (defined(__SunOS_5_10) || defined(__SunOS_5_11))
175 /* This will work for all future Solaris versions. */
176 if (ret != NULL) {
177 *ret = atomic_add_int_nv((volatile unsigned int *)val, amount);
178 return 1;
179 }
180# endif
181 if (!CRYPTO_THREAD_write_lock(lock))
182 return 0;
183
184 *val += amount;
185 *ret = *val;
186
187 if (!CRYPTO_THREAD_unlock(lock))
188 return 0;
189
190 return 1;
191}
192
193# ifndef FIPS_MODE
194/* TODO(3.0): No fork protection in FIPS module yet! */
195
196# ifdef OPENSSL_SYS_UNIX
197static pthread_once_t fork_once_control = PTHREAD_ONCE_INIT;
198
199static void fork_once_func(void)
200{
201 pthread_atfork(OPENSSL_fork_prepare,
202 OPENSSL_fork_parent, OPENSSL_fork_child);
203}
204# endif
205
206int openssl_init_fork_handlers(void)
207{
208# ifdef OPENSSL_SYS_UNIX
209 if (pthread_once(&fork_once_control, fork_once_func) == 0)
210 return 1;
211# endif
212 return 0;
213}
214# endif /* FIPS_MODE */
215
216int openssl_get_fork_id(void)
217{
218 return getpid();
219}
220#endif
221