pystate.c 21.6 KB
Newer Older
1 2 3 4 5

/* Thread and interpreter state structures and their interfaces */

#include "Python.h"

6 7 8 9 10 11 12 13 14 15
/* --------------------------------------------------------------------------
CAUTION

Always use malloc() and free() directly in this file.  A number of these
functions are advertised as safe to call when the GIL isn't held, and in
a debug build Python redirects (e.g.) PyMem_NEW (etc) to Python's debugging
obmalloc functions.  Those aren't thread-safe (they rely on the GIL to avoid
the expense of doing their own locking).
-------------------------------------------------------------------------- */

16 17 18 19 20 21 22 23 24
#ifdef HAVE_DLOPEN
#ifdef HAVE_DLFCN_H
#include <dlfcn.h>
#endif
#ifndef RTLD_LAZY
#define RTLD_LAZY 1
#endif
#endif

25 26 27
#ifdef __cplusplus
extern "C" {
#endif
28

Guido van Rossum's avatar
Guido van Rossum committed
29 30 31
#ifdef WITH_THREAD
#include "pythread.h"
static PyThread_type_lock head_mutex = NULL; /* Protects interp->tstate_head */
32
#define HEAD_INIT() (void)(head_mutex || (head_mutex = PyThread_allocate_lock()))
Guido van Rossum's avatar
Guido van Rossum committed
33 34
#define HEAD_LOCK() PyThread_acquire_lock(head_mutex, WAIT_LOCK)
#define HEAD_UNLOCK() PyThread_release_lock(head_mutex)
Michael W. Hudson's avatar
Michael W. Hudson committed
35 36 37 38 39 40

/* The single PyInterpreterState used by this process'
   GILState implementation
*/
static PyInterpreterState *autoInterpreterState = NULL;
static int autoTLSkey = 0;
Guido van Rossum's avatar
Guido van Rossum committed
41 42 43 44 45 46
#else
#define HEAD_INIT() /* Nothing */
#define HEAD_LOCK() /* Nothing */
#define HEAD_UNLOCK() /* Nothing */
#endif

47
static PyInterpreterState *interp_head = NULL;
48

49 50 51
/* Assuming the current thread holds the GIL, this is the
   PyThreadState for the current thread. */
_Py_atomic_address _PyThreadState_Current = {NULL};
52
PyThreadFrameGetter _PyThreadState_GetFrame = NULL;
53

Michael W. Hudson's avatar
Michael W. Hudson committed
54
#ifdef WITH_THREAD
Michael W. Hudson's avatar
Michael W. Hudson committed
55
static void _PyGILState_NoteThreadState(PyThreadState* tstate);
Michael W. Hudson's avatar
Michael W. Hudson committed
56
#endif
Michael W. Hudson's avatar
Michael W. Hudson committed
57

58 59

PyInterpreterState *
60
PyInterpreterState_New(void)
61
{
62 63
    PyInterpreterState *interp = (PyInterpreterState *)
                                 malloc(sizeof(PyInterpreterState));
64

65 66
    if (interp != NULL) {
        HEAD_INIT();
67
#ifdef WITH_THREAD
68 69
        if (head_mutex == NULL)
            Py_FatalError("Can't initialize threads for interpreter");
70
#endif
71 72 73 74 75 76 77 78 79
        interp->modules = NULL;
        interp->modules_by_index = NULL;
        interp->sysdict = NULL;
        interp->builtins = NULL;
        interp->tstate_head = NULL;
        interp->codec_search_path = NULL;
        interp->codec_search_cache = NULL;
        interp->codec_error_registry = NULL;
        interp->codecs_initialized = 0;
80
        interp->fscodec_initialized = 0;
81
        interp->importlib = NULL;
82 83
#ifdef HAVE_DLOPEN
#ifdef RTLD_NOW
84
        interp->dlopenflags = RTLD_NOW;
85
#else
86
        interp->dlopenflags = RTLD_LAZY;
87
#endif
88 89
#endif
#ifdef WITH_TSC
90
        interp->tscdump = 0;
91
#endif
92

93 94 95 96 97
        HEAD_LOCK();
        interp->next = interp_head;
        interp_head = interp;
        HEAD_UNLOCK();
    }
98

99
    return interp;
100 101 102 103
}


void
104
PyInterpreterState_Clear(PyInterpreterState *interp)
105
{
106 107 108 109 110 111 112 113 114 115 116 117
    PyThreadState *p;
    HEAD_LOCK();
    for (p = interp->tstate_head; p != NULL; p = p->next)
        PyThreadState_Clear(p);
    HEAD_UNLOCK();
    Py_CLEAR(interp->codec_search_path);
    Py_CLEAR(interp->codec_search_cache);
    Py_CLEAR(interp->codec_error_registry);
    Py_CLEAR(interp->modules);
    Py_CLEAR(interp->modules_by_index);
    Py_CLEAR(interp->sysdict);
    Py_CLEAR(interp->builtins);
118
    Py_CLEAR(interp->importlib);
119 120 121 122
}


static void
123
zapthreads(PyInterpreterState *interp)
124
{
125 126 127 128 129 130
    PyThreadState *p;
    /* No need to lock the mutex here because this should only happen
       when the threads are all really dead (XXX famous last words). */
    while ((p = interp->tstate_head) != NULL) {
        PyThreadState_Delete(p);
    }
131
}
132

133 134

void
135
PyInterpreterState_Delete(PyInterpreterState *interp)
136
{
137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
    PyInterpreterState **p;
    zapthreads(interp);
    HEAD_LOCK();
    for (p = &interp_head; ; p = &(*p)->next) {
        if (*p == NULL)
            Py_FatalError(
                "PyInterpreterState_Delete: invalid interp");
        if (*p == interp)
            break;
    }
    if (interp->tstate_head != NULL)
        Py_FatalError("PyInterpreterState_Delete: remaining threads");
    *p = interp->next;
    HEAD_UNLOCK();
    free(interp);
152 153 154 155 156 157
#ifdef WITH_THREAD
    if (interp_head == NULL && head_mutex != NULL) {
        PyThread_free_lock(head_mutex);
        head_mutex = NULL;
    }
#endif
158 159 160
}


161 162 163 164
/* Default implementation for _PyThreadState_GetFrame */
static struct _frame *
threadstate_getframe(PyThreadState *self)
{
165
    return self->frame;
166 167
}

168 169
static PyThreadState *
new_threadstate(PyInterpreterState *interp, int init)
170
{
171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187
    PyThreadState *tstate = (PyThreadState *)malloc(sizeof(PyThreadState));

    if (_PyThreadState_GetFrame == NULL)
        _PyThreadState_GetFrame = threadstate_getframe;

    if (tstate != NULL) {
        tstate->interp = interp;

        tstate->frame = NULL;
        tstate->recursion_depth = 0;
        tstate->overflowed = 0;
        tstate->recursion_critical = 0;
        tstate->tracing = 0;
        tstate->use_tracing = 0;
        tstate->tick_counter = 0;
        tstate->gilstate_counter = 0;
        tstate->async_exc = NULL;
188
#ifdef WITH_THREAD
189
        tstate->thread_id = PyThread_get_thread_ident();
190
#else
191
        tstate->thread_id = 0;
192
#endif
193

194
        tstate->dict = NULL;
195

196 197 198
        tstate->curexc_type = NULL;
        tstate->curexc_value = NULL;
        tstate->curexc_traceback = NULL;
199

200 201 202
        tstate->exc_type = NULL;
        tstate->exc_value = NULL;
        tstate->exc_traceback = NULL;
203

204 205 206 207
        tstate->c_profilefunc = NULL;
        tstate->c_tracefunc = NULL;
        tstate->c_profileobj = NULL;
        tstate->c_traceobj = NULL;
208

209 210
        if (init)
            _PyThreadState_Init(tstate);
Michael W. Hudson's avatar
Michael W. Hudson committed
211

212 213 214 215 216
        HEAD_LOCK();
        tstate->next = interp->tstate_head;
        interp->tstate_head = tstate;
        HEAD_UNLOCK();
    }
217

218
    return tstate;
219 220
}

221 222 223
PyThreadState *
PyThreadState_New(PyInterpreterState *interp)
{
224
    return new_threadstate(interp, 1);
225 226 227 228 229
}

PyThreadState *
_PyThreadState_Prealloc(PyInterpreterState *interp)
{
230
    return new_threadstate(interp, 0);
231 232 233 234 235 236
}

void
_PyThreadState_Init(PyThreadState *tstate)
{
#ifdef WITH_THREAD
237
    _PyGILState_NoteThreadState(tstate);
238 239 240
#endif
}

241 242 243
PyObject*
PyState_FindModule(struct PyModuleDef* m)
{
244 245 246 247 248 249 250 251 252 253 254
    Py_ssize_t index = m->m_base.m_index;
    PyInterpreterState *state = PyThreadState_GET()->interp;
    PyObject *res;
    if (index == 0)
        return NULL;
    if (state->modules_by_index == NULL)
        return NULL;
    if (index > PyList_GET_SIZE(state->modules_by_index))
        return NULL;
    res = PyList_GET_ITEM(state->modules_by_index, index);
    return res==Py_None ? NULL : res;
255 256 257 258 259
}

int
_PyState_AddModule(PyObject* module, struct PyModuleDef* def)
{
260 261 262 263 264 265 266 267 268 269 270 271 272 273
    PyInterpreterState *state = PyThreadState_GET()->interp;
    if (!def)
        return -1;
    if (!state->modules_by_index) {
        state->modules_by_index = PyList_New(0);
        if (!state->modules_by_index)
            return -1;
    }
    while(PyList_GET_SIZE(state->modules_by_index) <= def->m_base.m_index)
        if (PyList_Append(state->modules_by_index, Py_None) < 0)
            return -1;
    Py_INCREF(module);
    return PyList_SetItem(state->modules_by_index,
                          def->m_base.m_index, module);
274
}
275 276

void
277
PyThreadState_Clear(PyThreadState *tstate)
278
{
279 280 281
    if (Py_VerboseFlag && tstate->frame != NULL)
        fprintf(stderr,
          "PyThreadState_Clear: warning: thread still has a frame\n");
282

283
    Py_CLEAR(tstate->frame);
284

285 286
    Py_CLEAR(tstate->dict);
    Py_CLEAR(tstate->async_exc);
287

288 289 290
    Py_CLEAR(tstate->curexc_type);
    Py_CLEAR(tstate->curexc_value);
    Py_CLEAR(tstate->curexc_traceback);
291

292 293 294
    Py_CLEAR(tstate->exc_type);
    Py_CLEAR(tstate->exc_value);
    Py_CLEAR(tstate->exc_traceback);
295

296 297 298 299
    tstate->c_profilefunc = NULL;
    tstate->c_tracefunc = NULL;
    Py_CLEAR(tstate->c_profileobj);
    Py_CLEAR(tstate->c_traceobj);
300
}
301 302


303 304 305
/* Common code for PyThreadState_Delete() and PyThreadState_DeleteCurrent() */
static void
tstate_delete_common(PyThreadState *tstate)
306
{
307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338
    PyInterpreterState *interp;
    PyThreadState **p;
    PyThreadState *prev_p = NULL;
    if (tstate == NULL)
        Py_FatalError("PyThreadState_Delete: NULL tstate");
    interp = tstate->interp;
    if (interp == NULL)
        Py_FatalError("PyThreadState_Delete: NULL interp");
    HEAD_LOCK();
    for (p = &interp->tstate_head; ; p = &(*p)->next) {
        if (*p == NULL)
            Py_FatalError(
                "PyThreadState_Delete: invalid tstate");
        if (*p == tstate)
            break;
        /* Sanity check.  These states should never happen but if
         * they do we must abort.  Otherwise we'll end up spinning in
         * in a tight loop with the lock held.  A similar check is done
         * in thread.c find_key().  */
        if (*p == prev_p)
            Py_FatalError(
                "PyThreadState_Delete: small circular list(!)"
                " and tstate not found.");
        prev_p = *p;
        if ((*p)->next == interp->tstate_head)
            Py_FatalError(
                "PyThreadState_Delete: circular list(!) and"
                " tstate not found.");
    }
    *p = tstate->next;
    HEAD_UNLOCK();
    free(tstate);
339 340 341
}


342 343 344
void
PyThreadState_Delete(PyThreadState *tstate)
{
345 346 347
    if (tstate == _Py_atomic_load_relaxed(&_PyThreadState_Current))
        Py_FatalError("PyThreadState_Delete: tstate is still current");
    tstate_delete_common(tstate);
348
#ifdef WITH_THREAD
349
    if (autoInterpreterState && PyThread_get_key_value(autoTLSkey) == tstate)
350
        PyThread_delete_key_value(autoTLSkey);
351
#endif /* WITH_THREAD */
352 353 354 355 356 357 358
}


#ifdef WITH_THREAD
void
PyThreadState_DeleteCurrent()
{
359 360 361 362 363 364 365
    PyThreadState *tstate = (PyThreadState*)_Py_atomic_load_relaxed(
        &_PyThreadState_Current);
    if (tstate == NULL)
        Py_FatalError(
            "PyThreadState_DeleteCurrent: no current tstate");
    _Py_atomic_store_relaxed(&_PyThreadState_Current, NULL);
    tstate_delete_common(tstate);
366
    if (autoInterpreterState && PyThread_get_key_value(autoTLSkey) == tstate)
367 368
        PyThread_delete_key_value(autoTLSkey);
    PyEval_ReleaseLock();
369 370 371 372
}
#endif /* WITH_THREAD */


373
PyThreadState *
374
PyThreadState_Get(void)
375
{
376 377 378 379
    PyThreadState *tstate = (PyThreadState*)_Py_atomic_load_relaxed(
        &_PyThreadState_Current);
    if (tstate == NULL)
        Py_FatalError("PyThreadState_Get: no current thread");
380

381
    return tstate;
382 383 384 385
}


PyThreadState *
386
PyThreadState_Swap(PyThreadState *newts)
387
{
388 389 390 391 392 393 394 395
    PyThreadState *oldts = (PyThreadState*)_Py_atomic_load_relaxed(
        &_PyThreadState_Current);

    _Py_atomic_store_relaxed(&_PyThreadState_Current, newts);
    /* It should not be possible for more than one thread state
       to be used for a thread.  Check this the best we can in debug
       builds.
    */
396
#if defined(Py_DEBUG) && defined(WITH_THREAD)
397 398 399 400 401 402 403 404 405 406
    if (newts) {
        /* This can be called from PyEval_RestoreThread(). Similar
           to it, we need to ensure errno doesn't change.
        */
        int err = errno;
        PyThreadState *check = PyGILState_GetThisThreadState();
        if (check && check->interp == newts->interp && check != newts)
            Py_FatalError("Invalid thread state for this thread");
        errno = err;
    }
407
#endif
408
    return oldts;
409
}
410 411 412 413

/* An extension mechanism to store arbitrary additional per-thread state.
   PyThreadState_GetDict() returns a dictionary that can be used to hold such
   state; the caller should pick a unique key and store its state there.  If
414 415
   PyThreadState_GetDict() returns NULL, an exception has *not* been raised
   and the caller should assume no per-thread state is available. */
416 417

PyObject *
418
PyThreadState_GetDict(void)
419
{
420 421 422 423
    PyThreadState *tstate = (PyThreadState*)_Py_atomic_load_relaxed(
        &_PyThreadState_Current);
    if (tstate == NULL)
        return NULL;
424

425 426 427 428 429 430 431
    if (tstate->dict == NULL) {
        PyObject *d;
        tstate->dict = d = PyDict_New();
        if (d == NULL)
            PyErr_Clear();
    }
    return tstate->dict;
432
}
433 434


435 436
/* Asynchronously raise an exception in a thread.
   Requested by Just van Rossum and Alex Martelli.
437
   To prevent naive misuse, you must write your own extension
438 439 440 441
   to call this, or use ctypes.  Must be called with the GIL held.
   Returns the number of tstates modified (normally 1, but 0 if `id` didn't
   match any known thread id).  Can be called with exc=NULL to clear an
   existing async exception.  This raises no exceptions. */
442 443 444

int
PyThreadState_SetAsyncExc(long id, PyObject *exc) {
445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
    PyThreadState *tstate = PyThreadState_GET();
    PyInterpreterState *interp = tstate->interp;
    PyThreadState *p;

    /* Although the GIL is held, a few C API functions can be called
     * without the GIL held, and in particular some that create and
     * destroy thread and interpreter states.  Those can mutate the
     * list of thread states we're traversing, so to prevent that we lock
     * head_mutex for the duration.
     */
    HEAD_LOCK();
    for (p = interp->tstate_head; p != NULL; p = p->next) {
        if (p->thread_id == id) {
            /* Tricky:  we need to decref the current value
             * (if any) in p->async_exc, but that can in turn
             * allow arbitrary Python code to run, including
             * perhaps calls to this function.  To prevent
             * deadlock, we need to release head_mutex before
             * the decref.
             */
            PyObject *old_exc = p->async_exc;
            Py_XINCREF(exc);
            p->async_exc = exc;
            HEAD_UNLOCK();
            Py_XDECREF(old_exc);
            _PyEval_SignalAsyncExc();
            return 1;
        }
    }
    HEAD_UNLOCK();
    return 0;
476 477 478
}


479 480 481 482 483 484
/* Routines for advanced debuggers, requested by David Beazley.
   Don't use unless you know what you are doing! */

PyInterpreterState *
PyInterpreterState_Head(void)
{
485
    return interp_head;
486 487 488 489
}

PyInterpreterState *
PyInterpreterState_Next(PyInterpreterState *interp) {
490
    return interp->next;
491 492 493 494
}

PyThreadState *
PyInterpreterState_ThreadHead(PyInterpreterState *interp) {
495
    return interp->tstate_head;
496 497 498 499
}

PyThreadState *
PyThreadState_Next(PyThreadState *tstate) {
500
    return tstate->next;
501
}
502

503 504 505 506 507 508 509 510
/* The implementation of sys._current_frames().  This is intended to be
   called with the GIL held, as it will be when called via
   sys._current_frames().  It's possible it would work fine even without
   the GIL held, but haven't thought enough about that.
*/
PyObject *
_PyThread_CurrentFrames(void)
{
511 512 513 514 515 516 517 518 519 520
    PyObject *result;
    PyInterpreterState *i;

    result = PyDict_New();
    if (result == NULL)
        return NULL;

    /* for i in all interpreters:
     *     for t in all of i's thread states:
     *          if t's frame isn't NULL, map t's id to its frame
521
     * Because these lists can mutate even when the GIL is held, we
522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543
     * need to grab head_mutex for the duration.
     */
    HEAD_LOCK();
    for (i = interp_head; i != NULL; i = i->next) {
        PyThreadState *t;
        for (t = i->tstate_head; t != NULL; t = t->next) {
            PyObject *id;
            int stat;
            struct _frame *frame = t->frame;
            if (frame == NULL)
                continue;
            id = PyLong_FromLong(t->thread_id);
            if (id == NULL)
                goto Fail;
            stat = PyDict_SetItem(result, id, (PyObject *)frame);
            Py_DECREF(id);
            if (stat < 0)
                goto Fail;
        }
    }
    HEAD_UNLOCK();
    return result;
544 545

 Fail:
546 547 548
    HEAD_UNLOCK();
    Py_DECREF(result);
    return NULL;
549
}
550

551 552 553 554 555 556 557 558 559 560 561 562 563 564
/* Python "auto thread state" API. */
#ifdef WITH_THREAD

/* Keep this as a static, as it is not reliable!  It can only
   ever be compared to the state for the *current* thread.
   * If not equal, then it doesn't matter that the actual
     value may change immediately after comparison, as it can't
     possibly change to the current thread's state.
   * If equal, then the current thread holds the lock, so the value can't
     change until we yield the lock.
*/
static int
PyThreadState_IsCurrent(PyThreadState *tstate)
{
565 566 567
    /* Must be the tstate for this thread */
    assert(PyGILState_GetThisThreadState()==tstate);
    return tstate == _Py_atomic_load_relaxed(&_PyThreadState_Current);
568 569
}

Tim Peters's avatar
Tim Peters committed
570 571
/* Internal initialization/finalization functions called by
   Py_Initialize/Py_Finalize
572
*/
573 574
void
_PyGILState_Init(PyInterpreterState *i, PyThreadState *t)
575
{
576 577
    assert(i && t); /* must init with valid states */
    autoTLSkey = PyThread_create_key();
578 579
    if (autoTLSkey == -1)
        Py_FatalError("Could not allocate TLS entry");
580 581 582
    autoInterpreterState = i;
    assert(PyThread_get_key_value(autoTLSkey) == NULL);
    assert(t->gilstate_counter == 0);
Michael W. Hudson's avatar
Michael W. Hudson committed
583

584
    _PyGILState_NoteThreadState(t);
585 586
}

587 588
void
_PyGILState_Fini(void)
589
{
590 591
    PyThread_delete_key(autoTLSkey);
    autoInterpreterState = NULL;
592 593
}

594
/* Reset the TLS key - called by PyOS_AfterFork().
595
 * This should not be necessary, but some - buggy - pthread implementations
596
 * don't reset TLS upon fork(), see issue #10517.
597 598 599 600 601 602 603 604 605
 */
void
_PyGILState_Reinit(void)
{
    PyThreadState *tstate = PyGILState_GetThisThreadState();
    PyThread_delete_key(autoTLSkey);
    if ((autoTLSkey = PyThread_create_key()) == -1)
        Py_FatalError("Could not allocate TLS entry");

606 607 608
    /* If the thread had an associated auto thread state, reassociate it with
     * the new key. */
    if (tstate && PyThread_set_key_value(autoTLSkey, (void *)tstate) < 0)
609 610 611
        Py_FatalError("Couldn't create autoTLSkey mapping");
}

Michael W. Hudson's avatar
Michael W. Hudson committed
612 613 614 615 616
/* When a thread state is created for a thread by some mechanism other than
   PyGILState_Ensure, it's important that the GILState machinery knows about
   it so it doesn't try to create another thread state for the thread (this is
   a better fix for SF bug #1010677 than the first one attempted).
*/
617
static void
Michael W. Hudson's avatar
Michael W. Hudson committed
618 619
_PyGILState_NoteThreadState(PyThreadState* tstate)
{
620 621 622 623
    /* If autoTLSkey isn't initialized, this must be the very first
       threadstate created in Py_Initialize().  Don't do anything for now
       (we'll be back here when _PyGILState_Init is called). */
    if (!autoInterpreterState)
624
        return;
625

626
    /* Stick the thread state for this thread in thread local storage.
Michael W. Hudson's avatar
Michael W. Hudson committed
627

628 629 630
       The only situation where you can legitimately have more than one
       thread state for an OS level thread is when there are multiple
       interpreters, when:
631

632 633
           a) You shouldn't really be using the PyGILState_ APIs anyway,
          and:
Michael W. Hudson's avatar
Michael W. Hudson committed
634

635 636 637 638 639 640 641
           b) The slightly odd way PyThread_set_key_value works (see
          comments by its implementation) means that the first thread
          state created for that given OS level thread will "win",
          which seems reasonable behaviour.
    */
    if (PyThread_set_key_value(autoTLSkey, (void *)tstate) < 0)
        Py_FatalError("Couldn't create autoTLSkey mapping");
Michael W. Hudson's avatar
Michael W. Hudson committed
642

643 644
    /* PyGILState_Release must not try to delete this thread state. */
    tstate->gilstate_counter = 1;
Michael W. Hudson's avatar
Michael W. Hudson committed
645 646
}

647
/* The public functions */
648 649
PyThreadState *
PyGILState_GetThisThreadState(void)
650
{
651
    if (autoInterpreterState == NULL)
652 653
        return NULL;
    return (PyThreadState *)PyThread_get_key_value(autoTLSkey);
654 655
}

656 657
PyGILState_STATE
PyGILState_Ensure(void)
658
{
659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688
    int current;
    PyThreadState *tcur;
    /* Note that we do not auto-init Python here - apart from
       potential races with 2 threads auto-initializing, pep-311
       spells out other issues.  Embedders are expected to have
       called Py_Initialize() and usually PyEval_InitThreads().
    */
    assert(autoInterpreterState); /* Py_Initialize() hasn't been called! */
    tcur = (PyThreadState *)PyThread_get_key_value(autoTLSkey);
    if (tcur == NULL) {
        /* Create a new thread state for this thread */
        tcur = PyThreadState_New(autoInterpreterState);
        if (tcur == NULL)
            Py_FatalError("Couldn't create thread-state for new thread");
        /* This is our thread state!  We'll need to delete it in the
           matching call to PyGILState_Release(). */
        tcur->gilstate_counter = 0;
        current = 0; /* new thread state is never current */
    }
    else
        current = PyThreadState_IsCurrent(tcur);
    if (current == 0)
        PyEval_RestoreThread(tcur);
    /* Update our counter in the thread-state - no need for locks:
       - tcur will remain valid as we hold the GIL.
       - the counter is safe as we are the only thread "allowed"
         to modify this value
    */
    ++tcur->gilstate_counter;
    return current ? PyGILState_LOCKED : PyGILState_UNLOCKED;
689 690
}

691 692
void
PyGILState_Release(PyGILState_STATE oldstate)
693
{
694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726
    PyThreadState *tcur = (PyThreadState *)PyThread_get_key_value(
                                                            autoTLSkey);
    if (tcur == NULL)
        Py_FatalError("auto-releasing thread-state, "
                      "but no thread-state for this thread");
    /* We must hold the GIL and have our thread state current */
    /* XXX - remove the check - the assert should be fine,
       but while this is very new (April 2003), the extra check
       by release-only users can't hurt.
    */
    if (! PyThreadState_IsCurrent(tcur))
        Py_FatalError("This thread state must be current when releasing");
    assert(PyThreadState_IsCurrent(tcur));
    --tcur->gilstate_counter;
    assert(tcur->gilstate_counter >= 0); /* illegal counter value */

    /* If we're going to destroy this thread-state, we must
     * clear it while the GIL is held, as destructors may run.
     */
    if (tcur->gilstate_counter == 0) {
        /* can't have been locked when we created it */
        assert(oldstate == PyGILState_UNLOCKED);
        PyThreadState_Clear(tcur);
        /* Delete the thread-state.  Note this releases the GIL too!
         * It's vital that the GIL be held here, to avoid shutdown
         * races; see bugs 225673 and 1061968 (that nasty bug has a
         * habit of coming back).
         */
        PyThreadState_DeleteCurrent();
    }
    /* Release the lock if necessary */
    else if (oldstate == PyGILState_UNLOCKED)
        PyEval_SaveThread();
727
}
728

729 730
#endif /* WITH_THREAD */

731 732 733 734 735
#ifdef __cplusplus
}
#endif