Debian Codegraph @

lib/base/dll.c

raw
1 /***********************************************************************
2 * Copyright (c) 2016 Kungliga Tekniska Högskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
20 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
21 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
22 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
24 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
26 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
28 * OF THE POSSIBILITY OF SUCH DAMAGE.
29 *
30 **********************************************************************/
31
32 /*
33 * This is an implementation of thread-specific storage with
34 * destructors. WIN32 doesn't quite have this. Instead it has
35 * DllMain(), an entry point in every DLL that gets called to notify the
36 * DLL of thread/process "attach"/"detach" events.
37 *
38 * We use __thread (or __declspec(thread)) for the thread-local itself
39 * and DllMain() DLL_THREAD_DETACH events to drive destruction of
40 * thread-local values.
41 *
42 * When building in maintainer mode on non-Windows pthread systems this
43 * uses a single pthread key instead to implement multiple keys. This
44 * keeps the code from rotting when modified by non-Windows developers.
45 */
46
47 #include "baselocl.h"
48
49 #ifdef WIN32
50 #include <windows.h>
51 #endif
52
53 #ifdef HEIM_WIN32_TLS
54 #include <assert.h>
55 #include <err.h>
56 #include <heim_threads.h>
57
58 #ifndef WIN32
59 #include <pthread.h>
60 #endif
61
62 /* Logical array of keys that grows lock-lessly */
63 typedef struct tls_keys tls_keys;
64 struct tls_keys {
65 void (**keys_dtors)(void *); /* array of destructors */
66 size_t keys_start_idx; /* index of first destructor */
67 size_t keys_num;
68 tls_keys *keys_next;
69 };
70
71 /*
72 * Well, not quite locklessly. We need synchronization primitives to do
73 * this locklessly. An atomic CAS will do.
74 */
75 static HEIMDAL_MUTEX tls_key_defs_lock = HEIMDAL_MUTEX_INITIALIZER;
76 static tls_keys *tls_key_defs;
77
78 /* Logical array of values (per-thread; no locking needed here) */
79 struct tls_values {
80 void **values; /* realloc()ed */
81 size_t values_num;
82 };
83
84 static HEIMDAL_THREAD_LOCAL struct tls_values values;
85
86 static char dead_key[1];
87 static void no_dtor(void *d) { (void)d; }
88
89 void
90 heim_w32_service_thread_detach(void *unused)
91 {
92 tls_keys *key_defs;
93 void (*dtor)(void*);
94 size_t i;
95
96 HEIMDAL_MUTEX_lock(&tls_key_defs_lock);
97 key_defs = tls_key_defs;
98 HEIMDAL_MUTEX_unlock(&tls_key_defs_lock);
99
100 if (key_defs == NULL)
101 return;
102
103 for (i = 0; i < values.values_num; i++) {
104 assert(i >= key_defs->keys_start_idx);
105 if (i >= key_defs->keys_start_idx + key_defs->keys_num) {
106 HEIMDAL_MUTEX_lock(&tls_key_defs_lock);
107 key_defs = key_defs->keys_next;
108 HEIMDAL_MUTEX_unlock(&tls_key_defs_lock);
109
110 assert(key_defs != NULL);
111 assert(i >= key_defs->keys_start_idx);
112 assert(i < key_defs->keys_start_idx + key_defs->keys_num);
113 }
114 dtor = key_defs->keys_dtors[i - key_defs->keys_start_idx];
115 if (values.values[i] != NULL && dtor != NULL && dtor != no_dtor)
116 dtor(values.values[i]);
117 values.values[i] = NULL;
118 }
119 }
120
121 #if !defined(WIN32)
122 static pthread_key_t pt_key;
123 pthread_once_t pt_once = PTHREAD_ONCE_INIT;
124
125 static void
126 atexit_del_tls_for_thread(void)
127 {
128 heim_w32_service_thread_detach(NULL);
129 }
130
131 static void
132 create_pt_key(void)
133 {
134 int ret;
135
136 /* The main thread may not execute TLS destructors */
137 atexit(atexit_del_tls_for_thread);
138 ret = pthread_key_create(&pt_key, heim_w32_service_thread_detach);
139 if (ret != 0)
140 err(1, "pthread_key_create() failed");
141 }
142
143 #endif
144
145 int
146 heim_w32_key_create(HEIM_PRIV_thread_key *key, void (*dtor)(void *))
147 {
148 tls_keys *key_defs, *new_key_defs;
149 size_t i, k;
150 int ret = ENOMEM;
151
152 #if !defined(WIN32)
153 (void) pthread_once(&pt_once, create_pt_key);
154 (void) pthread_setspecific(pt_key, dead_key);
155 #endif
156
157 HEIMDAL_MUTEX_lock(&tls_key_defs_lock);
158 if (tls_key_defs == NULL) {
159 /* First key */
160 new_key_defs = calloc(1, sizeof(*new_key_defs));
161 if (new_key_defs == NULL) {
162 HEIMDAL_MUTEX_unlock(&tls_key_defs_lock);
163 return ENOMEM;
164 }
165 new_key_defs->keys_num = 8;
166 new_key_defs->keys_dtors = calloc(new_key_defs->keys_num,
167 sizeof(*new_key_defs->keys_dtors));
168 if (new_key_defs->keys_dtors == NULL) {
169 HEIMDAL_MUTEX_unlock(&tls_key_defs_lock);
170 free(new_key_defs);
171 return ENOMEM;
172 }
173 tls_key_defs = new_key_defs;
174 new_key_defs->keys_dtors[0] = dtor;
175 for (i = 1; i < new_key_defs->keys_num; i++)
176 new_key_defs->keys_dtors[i] = NULL;
177 HEIMDAL_MUTEX_unlock(&tls_key_defs_lock);
178 return 0;
179 }
180
181 for (key_defs = tls_key_defs;
182 key_defs != NULL;
183 key_defs = key_defs->keys_next) {
184 k = key_defs->keys_start_idx;
185 for (i = 0; i < key_defs->keys_num; i++, k++) {
186 if (key_defs->keys_dtors[i] == NULL) {
187 /* Found free slot; use it */
188 key_defs->keys_dtors[i] = dtor;
189 *key = k;
190 HEIMDAL_MUTEX_unlock(&tls_key_defs_lock);
191 return 0;
192 }
193 }
194 if (key_defs->keys_next != NULL)
195 continue;
196
197 /* Grow the registration array */
198 /* XXX DRY */
199 new_key_defs = calloc(1, sizeof(*new_key_defs));
200 if (new_key_defs == NULL)
201 break;
202
203 new_key_defs->keys_dtors =
204 calloc(key_defs->keys_num + key_defs->keys_num / 2,
205 sizeof(*new_key_defs->keys_dtors));
206 if (new_key_defs->keys_dtors == NULL) {
207 free(new_key_defs);
208 break;
209 }
210 new_key_defs->keys_start_idx = key_defs->keys_start_idx +
211 key_defs->keys_num;
212 new_key_defs->keys_num = key_defs->keys_num + key_defs->keys_num / 2;
213 new_key_defs->keys_dtors[i] = dtor;
214 for (i = 1; i < new_key_defs->keys_num; i++)
215 new_key_defs->keys_dtors[i] = NULL;
216 key_defs->keys_next = new_key_defs;
217 ret = 0;
218 break;
219 }
220 HEIMDAL_MUTEX_unlock(&tls_key_defs_lock);
221 return ret;
222 }
223
224 static void
225 key_lookup(HEIM_PRIV_thread_key key, tls_keys **kd,
226 size_t *dtor_idx, void (**dtor)(void *))
227 {
228 tls_keys *key_defs;
229
230 if (kd != NULL)
231 *kd = NULL;
232 if (dtor_idx != NULL)
233 *dtor_idx = 0;
234 if (dtor != NULL)
235 *dtor = NULL;
236
237 HEIMDAL_MUTEX_lock(&tls_key_defs_lock);
238 key_defs = tls_key_defs;
239 HEIMDAL_MUTEX_unlock(&tls_key_defs_lock);
240
241 while (key_defs != NULL) {
242 if (key >= key_defs->keys_start_idx &&
243 key < key_defs->keys_start_idx + key_defs->keys_num) {
244 if (kd != NULL)
245 *kd = key_defs;
246 if (dtor_idx != NULL)
247 *dtor_idx = key - key_defs->keys_start_idx;
248 if (dtor != NULL)
249 *dtor = key_defs->keys_dtors[key - key_defs->keys_start_idx];
250 return;
251 }
252
253 HEIMDAL_MUTEX_lock(&tls_key_defs_lock);
254 key_defs = key_defs->keys_next;
255 HEIMDAL_MUTEX_unlock(&tls_key_defs_lock);
256 assert(key_defs != NULL);
257 assert(key >= key_defs->keys_start_idx);
258 }
259 }
260
261 int
262 heim_w32_delete_key(HEIM_PRIV_thread_key key)
263 {
264 tls_keys *key_defs;
265 size_t dtor_idx;
266
267 key_lookup(key, &key_defs, &dtor_idx, NULL);
268 if (key_defs == NULL)
269 return EINVAL;
270 key_defs->keys_dtors[dtor_idx] = no_dtor;
271 return 0;
272 }
273
274 int
275 heim_w32_setspecific(HEIM_PRIV_thread_key key, void *value)
276 {
277 void **new_values;
278 size_t new_num;
279 void (*dtor)(void *);
280 size_t i;
281
282 #if !defined(WIN32)
283 (void) pthread_setspecific(pt_key, dead_key);
284 #endif
285
286 key_lookup(key, NULL, NULL, &dtor);
287 if (dtor == NULL)
288 return EINVAL;
289
290 if (key >= values.values_num) {
291 if (values.values_num == 0) {
292 values.values = NULL;
293 new_num = 8;
294 } else {
295 new_num = (values.values_num + values.values_num / 2);
296 }
297 new_values = realloc(values.values, sizeof(void *) * new_num);
298 if (new_values == NULL)
299 return ENOMEM;
300 for (i = values.values_num; i < new_num; i++)
301 new_values[i] = NULL;
302 values.values = new_values;
303 values.values_num = new_num;
304 }
305
306 assert(key < values.values_num);
307
308 if (values.values[key] != NULL && dtor != NULL && dtor != no_dtor)
309 dtor(values.values[key]);
310
311 values.values[key] = value;
312 return 0;
313 }
314
315 void *
316 heim_w32_getspecific(HEIM_PRIV_thread_key key)
317 {
318 if (key >= values.values_num)
319 return NULL;
320 return values.values[key];
321 }
322
323 #else
324 static char dummy;
325 #endif /* HEIM_WIN32_TLS */