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