Python/pystate.c

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