1
2 /* Thread package.
3 This is intended to be usable independently from Python.
4 The implementation for system foobar is in a file thread_foobar.h
5 which is included by this file dependent on config settings.
6 Stuff shared by all thread_*.h files is collected here. */
7
8 #include "Python.h"
9
10
11 #ifndef _POSIX_THREADS
12 /* This means pthreads are not implemented in libc headers, hence the macro
13 not present in unistd.h. But they still can be implemented as an external
14 library (e.g. gnu pth in pthread emulation) */
15 # ifdef HAVE_PTHREAD_H
16 # include <pthread.h> /* _POSIX_THREADS */
17 # endif
18 #endif
19
20 #ifndef DONT_HAVE_STDIO_H
21 #include <stdio.h>
22 #endif
23
24 #include <stdlib.h>
25
26 #ifdef __sgi
27 #ifndef HAVE_PTHREAD_H /* XXX Need to check in configure.ac */
28 #undef _POSIX_THREADS
29 #endif
30 #endif
31
32 #include "pythread.h"
33
34 #ifndef _POSIX_THREADS
35
36 #ifdef __sgi
37 #define SGI_THREADS
38 #endif
39
40 #ifdef HAVE_THREAD_H
41 #define SOLARIS_THREADS
42 #endif
43
44 #if defined(sun) && !defined(SOLARIS_THREADS)
45 #define SUN_LWP
46 #endif
47
48 /* Check if we're running on HP-UX and _SC_THREADS is defined. If so, then
49 enough of the Posix threads package is implemented to support python
50 threads.
51
52 This is valid for HP-UX 11.23 running on an ia64 system. If needed, add
53 a check of __ia64 to verify that we're running on an ia64 system instead
54 of a pa-risc system.
55 */
56 #ifdef __hpux
57 #ifdef _SC_THREADS
58 #define _POSIX_THREADS
59 #endif
60 #endif
61
62 #endif /* _POSIX_THREADS */
63
64
65 #ifdef Py_DEBUG
66 static int thread_debug = 0;
67 #define dprintf(args) (void)((thread_debug & 1) && printf args)
68 #define d2printf(args) ((thread_debug & 8) && printf args)
69 #else
70 #define dprintf(args)
71 #define d2printf(args)
72 #endif
73
74 static int initialized;
75
76 static void PyThread__init_thread(void); /* Forward */
77
78 void
PyThread_init_thread(void)79 PyThread_init_thread(void)
80 {
81 #ifdef Py_DEBUG
82 char *p = Py_GETENV("PYTHONTHREADDEBUG");
83
84 if (p) {
85 if (*p)
86 thread_debug = atoi(p);
87 else
88 thread_debug = 1;
89 }
90 #endif /* Py_DEBUG */
91 if (initialized)
92 return;
93 initialized = 1;
94 dprintf(("PyThread_init_thread called\n"));
95 PyThread__init_thread();
96 }
97
98 /* Support for runtime thread stack size tuning.
99 A value of 0 means using the platform's default stack size
100 or the size specified by the THREAD_STACK_SIZE macro. */
101 static size_t _pythread_stacksize = 0;
102
103 #ifdef SGI_THREADS
104 #include "thread_sgi.h"
105 #endif
106
107 #ifdef SOLARIS_THREADS
108 #include "thread_solaris.h"
109 #endif
110
111 #ifdef SUN_LWP
112 #include "thread_lwp.h"
113 #endif
114
115 #ifdef HAVE_PTH
116 #include "thread_pth.h"
117 #undef _POSIX_THREADS
118 #endif
119
120 #ifdef _POSIX_THREADS
121 #include "thread_pthread.h"
122 #endif
123
124 #ifdef C_THREADS
125 #include "thread_cthread.h"
126 #endif
127
128 #ifdef NT_THREADS
129 #include "thread_nt.h"
130 #endif
131
132 #ifdef OS2_THREADS
133 #include "thread_os2.h"
134 #endif
135
136 #ifdef BEOS_THREADS
137 #include "thread_beos.h"
138 #endif
139
140 #ifdef PLAN9_THREADS
141 #include "thread_plan9.h"
142 #endif
143
144 #ifdef ATHEOS_THREADS
145 #include "thread_atheos.h"
146 #endif
147
148 /*
149 #ifdef FOOBAR_THREADS
150 #include "thread_foobar.h"
151 #endif
152 */
153
154 /* return the current thread stack size */
155 size_t
PyThread_get_stacksize(void)156 PyThread_get_stacksize(void)
157 {
158 return _pythread_stacksize;
159 }
160
161 /* Only platforms defining a THREAD_SET_STACKSIZE() macro
162 in thread_<platform>.h support changing the stack size.
163 Return 0 if stack size is valid,
164 -1 if stack size value is invalid,
165 -2 if setting stack size is not supported. */
166 int
PyThread_set_stacksize(size_t size)167 PyThread_set_stacksize(size_t size)
168 {
169 #if defined(THREAD_SET_STACKSIZE)
170 return THREAD_SET_STACKSIZE(size);
171 #else
172 return -2;
173 #endif
174 }
175
176 #ifndef Py_HAVE_NATIVE_TLS
177 /* If the platform has not supplied a platform specific
178 TLS implementation, provide our own.
179
180 This code stolen from "thread_sgi.h", where it was the only
181 implementation of an existing Python TLS API.
182 */
183 /* ------------------------------------------------------------------------
184 Per-thread data ("key") support.
185
186 Use PyThread_create_key() to create a new key. This is typically shared
187 across threads.
188
189 Use PyThread_set_key_value(thekey, value) to associate void* value with
190 thekey in the current thread. Each thread has a distinct mapping of thekey
191 to a void* value. Caution: if the current thread already has a mapping
192 for thekey, value is ignored.
193
194 Use PyThread_get_key_value(thekey) to retrieve the void* value associated
195 with thekey in the current thread. This returns NULL if no value is
196 associated with thekey in the current thread.
197
198 Use PyThread_delete_key_value(thekey) to forget the current thread's associated
199 value for thekey. PyThread_delete_key(thekey) forgets the values associated
200 with thekey across *all* threads.
201
202 While some of these functions have error-return values, none set any
203 Python exception.
204
205 None of the functions does memory management on behalf of the void* values.
206 You need to allocate and deallocate them yourself. If the void* values
207 happen to be PyObject*, these functions don't do refcount operations on
208 them either.
209
210 The GIL does not need to be held when calling these functions; they supply
211 their own locking. This isn't true of PyThread_create_key(), though (see
212 next paragraph).
213
214 There's a hidden assumption that PyThread_create_key() will be called before
215 any of the other functions are called. There's also a hidden assumption
216 that calls to PyThread_create_key() are serialized externally.
217 ------------------------------------------------------------------------ */
218
219 /* A singly-linked list of struct key objects remembers all the key->value
220 * associations. File static keyhead heads the list. keymutex is used
221 * to enforce exclusion internally.
222 */
223 struct key {
224 /* Next record in the list, or NULL if this is the last record. */
225 struct key *next;
226
227 /* The thread id, according to PyThread_get_thread_ident(). */
228 long id;
229
230 /* The key and its associated value. */
231 int key;
232 void *value;
233 };
234
235 static struct key *keyhead = NULL;
236 static PyThread_type_lock keymutex = NULL;
237 static int nkeys = 0; /* PyThread_create_key() hands out nkeys+1 next */
238
239 /* Internal helper.
240 * If the current thread has a mapping for key, the appropriate struct key*
241 * is returned. NB: value is ignored in this case!
242 * If there is no mapping for key in the current thread, then:
243 * If value is NULL, NULL is returned.
244 * Else a mapping of key to value is created for the current thread,
245 * and a pointer to a new struct key* is returned; except that if
246 * malloc() can't find room for a new struct key*, NULL is returned.
247 * So when value==NULL, this acts like a pure lookup routine, and when
248 * value!=NULL, this acts like dict.setdefault(), returning an existing
249 * mapping if one exists, else creating a new mapping.
250 *
251 * Caution: this used to be too clever, trying to hold keymutex only
252 * around the "p->next = keyhead; keyhead = p" pair. That allowed
253 * another thread to mutate the list, via key deletion, concurrent with
254 * find_key() crawling over the list. Hilarity ensued. For example, when
255 * the for-loop here does "p = p->next", p could end up pointing at a
256 * record that PyThread_delete_key_value() was concurrently free()'ing.
257 * That could lead to anything, from failing to find a key that exists, to
258 * segfaults. Now we lock the whole routine.
259 */
260 static struct key *
find_key(int key,void * value)261 find_key(int key, void *value)
262 {
263 struct key *p, *prev_p;
264 long id = PyThread_get_thread_ident();
265
266 if (!keymutex)
267 return NULL;
268 PyThread_acquire_lock(keymutex, 1);
269 prev_p = NULL;
270 for (p = keyhead; p != NULL; p = p->next) {
271 if (p->id == id && p->key == key)
272 goto Done;
273 /* Sanity check. These states should never happen but if
274 * they do we must abort. Otherwise we'll end up spinning
275 * in a tight loop with the lock held. A similar check is done
276 * in pystate.c tstate_delete_common(). */
277 if (p == prev_p)
278 Py_FatalError("tls find_key: small circular list(!)");
279 prev_p = p;
280 if (p->next == keyhead)
281 Py_FatalError("tls find_key: circular list(!)");
282 }
283 if (value == NULL) {
284 assert(p == NULL);
285 goto Done;
286 }
287 p = (struct key *)malloc(sizeof(struct key));
288 if (p != NULL) {
289 p->id = id;
290 p->key = key;
291 p->value = value;
292 p->next = keyhead;
293 keyhead = p;
294 }
295 Done:
296 PyThread_release_lock(keymutex);
297 return p;
298 }
299
300 /* Return a new key. This must be called before any other functions in
301 * this family, and callers must arrange to serialize calls to this
302 * function. No violations are detected.
303 */
304 int
PyThread_create_key(void)305 PyThread_create_key(void)
306 {
307 /* All parts of this function are wrong if it's called by multiple
308 * threads simultaneously.
309 */
310 if (keymutex == NULL)
311 keymutex = PyThread_allocate_lock();
312 return ++nkeys;
313 }
314
315 /* Forget the associations for key across *all* threads. */
316 void
PyThread_delete_key(int key)317 PyThread_delete_key(int key)
318 {
319 struct key *p, **q;
320
321 PyThread_acquire_lock(keymutex, 1);
322 q = &keyhead;
323 while ((p = *q) != NULL) {
324 if (p->key == key) {
325 *q = p->next;
326 free((void *)p);
327 /* NB This does *not* free p->value! */
328 }
329 else
330 q = &p->next;
331 }
332 PyThread_release_lock(keymutex);
333 }
334
335 /* Confusing: If the current thread has an association for key,
336 * value is ignored, and 0 is returned. Else an attempt is made to create
337 * an association of key to value for the current thread. 0 is returned
338 * if that succeeds, but -1 is returned if there's not enough memory
339 * to create the association. value must not be NULL.
340 */
341 int
PyThread_set_key_value(int key,void * value)342 PyThread_set_key_value(int key, void *value)
343 {
344 struct key *p;
345
346 assert(value != NULL);
347 p = find_key(key, value);
348 if (p == NULL)
349 return -1;
350 else
351 return 0;
352 }
353
354 /* Retrieve the value associated with key in the current thread, or NULL
355 * if the current thread doesn't have an association for key.
356 */
357 void *
PyThread_get_key_value(int key)358 PyThread_get_key_value(int key)
359 {
360 struct key *p = find_key(key, NULL);
361
362 if (p == NULL)
363 return NULL;
364 else
365 return p->value;
366 }
367
368 /* Forget the current thread's association for key, if any. */
369 void
PyThread_delete_key_value(int key)370 PyThread_delete_key_value(int key)
371 {
372 long id = PyThread_get_thread_ident();
373 struct key *p, **q;
374
375 PyThread_acquire_lock(keymutex, 1);
376 q = &keyhead;
377 while ((p = *q) != NULL) {
378 if (p->key == key && p->id == id) {
379 *q = p->next;
380 free((void *)p);
381 /* NB This does *not* free p->value! */
382 break;
383 }
384 else
385 q = &p->next;
386 }
387 PyThread_release_lock(keymutex);
388 }
389
390 /* Forget everything not associated with the current thread id.
391 * This function is called from PyOS_AfterFork(). It is necessary
392 * because other thread ids which were in use at the time of the fork
393 * may be reused for new threads created in the forked process.
394 */
395 void
PyThread_ReInitTLS(void)396 PyThread_ReInitTLS(void)
397 {
398 long id = PyThread_get_thread_ident();
399 struct key *p, **q;
400
401 if (!keymutex)
402 return;
403
404 /* As with interpreter_lock in PyEval_ReInitThreads()
405 we just create a new lock without freeing the old one */
406 keymutex = PyThread_allocate_lock();
407
408 /* Delete all keys which do not match the current thread id */
409 q = &keyhead;
410 while ((p = *q) != NULL) {
411 if (p->id != id) {
412 *q = p->next;
413 free((void *)p);
414 /* NB This does *not* free p->value! */
415 }
416 else
417 q = &p->next;
418 }
419 }
420
421 #endif /* Py_HAVE_NATIVE_TLS */
422