|
145
|
1 /* Copyright (C) 2002-2020 Free Software Foundation, Inc.
|
|
|
2 Contributed by Zack Weinberg <zack@codesourcery.com>
|
|
|
3
|
|
|
4 This file is part of GCC.
|
|
|
5
|
|
|
6 GCC is free software; you can redistribute it and/or modify it under
|
|
|
7 the terms of the GNU General Public License as published by the Free
|
|
|
8 Software Foundation; either version 3, or (at your option) any later
|
|
|
9 version.
|
|
|
10
|
|
|
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
14 for more details.
|
|
|
15
|
|
|
16 Under Section 7 of GPL version 3, you are granted additional
|
|
|
17 permissions described in the GCC Runtime Library Exception, version
|
|
|
18 3.1, as published by the Free Software Foundation.
|
|
|
19
|
|
|
20 You should have received a copy of the GNU General Public License and
|
|
|
21 a copy of the GCC Runtime Library Exception along with this program;
|
|
|
22 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
|
|
23 <http://www.gnu.org/licenses/>. */
|
|
|
24
|
|
|
25 /* Threads compatibility routines for libgcc2 for VxWorks.
|
|
|
26 These are out-of-line routines called from gthr-vxworks.h.
|
|
|
27
|
|
|
28 This file provides the TLS related support routines, calling specific
|
|
|
29 VxWorks kernel entry points for this purpose. */
|
|
|
30
|
|
|
31 #include "tconfig.h"
|
|
|
32 #include "tsystem.h"
|
|
|
33 #include "gthr.h"
|
|
|
34
|
|
|
35 #if defined(__GTHREADS)
|
|
|
36
|
|
|
37 #include <vxWorks.h>
|
|
|
38 #ifndef __RTP__
|
|
|
39 #include <vxLib.h>
|
|
|
40 #endif
|
|
|
41 #include <taskLib.h>
|
|
|
42 #ifndef __RTP__
|
|
|
43 #include <taskHookLib.h>
|
|
|
44 #else
|
|
|
45 #include <errno.h>
|
|
|
46 #endif
|
|
|
47
|
|
|
48 #include <_vxworks-versions.h>
|
|
|
49
|
|
|
50 /* Thread-local storage.
|
|
|
51
|
|
|
52 A gthread TLS key is simply an offset in an array, the address of which
|
|
|
53 we store in a single pointer field associated with the current task.
|
|
|
54
|
|
|
55 On VxWorks 7, we have direct support for __thread variables and use
|
|
|
56 such a variable as the pointer "field". On other versions, we resort
|
|
|
57 to __gthread_get_tls_data and __gthread_set_tls_data functions provided
|
|
|
58 by the kernel.
|
|
|
59
|
|
|
60 There is also a global array which records which keys are valid and
|
|
|
61 which have destructors.
|
|
|
62
|
|
|
63 A task delete hook is installed to execute key destructors. The routines
|
|
|
64 __gthread_enter_tls_dtor_context and __gthread_leave_tls_dtor_context,
|
|
|
65 which are also provided by the kernel, ensure that it is safe to call
|
|
|
66 free() on memory allocated by the task being deleted. This is a no-op on
|
|
|
67 VxWorks 5, but a major undertaking on AE.
|
|
|
68
|
|
|
69 The task delete hook is only installed when at least one thread
|
|
|
70 has TLS data. This is a necessary precaution, to allow this module
|
|
|
71 to be unloaded - a module with a hook can not be removed.
|
|
|
72
|
|
|
73 Since this interface is used to allocate only a small number of
|
|
|
74 keys, the table size is small and static, which simplifies the
|
|
|
75 code quite a bit. Revisit this if and when it becomes necessary. */
|
|
|
76
|
|
|
77 #define MAX_KEYS 4
|
|
|
78
|
|
|
79 /* This is the structure pointed to by the pointer returned
|
|
|
80 by __gthread_get_tls_data. */
|
|
|
81 struct tls_data
|
|
|
82 {
|
|
|
83 int *owner;
|
|
|
84 void *values[MAX_KEYS];
|
|
|
85 unsigned int generation[MAX_KEYS];
|
|
|
86 };
|
|
|
87
|
|
|
88 /* To make sure we only delete TLS data associated with this object,
|
|
|
89 include a pointer to a local variable in the TLS data object. */
|
|
|
90 static int self_owner;
|
|
|
91
|
|
|
92 /* Flag to check whether the delete hook is installed. Once installed
|
|
|
93 it is only removed when unloading this module. */
|
|
|
94 static volatile int delete_hook_installed;
|
|
|
95
|
|
|
96 /* TLS data access internal API. A straight __thread variable starting with
|
|
|
97 VxWorks 7, a pointer returned by kernel provided routines otherwise. */
|
|
|
98
|
|
|
99 #if _VXWORKS_MAJOR_GE(7)
|
|
|
100
|
|
|
101 static __thread struct tls_data *__gthread_tls_data;
|
|
|
102
|
|
|
103 #define VX_GET_TLS_DATA() __gthread_tls_data
|
|
|
104 #define VX_SET_TLS_DATA(x) __gthread_tls_data = (x)
|
|
|
105
|
|
|
106 #define VX_ENTER_TLS_DTOR()
|
|
|
107 #define VX_LEAVE_TLS_DTOR()
|
|
|
108
|
|
|
109 #else
|
|
|
110
|
|
|
111 extern void *__gthread_get_tls_data (void);
|
|
|
112 extern void __gthread_set_tls_data (void *data);
|
|
|
113
|
|
|
114 extern void __gthread_enter_tls_dtor_context (void);
|
|
|
115 extern void __gthread_leave_tls_dtor_context (void);
|
|
|
116
|
|
|
117 #define VX_GET_TLS_DATA() __gthread_get_tls_data()
|
|
|
118 #define VX_SET_TLS_DATA(x) __gthread_set_tls_data(x)
|
|
|
119
|
|
|
120 #define VX_ENTER_TLS_DTOR() __gthread_enter_tls_dtor_context ()
|
|
|
121 #define VX_LEAVE_TLS_DTOR() __gthread_leave_tls_dtor_context ()
|
|
|
122
|
|
|
123 #endif
|
|
|
124
|
|
|
125 /* This is a global structure which records all of the active keys.
|
|
|
126
|
|
|
127 A key is potentially valid (i.e. has been handed out by
|
|
|
128 __gthread_key_create) iff its generation count in this structure is
|
|
|
129 even. In that case, the matching entry in the dtors array is a
|
|
|
130 routine to be called when a thread terminates with a valid,
|
|
|
131 non-NULL specific value for that key.
|
|
|
132
|
|
|
133 A key is actually valid in a thread T iff the generation count
|
|
|
134 stored in this structure is equal to the generation count stored in
|
|
|
135 T's specific-value structure. */
|
|
|
136
|
|
|
137 typedef void (*tls_dtor) (void *);
|
|
|
138
|
|
|
139 struct tls_keys
|
|
|
140 {
|
|
|
141 tls_dtor dtor[MAX_KEYS];
|
|
|
142 unsigned int generation[MAX_KEYS];
|
|
|
143 };
|
|
|
144
|
|
|
145 #define KEY_VALID_P(key) !(tls_keys.generation[key] & 1)
|
|
|
146
|
|
|
147 /* Note: if MAX_KEYS is increased, this initializer must be updated
|
|
|
148 to match. All the generation counts begin at 1, which means no
|
|
|
149 key is valid. */
|
|
|
150 static struct tls_keys tls_keys =
|
|
|
151 {
|
|
|
152 { NULL, NULL, NULL, NULL },
|
|
|
153 { 1, 1, 1, 1 }
|
|
|
154 };
|
|
|
155
|
|
|
156 /* This lock protects the tls_keys structure. */
|
|
|
157 static __gthread_mutex_t tls_lock;
|
|
|
158
|
|
|
159 static __gthread_once_t tls_init_guard = __GTHREAD_ONCE_INIT;
|
|
|
160
|
|
|
161 /* Internal routines. */
|
|
|
162
|
|
|
163 /* The task TCB has just been deleted. Call the destructor
|
|
|
164 function for each TLS key that has both a destructor and
|
|
|
165 a non-NULL specific value in this thread.
|
|
|
166
|
|
|
167 This routine does not need to take tls_lock; the generation
|
|
|
168 count protects us from calling a stale destructor. It does
|
|
|
169 need to read tls_keys.dtor[key] atomically. */
|
|
|
170
|
|
|
171 void
|
|
|
172 tls_delete_hook (void *tcb ATTRIBUTE_UNUSED)
|
|
|
173 {
|
|
|
174 struct tls_data *data;
|
|
|
175 __gthread_key_t key;
|
|
|
176
|
|
|
177 data = VX_GET_TLS_DATA();
|
|
|
178
|
|
|
179 if (data && data->owner == &self_owner)
|
|
|
180 {
|
|
|
181 VX_ENTER_TLS_DTOR();
|
|
|
182 for (key = 0; key < MAX_KEYS; key++)
|
|
|
183 {
|
|
|
184 if (data->generation[key] == tls_keys.generation[key])
|
|
|
185 {
|
|
|
186 tls_dtor dtor = tls_keys.dtor[key];
|
|
|
187
|
|
|
188 if (dtor)
|
|
|
189 dtor (data->values[key]);
|
|
|
190 }
|
|
|
191 }
|
|
|
192 free (data);
|
|
|
193
|
|
|
194 VX_LEAVE_TLS_DTOR();
|
|
|
195 VX_SET_TLS_DATA(NULL);
|
|
|
196 }
|
|
|
197 }
|
|
|
198
|
|
|
199 /* Initialize global data used by the TLS system. */
|
|
|
200 static void
|
|
|
201 tls_init (void)
|
|
|
202 {
|
|
|
203 __GTHREAD_MUTEX_INIT_FUNCTION (&tls_lock);
|
|
|
204 }
|
|
|
205
|
|
|
206 static void tls_destructor (void) __attribute__ ((destructor));
|
|
|
207 static void
|
|
|
208 tls_destructor (void)
|
|
|
209 {
|
|
|
210 #ifdef __RTP__
|
|
|
211 /* All threads but this one should have exited by now. */
|
|
|
212 tls_delete_hook (NULL);
|
|
|
213 #endif
|
|
|
214 /* Unregister the hook. */
|
|
|
215 if (delete_hook_installed)
|
|
|
216 taskDeleteHookDelete ((FUNCPTR)tls_delete_hook);
|
|
|
217
|
|
|
218 if (tls_init_guard.done && __gthread_mutex_lock (&tls_lock) != ERROR)
|
|
|
219 semDelete (tls_lock);
|
|
|
220 }
|
|
|
221
|
|
|
222 /* External interface */
|
|
|
223
|
|
|
224 /* Store in KEYP a value which can be passed to __gthread_setspecific/
|
|
|
225 __gthread_getspecific to store and retrieve a value which is
|
|
|
226 specific to each calling thread. If DTOR is not NULL, it will be
|
|
|
227 called when a thread terminates with a non-NULL specific value for
|
|
|
228 this key, with the value as its sole argument. */
|
|
|
229
|
|
|
230 int
|
|
|
231 __gthread_key_create (__gthread_key_t *keyp, tls_dtor dtor)
|
|
|
232 {
|
|
|
233 __gthread_key_t key;
|
|
|
234
|
|
|
235 __gthread_once (&tls_init_guard, tls_init);
|
|
|
236
|
|
|
237 if (__gthread_mutex_lock (&tls_lock) == ERROR)
|
|
|
238 return errno;
|
|
|
239
|
|
|
240 for (key = 0; key < MAX_KEYS; key++)
|
|
|
241 if (!KEY_VALID_P (key))
|
|
|
242 goto found_slot;
|
|
|
243
|
|
|
244 /* no room */
|
|
|
245 __gthread_mutex_unlock (&tls_lock);
|
|
|
246 return EAGAIN;
|
|
|
247
|
|
|
248 found_slot:
|
|
|
249 tls_keys.generation[key]++; /* making it even */
|
|
|
250 tls_keys.dtor[key] = dtor;
|
|
|
251 *keyp = key;
|
|
|
252 __gthread_mutex_unlock (&tls_lock);
|
|
|
253 return 0;
|
|
|
254 }
|
|
|
255
|
|
|
256 /* Invalidate KEY; it can no longer be used as an argument to
|
|
|
257 setspecific/getspecific. Note that this does NOT call destructor
|
|
|
258 functions for any live values for this key. */
|
|
|
259 int
|
|
|
260 __gthread_key_delete (__gthread_key_t key)
|
|
|
261 {
|
|
|
262 if (key >= MAX_KEYS)
|
|
|
263 return EINVAL;
|
|
|
264
|
|
|
265 __gthread_once (&tls_init_guard, tls_init);
|
|
|
266
|
|
|
267 if (__gthread_mutex_lock (&tls_lock) == ERROR)
|
|
|
268 return errno;
|
|
|
269
|
|
|
270 if (!KEY_VALID_P (key))
|
|
|
271 {
|
|
|
272 __gthread_mutex_unlock (&tls_lock);
|
|
|
273 return EINVAL;
|
|
|
274 }
|
|
|
275
|
|
|
276 tls_keys.generation[key]++; /* making it odd */
|
|
|
277 tls_keys.dtor[key] = 0;
|
|
|
278
|
|
|
279 __gthread_mutex_unlock (&tls_lock);
|
|
|
280 return 0;
|
|
|
281 }
|
|
|
282
|
|
|
283 /* Retrieve the thread-specific value for KEY. If it has never been
|
|
|
284 set in this thread, or KEY is invalid, returns NULL.
|
|
|
285
|
|
|
286 It does not matter if this function races with key_create or
|
|
|
287 key_delete; the worst that can happen is you get a value other than
|
|
|
288 the one that a serialized implementation would have provided. */
|
|
|
289
|
|
|
290 void *
|
|
|
291 __gthread_getspecific (__gthread_key_t key)
|
|
|
292 {
|
|
|
293 struct tls_data *data;
|
|
|
294
|
|
|
295 if (key >= MAX_KEYS)
|
|
|
296 return 0;
|
|
|
297
|
|
|
298 data = VX_GET_TLS_DATA();
|
|
|
299
|
|
|
300 if (!data)
|
|
|
301 return 0;
|
|
|
302
|
|
|
303 if (data->generation[key] != tls_keys.generation[key])
|
|
|
304 return 0;
|
|
|
305
|
|
|
306 return data->values[key];
|
|
|
307 }
|
|
|
308
|
|
|
309 /* Set the thread-specific value for KEY. If KEY is invalid, or
|
|
|
310 memory allocation fails, returns -1, otherwise 0.
|
|
|
311
|
|
|
312 The generation count protects this function against races with
|
|
|
313 key_create/key_delete; the worst thing that can happen is that a
|
|
|
314 value is successfully stored into a dead generation (and then
|
|
|
315 immediately becomes invalid). However, we do have to make sure
|
|
|
316 to read tls_keys.generation[key] atomically. */
|
|
|
317
|
|
|
318 int
|
|
|
319 __gthread_setspecific (__gthread_key_t key, void *value)
|
|
|
320 {
|
|
|
321 struct tls_data *data;
|
|
|
322 unsigned int generation;
|
|
|
323
|
|
|
324 if (key >= MAX_KEYS)
|
|
|
325 return EINVAL;
|
|
|
326
|
|
|
327 data = VX_GET_TLS_DATA();
|
|
|
328
|
|
|
329 if (!data)
|
|
|
330 {
|
|
|
331 if (!delete_hook_installed)
|
|
|
332 {
|
|
|
333 /* Install the delete hook. */
|
|
|
334 if (__gthread_mutex_lock (&tls_lock) == ERROR)
|
|
|
335 return ENOMEM;
|
|
|
336 if (!delete_hook_installed)
|
|
|
337 {
|
|
|
338 taskDeleteHookAdd ((FUNCPTR)tls_delete_hook);
|
|
|
339 delete_hook_installed = 1;
|
|
|
340 }
|
|
|
341 __gthread_mutex_unlock (&tls_lock);
|
|
|
342 }
|
|
|
343
|
|
|
344 data = malloc (sizeof (struct tls_data));
|
|
|
345 if (!data)
|
|
|
346 return ENOMEM;
|
|
|
347
|
|
|
348 memset (data, 0, sizeof (struct tls_data));
|
|
|
349 data->owner = &self_owner;
|
|
|
350
|
|
|
351 VX_SET_TLS_DATA(data);
|
|
|
352 }
|
|
|
353
|
|
|
354 generation = tls_keys.generation[key];
|
|
|
355
|
|
|
356 if (generation & 1)
|
|
|
357 return EINVAL;
|
|
|
358
|
|
|
359 data->generation[key] = generation;
|
|
|
360 data->values[key] = value;
|
|
|
361
|
|
|
362 return 0;
|
|
|
363 }
|
|
|
364 #endif /* __GTHREADS */
|
