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 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
 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
 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 *
 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 in
 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
 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
 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
 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 *
 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
 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
 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 */