• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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