1 2 /* Thread and interpreter state structures and their interfaces */ 3 4 #include "Python.h" 5 6 /* -------------------------------------------------------------------------- 7 CAUTION 8 9 Always use malloc() and free() directly in this file. A number of these 10 functions are advertised as safe to call when the GIL isn't held, and in 11 a debug build Python redirects (e.g.) PyMem_NEW (etc) to Python's debugging 12 obmalloc functions. Those aren't thread-safe (they rely on the GIL to avoid 13 the expense of doing their own locking). 14 -------------------------------------------------------------------------- */ 15 16 #ifdef HAVE_DLOPEN 17 #ifdef HAVE_DLFCN_H 18 #include <dlfcn.h> 19 #endif 20 #ifndef RTLD_LAZY 21 #define RTLD_LAZY 1 22 #endif 23 #endif 24 25 26 #ifdef WITH_THREAD 27 #include "pythread.h" 28 static PyThread_type_lock head_mutex = NULL; /* Protects interp->tstate_head */ 29 #define HEAD_INIT() (void)(head_mutex || (head_mutex = PyThread_allocate_lock())) 30 #define HEAD_LOCK() PyThread_acquire_lock(head_mutex, WAIT_LOCK) 31 #define HEAD_UNLOCK() PyThread_release_lock(head_mutex) 32 33 #ifdef __cplusplus 34 extern "C" { 35 #endif 36 37 /* The single PyInterpreterState used by this process' 38 GILState implementation 39 */ 40 static PyInterpreterState *autoInterpreterState = NULL; 41 static int autoTLSkey = 0; 42 #else 43 #define HEAD_INIT() /* Nothing */ 44 #define HEAD_LOCK() /* Nothing */ 45 #define HEAD_UNLOCK() /* Nothing */ 46 #endif 47 48 static PyInterpreterState *interp_head = NULL; 49 50 PyThreadState *_PyThreadState_Current = NULL; 51 PyThreadFrameGetter _PyThreadState_GetFrame = NULL; 52 53 #ifdef WITH_THREAD 54 static void _PyGILState_NoteThreadState(PyThreadState* tstate); 55 #endif 56 57 58 PyInterpreterState * 59 PyInterpreterState_New(void) 60 { 61 PyInterpreterState *interp = (PyInterpreterState *) 62 malloc(sizeof(PyInterpreterState)); 63 64 if (interp != NULL) { 65 HEAD_INIT(); 66 #ifdef WITH_THREAD 67 if (head_mutex == NULL) 68 Py_FatalError("Can't initialize threads for interpreter"); 69 #endif 70 interp->modules = NULL; 71 interp->modules_reloading = NULL; 72 interp->sysdict = NULL; 73 interp->builtins = NULL; 74 interp->tstate_head = NULL; 75 interp->codec_search_path = NULL; 76 interp->codec_search_cache = NULL; 77 interp->codec_error_registry = NULL; 78 #ifdef HAVE_DLOPEN 79 #ifdef RTLD_NOW 80 interp->dlopenflags = RTLD_NOW; 81 #else 82 interp->dlopenflags = RTLD_LAZY; 83 #endif 84 #endif 85 #ifdef WITH_TSC 86 interp->tscdump = 0; 87 #endif 88 89 HEAD_LOCK(); 90 interp->next = interp_head; 91 interp_head = interp; 92 HEAD_UNLOCK(); 93 } 94 95 return interp; 96 } 97 98 99 void 100 PyInterpreterState_Clear(PyInterpreterState *interp) 101 { 102 PyThreadState *p; 103 HEAD_LOCK(); 104 for (p = interp->tstate_head; p != NULL; p = p->next) 105 PyThreadState_Clear(p); 106 HEAD_UNLOCK(); 107 Py_CLEAR(interp->codec_search_path); 108 Py_CLEAR(interp->codec_search_cache); 109 Py_CLEAR(interp->codec_error_registry); 110 Py_CLEAR(interp->modules); 111 Py_CLEAR(interp->modules_reloading); 112 Py_CLEAR(interp->sysdict); 113 Py_CLEAR(interp->builtins); 114 } 115 116 117 static void 118 zapthreads(PyInterpreterState *interp) 119 { 120 PyThreadState *p; 121 /* No need to lock the mutex here because this should only happen 122 when the threads are all really dead (XXX famous last words). */ 123 while ((p = interp->tstate_head) != NULL) { 124 PyThreadState_Delete(p); 125 } 126 } 127 128 129 void 130 PyInterpreterState_Delete(PyInterpreterState *interp) 131 { 132 PyInterpreterState **p; 133 zapthreads(interp); 134 HEAD_LOCK(); 135 for (p = &interp_head; ; p = &(*p)->next) { 136 if (*p == NULL) 137 Py_FatalError( 138 "PyInterpreterState_Delete: invalid interp"); 139 if (*p == interp) 140 break; 141 } 142 if (interp->tstate_head != NULL) 143 Py_FatalError("PyInterpreterState_Delete: remaining threads"); 144 *p = interp->next; 145 HEAD_UNLOCK(); 146 free(interp); 147 } 148 149 150 /* Default implementation for _PyThreadState_GetFrame */ 151 static struct _frame * 152 threadstate_getframe(PyThreadState *self) 153 { 154 return self->frame; 155 } 156 157 static PyThreadState * 158 new_threadstate(PyInterpreterState *interp, int init) 159 { 160 PyThreadState *tstate = (PyThreadState *)malloc(sizeof(PyThreadState)); 161 162 if (_PyThreadState_GetFrame == NULL) 163 _PyThreadState_GetFrame = threadstate_getframe; 164 165 if (tstate != NULL) { 166 tstate->interp = interp; 167 168 tstate->frame = NULL; 169 tstate->recursion_depth = 0; 170 tstate->tracing = 0; 171 tstate->use_tracing = 0; 172 tstate->tick_counter = 0; 173 tstate->gilstate_counter = 0; 174 tstate->async_exc = NULL; 175 #ifdef WITH_THREAD 176 tstate->thread_id = PyThread_get_thread_ident(); 177 #else 178 tstate->thread_id = 0; 179 #endif 180 181 tstate->dict = NULL; 182 183 tstate->curexc_type = NULL; 184 tstate->curexc_value = NULL; 185 tstate->curexc_traceback = NULL; 186 187 tstate->exc_type = NULL; 188 tstate->exc_value = NULL; 189 tstate->exc_traceback = NULL; 190 191 tstate->c_profilefunc = NULL; 192 tstate->c_tracefunc = NULL; 193 tstate->c_profileobj = NULL; 194 tstate->c_traceobj = NULL; 195 196 if (init) 197 _PyThreadState_Init(tstate); 198 199 HEAD_LOCK(); 200 tstate->next = interp->tstate_head; 201 interp->tstate_head = tstate; 202 HEAD_UNLOCK(); 203 } 204 205 return tstate; 206 } 207 208 PyThreadState * 209 PyThreadState_New(PyInterpreterState *interp) 210 { 211 return new_threadstate(interp, 1); 212 } 213 214 PyThreadState * 215 _PyThreadState_Prealloc(PyInterpreterState *interp) 216 { 217 return new_threadstate(interp, 0); 218 } 219 220 void 221 _PyThreadState_Init(PyThreadState *tstate) 222 { 223 #ifdef WITH_THREAD 224 _PyGILState_NoteThreadState(tstate); 225 #endif 226 } 227 228 void 229 PyThreadState_Clear(PyThreadState *tstate) 230 { 231 if (Py_VerboseFlag && tstate->frame != NULL) 232 fprintf(stderr, 233 "PyThreadState_Clear: warning: thread still has a frame\n"); 234 235 Py_CLEAR(tstate->frame); 236 237 Py_CLEAR(tstate->dict); 238 Py_CLEAR(tstate->async_exc); 239 240 Py_CLEAR(tstate->curexc_type); 241 Py_CLEAR(tstate->curexc_value); 242 Py_CLEAR(tstate->curexc_traceback); 243 244 Py_CLEAR(tstate->exc_type); 245 Py_CLEAR(tstate->exc_value); 246 Py_CLEAR(tstate->exc_traceback); 247 248 tstate->c_profilefunc = NULL; 249 tstate->c_tracefunc = NULL; 250 Py_CLEAR(tstate->c_profileobj); 251 Py_CLEAR(tstate->c_traceobj); 252 } 253 254 255 /* Common code for PyThreadState_Delete() and PyThreadState_DeleteCurrent() */ 256 static void 257 tstate_delete_common(PyThreadState *tstate) 258 { 259 PyInterpreterState *interp; 260 PyThreadState **p; 261 PyThreadState *prev_p = NULL; 262 if (tstate == NULL) 263 Py_FatalError("PyThreadState_Delete: NULL tstate"); 264 interp = tstate->interp; 265 if (interp == NULL) 266 Py_FatalError("PyThreadState_Delete: NULL interp"); 267 HEAD_LOCK(); 268 for (p = &interp->tstate_head; ; p = &(*p)->next) { 269 if (*p == NULL) 270 Py_FatalError( 271 "PyThreadState_Delete: invalid tstate"); 272 if (*p == tstate) 273 break; 274 /* Sanity check. These states should never happen but if 275 * they do we must abort. Otherwise we'll end up spinning in 276 * in a tight loop with the lock held. A similar check is done 277 * in thread.c find_key(). */ 278 if (*p == prev_p) 279 Py_FatalError( 280 "PyThreadState_Delete: small circular list(!)" 281 " and tstate not found."); 282 prev_p = *p; 283 if ((*p)->next == interp->tstate_head) 284 Py_FatalError( 285 "PyThreadState_Delete: circular list(!) and" 286 " tstate not found."); 287 } 288 *p = tstate->next; 289 HEAD_UNLOCK(); 290 free(tstate); 291 } 292 293 294 void 295 PyThreadState_Delete(PyThreadState *tstate) 296 { 297 if (tstate == _PyThreadState_Current) 298 Py_FatalError("PyThreadState_Delete: tstate is still current"); 299 tstate_delete_common(tstate); 300 #ifdef WITH_THREAD 301 if (autoInterpreterState && PyThread_get_key_value(autoTLSkey) == tstate) 302 PyThread_delete_key_value(autoTLSkey); 303 #endif /* WITH_THREAD */ 304 } 305 306 307 #ifdef WITH_THREAD 308 void 309 PyThreadState_DeleteCurrent() 310 { 311 PyThreadState *tstate = _PyThreadState_Current; 312 if (tstate == NULL) 313 Py_FatalError( 314 "PyThreadState_DeleteCurrent: no current tstate"); 315 _PyThreadState_Current = NULL; 316 tstate_delete_common(tstate); 317 if (autoInterpreterState && PyThread_get_key_value(autoTLSkey) == tstate) 318 PyThread_delete_key_value(autoTLSkey); 319 PyEval_ReleaseLock(); 320 } 321 #endif /* WITH_THREAD */ 322 323 324 PyThreadState * 325 PyThreadState_Get(void) 326 { 327 if (_PyThreadState_Current == NULL) 328 Py_FatalError("PyThreadState_Get: no current thread"); 329 330 return _PyThreadState_Current; 331 } 332 333 334 PyThreadState * 335 PyThreadState_Swap(PyThreadState *newts) 336 { 337 PyThreadState *oldts = _PyThreadState_Current; 338 339 _PyThreadState_Current = newts; 340 /* It should not be possible for more than one thread state 341 to be used for a thread. Check this the best we can in debug 342 builds. 343 */ 344 #if defined(Py_DEBUG) && defined(WITH_THREAD) 345 if (newts) { 346 /* This can be called from PyEval_RestoreThread(). Similar 347 to it, we need to ensure errno doesn't change. 348 */ 349 int err = errno; 350 PyThreadState *check = PyGILState_GetThisThreadState(); 351 if (check && check->interp == newts->interp && check != newts) 352 Py_FatalError("Invalid thread state for this thread"); 353 errno = err; 354 } 355 #endif 356 return oldts; 357 } 358 359 /* An extension mechanism to store arbitrary additional per-thread state. 360 PyThreadState_GetDict() returns a dictionary that can be used to hold such 361 state; the caller should pick a unique key and store its state there. If 362 PyThreadState_GetDict() returns NULL, an exception has *not* been raised 363 and the caller should assume no per-thread state is available. */ 364 365 PyObject * 366 PyThreadState_GetDict(void) 367 { 368 if (_PyThreadState_Current == NULL) 369 return NULL; 370 371 if (_PyThreadState_Current->dict == NULL) { 372 PyObject *d; 373 _PyThreadState_Current->dict = d = PyDict_New(); 374 if (d == NULL) 375 PyErr_Clear(); 376 } 377 return _PyThreadState_Current->dict; 378 } 379 380 381 /* Asynchronously raise an exception in a thread. 382 Requested by Just van Rossum and Alex Martelli. 383 To prevent naive misuse, you must write your own extension 384 to call this, or use ctypes. Must be called with the GIL held. 385 Returns the number of tstates modified (normally 1, but 0 if `id` didn't 386 match any known thread id). Can be called with exc=NULL to clear an 387 existing async exception. This raises no exceptions. */ 388 389 int 390 PyThreadState_SetAsyncExc(long id, PyObject *exc) { 391 PyThreadState *tstate = PyThreadState_GET(); 392 PyInterpreterState *interp = tstate->interp; 393 PyThreadState *p; 394 395 /* Although the GIL is held, a few C API functions can be called 396 * without the GIL held, and in particular some that create and 397 * destroy thread and interpreter states. Those can mutate the 398 * list of thread states we're traversing, so to prevent that we lock 399 * head_mutex for the duration. 400 */ 401 HEAD_LOCK(); 402 for (p = interp->tstate_head; p != NULL; p = p->next) { 403 if (p->thread_id == id) { 404 /* Tricky: we need to decref the current value 405 * (if any) in p->async_exc, but that can in turn 406 * allow arbitrary Python code to run, including 407 * perhaps calls to this function. To prevent 408 * deadlock, we need to release head_mutex before 409 * the decref. 410 */ 411 PyObject *old_exc = p->async_exc; 412 Py_XINCREF(exc); 413 p->async_exc = exc; 414 HEAD_UNLOCK(); 415 Py_XDECREF(old_exc); 416 return 1; 417 } 418 } 419 HEAD_UNLOCK(); 420 return 0; 421 } 422 423 424 /* Routines for advanced debuggers, requested by David Beazley. 425 Don't use unless you know what you are doing! */ 426 427 PyInterpreterState * 428 PyInterpreterState_Head(void) 429 { 430 return interp_head; 431 } 432 433 PyInterpreterState * 434 PyInterpreterState_Next(PyInterpreterState *interp) { 435 return interp->next; 436 } 437 438 PyThreadState * 439 PyInterpreterState_ThreadHead(PyInterpreterState *interp) { 440 return interp->tstate_head; 441 } 442 443 PyThreadState * 444 PyThreadState_Next(PyThreadState *tstate) { 445 return tstate->next; 446 } 447 448 /* The implementation of sys._current_frames(). This is intended to be 449 called with the GIL held, as it will be when called via 450 sys._current_frames(). It's possible it would work fine even without 451 the GIL held, but haven't thought enough about that. 452 */ 453 PyObject * 454 _PyThread_CurrentFrames(void) 455 { 456 PyObject *result; 457 PyInterpreterState *i; 458 459 result = PyDict_New(); 460 if (result == NULL) 461 return NULL; 462 463 /* for i in all interpreters: 464 * for t in all of i's thread states: 465 * if t's frame isn't NULL, map t's id to its frame 466 * Because these lists can mutate even when the GIL is held, we 467 * need to grab head_mutex for the duration. 468 */ 469 HEAD_LOCK(); 470 for (i = interp_head; i != NULL; i = i->next) { 471 PyThreadState *t; 472 for (t = i->tstate_head; t != NULL; t = t->next) { 473 PyObject *id; 474 int stat; 475 struct _frame *frame = t->frame; 476 if (frame == NULL) 477 continue; 478 id = PyInt_FromLong(t->thread_id); 479 if (id == NULL) 480 goto Fail; 481 stat = PyDict_SetItem(result, id, (PyObject *)frame); 482 Py_DECREF(id); 483 if (stat < 0) 484 goto Fail; 485 } 486 } 487 HEAD_UNLOCK(); 488 return result; 489 490 Fail: 491 HEAD_UNLOCK(); 492 Py_DECREF(result); 493 return NULL; 494 } 495 496 /* Python "auto thread state" API. */ 497 #ifdef WITH_THREAD 498 499 /* Keep this as a static, as it is not reliable! It can only 500 ever be compared to the state for the *current* thread. 501 * If not equal, then it doesn't matter that the actual 502 value may change immediately after comparison, as it can't 503 possibly change to the current thread's state. 504 * If equal, then the current thread holds the lock, so the value can't 505 change until we yield the lock. 506 */ 507 static int 508 PyThreadState_IsCurrent(PyThreadState *tstate) 509 { 510 /* Must be the tstate for this thread */ 511 assert(PyGILState_GetThisThreadState()==tstate); 512 /* On Windows at least, simple reads and writes to 32 bit values 513 are atomic. 514 */ 515 return tstate == _PyThreadState_Current; 516 } 517 518 /* Internal initialization/finalization functions called by 519 Py_Initialize/Py_Finalize 520 */ 521 void 522 _PyGILState_Init(PyInterpreterState *i, PyThreadState *t) 523 { 524 assert(i && t); /* must init with valid states */ 525 autoTLSkey = PyThread_create_key(); 526 autoInterpreterState = i; 527 assert(PyThread_get_key_value(autoTLSkey) == NULL); 528 assert(t->gilstate_counter == 0); 529 530 _PyGILState_NoteThreadState(t); 531 } 532 533 void 534 _PyGILState_Fini(void) 535 { 536 PyThread_delete_key(autoTLSkey); 537 autoInterpreterState = NULL; 538 } 539 540 /* Reset the TLS key - called by PyOS_AfterFork. 541 * This should not be necessary, but some - buggy - pthread implementations 542 * don't flush TLS on fork, see issue #10517. 543 */ 544 void 545 _PyGILState_Reinit(void) 546 { 547 PyThreadState *tstate = PyGILState_GetThisThreadState(); 548 PyThread_delete_key(autoTLSkey); 549 if ((autoTLSkey = PyThread_create_key()) == -1) 550 Py_FatalError("Could not allocate TLS entry"); 551 552 /* re-associate the current thread state with the new key */ 553 if (PyThread_set_key_value(autoTLSkey, (void *)tstate) < 0) 554 Py_FatalError("Couldn't create autoTLSkey mapping"); 555 } 556 557 /* When a thread state is created for a thread by some mechanism other than 558 PyGILState_Ensure, it's important that the GILState machinery knows about 559 it so it doesn't try to create another thread state for the thread (this is 560 a better fix for SF bug #1010677 than the first one attempted). 561 */ 562 static void 563 _PyGILState_NoteThreadState(PyThreadState* tstate) 564 { 565 /* If autoTLSkey isn't initialized, this must be the very first 566 threadstate created in Py_Initialize(). Don't do anything for now 567 (we'll be back here when _PyGILState_Init is called). */ 568 if (!autoInterpreterState) 569 return; 570 571 /* Stick the thread state for this thread in thread local storage. 572 573 The only situation where you can legitimately have more than one 574 thread state for an OS level thread is when there are multiple 575 interpreters, when: 576 577 a) You shouldn't really be using the PyGILState_ APIs anyway, 578 and: 579 580 b) The slightly odd way PyThread_set_key_value works (see 581 comments by its implementation) means that the first thread 582 state created for that given OS level thread will "win", 583 which seems reasonable behaviour. 584 */ 585 if (PyThread_set_key_value(autoTLSkey, (void *)tstate) < 0) 586 Py_FatalError("Couldn't create autoTLSkey mapping"); 587 588 /* PyGILState_Release must not try to delete this thread state. */ 589 tstate->gilstate_counter = 1; 590 } 591 592 /* The public functions */ 593 PyThreadState * 594 PyGILState_GetThisThreadState(void) 595 { 596 if (autoInterpreterState == NULL) 597 return NULL; 598 return (PyThreadState *)PyThread_get_key_value(autoTLSkey); 599 } 600 601 PyGILState_STATE 602 PyGILState_Ensure(void) 603 { 604 int current; 605 PyThreadState *tcur; 606 /* Note that we do not auto-init Python here - apart from 607 potential races with 2 threads auto-initializing, pep-311 608 spells out other issues. Embedders are expected to have 609 called Py_Initialize() and usually PyEval_InitThreads(). 610 */ 611 assert(autoInterpreterState); /* Py_Initialize() hasn't been called! */ 612 tcur = (PyThreadState *)PyThread_get_key_value(autoTLSkey); 613 if (tcur == NULL) { 614 /* Create a new thread state for this thread */ 615 tcur = PyThreadState_New(autoInterpreterState); 616 if (tcur == NULL) 617 Py_FatalError("Couldn't create thread-state for new thread"); 618 /* This is our thread state! We'll need to delete it in the 619 matching call to PyGILState_Release(). */ 620 tcur->gilstate_counter = 0; 621 current = 0; /* new thread state is never current */ 622 } 623 else 624 current = PyThreadState_IsCurrent(tcur); 625 if (current == 0) 626 PyEval_RestoreThread(tcur); 627 /* Update our counter in the thread-state - no need for locks: 628 - tcur will remain valid as we hold the GIL. 629 - the counter is safe as we are the only thread "allowed" 630 to modify this value 631 */ 632 ++tcur->gilstate_counter; 633 return current ? PyGILState_LOCKED : PyGILState_UNLOCKED; 634 } 635 636 void 637 PyGILState_Release(PyGILState_STATE oldstate) 638 { 639 PyThreadState *tcur = (PyThreadState *)PyThread_get_key_value( 640 autoTLSkey); 641 if (tcur == NULL) 642 Py_FatalError("auto-releasing thread-state, " 643 "but no thread-state for this thread"); 644 /* We must hold the GIL and have our thread state current */ 645 /* XXX - remove the check - the assert should be fine, 646 but while this is very new (April 2003), the extra check 647 by release-only users can't hurt. 648 */ 649 if (! PyThreadState_IsCurrent(tcur)) 650 Py_FatalError("This thread state must be current when releasing"); 651 assert(PyThreadState_IsCurrent(tcur)); 652 --tcur->gilstate_counter; 653 assert(tcur->gilstate_counter >= 0); /* illegal counter value */ 654 655 /* If we're going to destroy this thread-state, we must 656 * clear it while the GIL is held, as destructors may run. 657 */ 658 if (tcur->gilstate_counter == 0) { 659 /* can't have been locked when we created it */ 660 assert(oldstate == PyGILState_UNLOCKED); 661 PyThreadState_Clear(tcur); 662 /* Delete the thread-state. Note this releases the GIL too! 663 * It's vital that the GIL be held here, to avoid shutdown 664 * races; see bugs 225673 and 1061968 (that nasty bug has a 665 * habit of coming back). 666 */ 667 PyThreadState_DeleteCurrent(); 668 } 669 /* Release the lock if necessary */ 670 else if (oldstate == PyGILState_UNLOCKED) 671 PyEval_SaveThread(); 672 } 673 674 #ifdef __cplusplus 675 } 676 #endif 677 678 #endif /* WITH_THREAD */ 679 680 681
