Python/thread.c

   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.in */
  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 implimented 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 a 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
  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 PLAN9_THREADS
 137 #include "thread_plan9.h"
 138 #endif
 139
 140 #ifdef ATHEOS_THREADS
 141 #include "thread_atheos.h"
 142 #endif
 143
 144 /*
 145 #ifdef FOOBAR_THREADS
 146 #include "thread_foobar.h"
 147 #endif
 148 */
 149
 150 /* return the current thread stack size */
 151 size_t
 152 PyThread_get_stacksize(void)
 153 {
 154     return _pythread_stacksize;
 155 }
 156
 157 /* Only platforms defining a THREAD_SET_STACKSIZE() macro
 158    in thread_<platform>.h support changing the stack size.
 159    Return 0 if stack size is valid,
 160       -1 if stack size value is invalid,
 161       -2 if setting stack size is not supported. */
 162 int
 163 PyThread_set_stacksize(size_t size)
 164 {
 165 #if defined(THREAD_SET_STACKSIZE)
 166     return THREAD_SET_STACKSIZE(size);
 167 #else
 168     return -2;
 169 #endif
 170 }
 171
 172 #ifndef Py_HAVE_NATIVE_TLS
 173 /* If the platform has not supplied a platform specific
 174    TLS implementation, provide our own.
 175
 176    This code stolen from "thread_sgi.h", where it was the only
 177    implementation of an existing Python TLS API.
 178 */
 179 /* ------------------------------------------------------------------------
 180 Per-thread data ("key") support.
 181
 182 Use PyThread_create_key() to create a new key.  This is typically shared
 183 across threads.
 184
 185 Use PyThread_set_key_value(thekey, value) to associate void* value with
 186 thekey in the current thread.  Each thread has a distinct mapping of thekey
 187 to a void* value.  Caution:  if the current thread already has a mapping
 188 for thekey, value is ignored.
 189
 190 Use PyThread_get_key_value(thekey) to retrieve the void* value associated
 191 with thekey in the current thread.  This returns NULL if no value is
 192 associated with thekey in the current thread.
 193
 194 Use PyThread_delete_key_value(thekey) to forget the current thread's associated
 195 value for thekey.  PyThread_delete_key(thekey) forgets the values associated
 196 with thekey across *all* threads.
 197
 198 While some of these functions have error-return values, none set any
 199 Python exception.
 200
 201 None of the functions does memory management on behalf of the void* values.
 202 You need to allocate and deallocate them yourself.  If the void* values
 203 happen to be PyObject*, these functions don't do refcount operations on
 204 them either.
 205
 206 The GIL does not need to be held when calling these functions; they supply
 207 their own locking.  This isn't true of PyThread_create_key(), though (see
 208 next paragraph).
 209
 210 There's a hidden assumption that PyThread_create_key() will be called before
 211 any of the other functions are called.  There's also a hidden assumption
 212 that calls to PyThread_create_key() are serialized externally.
 213 ------------------------------------------------------------------------ */
 214
 215 /* A singly-linked list of struct key objects remembers all the key->value
 216  * associations.  File static keyhead heads the list.  keymutex is used
 217  * to enforce exclusion internally.
 218  */
 219 struct key {
 220     /* Next record in the list, or NULL if this is the last record. */
 221     struct key *next;
 222
 223     /* The thread id, according to PyThread_get_thread_ident(). */
 224     long id;
 225
 226     /* The key and its associated value. */
 227     int key;
 228     void *value;
 229 };
 230
 231 static struct key *keyhead = NULL;
 232 static PyThread_type_lock keymutex = NULL;
 233 static int nkeys = 0;  /* PyThread_create_key() hands out nkeys+1 next */
 234
 235 /* Internal helper.
 236  * If the current thread has a mapping for key, the appropriate struct key*
 237  * is returned.  NB:  value is ignored in this case!
 238  * If there is no mapping for key in the current thread, then:
 239  *     If value is NULL, NULL is returned.
 240  *     Else a mapping of key to value is created for the current thread,
 241  *     and a pointer to a new struct key* is returned; except that if
 242  *     malloc() can't find room for a new struct key*, NULL is returned.
 243  * So when value==NULL, this acts like a pure lookup routine, and when
 244  * value!=NULL, this acts like dict.setdefault(), returning an existing
 245  * mapping if one exists, else creating a new mapping.
 246  *
 247  * Caution:  this used to be too clever, trying to hold keymutex only
 248  * around the "p->next = keyhead; keyhead = p" pair.  That allowed
 249  * another thread to mutate the list, via key deletion, concurrent with
 250  * find_key() crawling over the list.  Hilarity ensued.  For example, when
 251  * the for-loop here does "p = p->next", p could end up pointing at a
 252  * record that PyThread_delete_key_value() was concurrently free()'ing.
 253  * That could lead to anything, from failing to find a key that exists, to
 254  * segfaults.  Now we lock the whole routine.
 255  */
 256 static struct key *
 257 find_key(int key, void *value)
 258 {
 259     struct key *p, *prev_p;
 260     long id = PyThread_get_thread_ident();
 261
 262     if (!keymutex)
 263         return NULL;
 264     PyThread_acquire_lock(keymutex, 1);
 265     prev_p = NULL;
 266     for (p = keyhead; p != NULL; p = p->next) {
 267         if (p->id == id && p->key == key)
 268             goto Done;
 269         /* Sanity check.  These states should never happen but if
 270          * they do we must abort.  Otherwise we'll end up spinning in
 271          * in a tight loop with the lock held.  A similar check is done
 272          * in pystate.c tstate_delete_common().  */
 273         if (p == prev_p)
 274             Py_FatalError("tls find_key: small circular list(!)");
 275         prev_p = p;
 276         if (p->next == keyhead)
 277             Py_FatalError("tls find_key: circular list(!)");
 278     }
 279     if (value == NULL) {
 280         assert(p == NULL);
 281         goto Done;
 282     }
 283     p = (struct key *)malloc(sizeof(struct key));
 284     if (p != NULL) {
 285         p->id = id;
 286         p->key = key;
 287         p->value = value;
 288         p->next = keyhead;
 289         keyhead = p;
 290     }
 291  Done:
 292     PyThread_release_lock(keymutex);
 293     return p;
 294 }
 295
 296 /* Return a new key.  This must be called before any other functions in
 297  * this family, and callers must arrange to serialize calls to this
 298  * function.  No violations are detected.
 299  */
 300 int
 301 PyThread_create_key(void)
 302 {
 303     /* All parts of this function are wrong if it's called by multiple
 304      * threads simultaneously.
 305      */
 306     if (keymutex == NULL)
 307         keymutex = PyThread_allocate_lock();
 308     return ++nkeys;
 309 }
 310
 311 /* Forget the associations for key across *all* threads. */
 312 void
 313 PyThread_delete_key(int key)
 314 {
 315     struct key *p, **q;
 316
 317     PyThread_acquire_lock(keymutex, 1);
 318     q = &keyhead;
 319     while ((p = *q) != NULL) {
 320         if (p->key == key) {
 321             *q = p->next;
 322             free((void *)p);
 323             /* NB This does *not* free p->value! */
 324         }
 325         else
 326             q = &p->next;
 327     }
 328     PyThread_release_lock(keymutex);
 329 }
 330
 331 /* Confusing:  If the current thread has an association for key,
 332  * value is ignored, and 0 is returned.  Else an attempt is made to create
 333  * an association of key to value for the current thread.  0 is returned
 334  * if that succeeds, but -1 is returned if there's not enough memory
 335  * to create the association.  value must not be NULL.
 336  */
 337 int
 338 PyThread_set_key_value(int key, void *value)
 339 {
 340     struct key *p;
 341
 342     assert(value != NULL);
 343     p = find_key(key, value);
 344     if (p == NULL)
 345         return -1;
 346     else
 347         return 0;
 348 }
 349
 350 /* Retrieve the value associated with key in the current thread, or NULL
 351  * if the current thread doesn't have an association for key.
 352  */
 353 void *
 354 PyThread_get_key_value(int key)
 355 {
 356     struct key *p = find_key(key, NULL);
 357
 358     if (p == NULL)
 359         return NULL;
 360     else
 361         return p->value;
 362 }
 363
 364 /* Forget the current thread's association for key, if any. */
 365 void
 366 PyThread_delete_key_value(int key)
 367 {
 368     long id = PyThread_get_thread_ident();
 369     struct key *p, **q;
 370
 371     PyThread_acquire_lock(keymutex, 1);
 372     q = &keyhead;
 373     while ((p = *q) != NULL) {
 374         if (p->key == key && p->id == id) {
 375             *q = p->next;
 376             free((void *)p);
 377             /* NB This does *not* free p->value! */
 378             break;
 379         }
 380         else
 381             q = &p->next;
 382     }
 383     PyThread_release_lock(keymutex);
 384 }
 385
 386 /* Forget everything not associated with the current thread id.
 387  * This function is called from PyOS_AfterFork().  It is necessary
 388  * because other thread ids which were in use at the time of the fork
 389  * may be reused for new threads created in the forked process.
 390  */
 391 void
 392 PyThread_ReInitTLS(void)
 393 {
 394     long id = PyThread_get_thread_ident();
 395     struct key *p, **q;
 396
 397     if (!keymutex)
 398         return;
 399
 400     /* As with interpreter_lock in PyEval_ReInitThreads()
 401        we just create a new lock without freeing the old one */
 402     keymutex = PyThread_allocate_lock();
 403
 404     /* Delete all keys which do not match the current thread id */
 405     q = &keyhead;
 406     while ((p = *q) != NULL) {
 407         if (p->id != id) {
 408             *q = p->next;
 409             free((void *)p);
 410             /* NB This does *not* free p->value! */
 411         }
 412         else
 413             q = &p->next;
 414     }
 415 }
 416
 417 #endif /* Py_HAVE_NATIVE_TLS */