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

#include "Python.h"

#include "pycore_ceval.h"

#include "pycore_initconfig.h"

#include "pycore_pymem.h"

#include "pycore_pystate.h"

#include "pycore_pylifecycle.h"

/* --------------------------------------------------------------------------

CAUTION

Always use PyMem_RawMalloc() and PyMem_RawFree() 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).

-------------------------------------------------------------------------- */

#ifdef HAVE_DLOPEN

#ifdef HAVE_DLFCN_H

#include <dlfcn.h>

#endif

#if !HAVE_DECL_RTLD_LAZY

#define RTLD_LAZY 1

#endif

#endif

#ifdef __cplusplus

extern "C" {

#endif

#define _PyRuntimeGILState_GetThreadState(gilstate) \

((PyThreadState*)_Py_atomic_load_relaxed(&(gilstate)->tstate_current))

#define _PyRuntimeGILState_SetThreadState(gilstate, value) \

_Py_atomic_store_relaxed(&(gilstate)->tstate_current, \

(uintptr_t)(value))

/* Forward declarations */

static PyThreadState *_PyGILState_GetThisThreadState(struct _gilstate_runtime_state *gilstate);

static void _PyThreadState_Delete(PyThreadState *tstate, int check_current);

static PyStatus

_PyRuntimeState_Init_impl(_PyRuntimeState *runtime)

{

/* We preserve the hook across init, because there is

currently no public API to set it between runtime

initialization and interpreter initialization. */

void *open_code_hook = runtime->open_code_hook;

void *open_code_userdata = runtime->open_code_userdata;

_Py_AuditHookEntry *audit_hook_head = runtime->audit_hook_head;

memset(runtime, 0, sizeof(*runtime));

runtime->open_code_hook = open_code_hook;

runtime->open_code_userdata = open_code_userdata;

runtime->audit_hook_head = audit_hook_head;

_PyEval_Initialize(&runtime->ceval);

PyPreConfig_InitPythonConfig(&runtime->preconfig);

runtime->gilstate.check_enabled = 1;

/* A TSS key must be initialized with Py_tss_NEEDS_INIT

in accordance with the specification. */

Py_tss_t initial = Py_tss_NEEDS_INIT;

runtime->gilstate.autoTSSkey = initial;

runtime->interpreters.mutex = PyThread_allocate_lock();

if (runtime->interpreters.mutex == NULL) {

return _PyStatus_ERR("Can't initialize threads for interpreter");

}

runtime->interpreters.next_id = -1;

runtime->xidregistry.mutex = PyThread_allocate_lock();

if (runtime->xidregistry.mutex == NULL) {

return _PyStatus_ERR("Can't initialize threads for cross-interpreter data registry");

}

// Set it to the ID of the main thread of the main interpreter.

runtime->main_thread = PyThread_get_thread_ident();

return _PyStatus_OK();

}

PyStatus

_PyRuntimeState_Init(_PyRuntimeState *runtime)

{

/* Force default allocator, since _PyRuntimeState_Fini() must

use the same allocator than this function. */

PyMemAllocatorEx old_alloc;

_PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

PyStatus status = _PyRuntimeState_Init_impl(runtime);

PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

return status;

}

void

_PyRuntimeState_Fini(_PyRuntimeState *runtime)

{

/* Force the allocator used by _PyRuntimeState_Init(). */

PyMemAllocatorEx old_alloc;

_PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

if (runtime->interpreters.mutex != NULL) {

PyThread_free_lock(runtime->interpreters.mutex);

runtime->interpreters.mutex = NULL;

}

if (runtime->xidregistry.mutex != NULL) {

PyThread_free_lock(runtime->xidregistry.mutex);

runtime->xidregistry.mutex = NULL;

}

PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

}

/* This function is called from PyOS_AfterFork_Child to ensure that

* newly created child processes do not share locks with the parent.

*/

void

_PyRuntimeState_ReInitThreads(_PyRuntimeState *runtime)

{

// This was initially set in _PyRuntimeState_Init().

runtime->main_thread = PyThread_get_thread_ident();

/* Force default allocator, since _PyRuntimeState_Fini() must

use the same allocator than this function. */

PyMemAllocatorEx old_alloc;

_PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

runtime->interpreters.mutex = PyThread_allocate_lock();

runtime->interpreters.main->id_mutex = PyThread_allocate_lock();

runtime->xidregistry.mutex = PyThread_allocate_lock();

PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

if (runtime->interpreters.mutex == NULL) {

Py_FatalError("Can't initialize lock for runtime interpreters");

}

if (runtime->interpreters.main->id_mutex == NULL) {

Py_FatalError("Can't initialize ID lock for main interpreter");

}

if (runtime->xidregistry.mutex == NULL) {

Py_FatalError("Can't initialize lock for cross-interpreter data registry");

}

}

#define HEAD_LOCK(runtime) \

PyThread_acquire_lock((runtime)->interpreters.mutex, WAIT_LOCK)

#define HEAD_UNLOCK(runtime) \

PyThread_release_lock((runtime)->interpreters.mutex)

int

_Py_IsMainInterpreter(PyThreadState* tstate)

{

return (tstate->interp == tstate->interp->runtime->interpreters.main);

}

/* Forward declaration */

static void _PyGILState_NoteThreadState(

struct _gilstate_runtime_state *gilstate, PyThreadState* tstate);

PyStatus

_PyInterpreterState_Enable(_PyRuntimeState *runtime)

{

struct pyinterpreters *interpreters = &runtime->interpreters;

interpreters->next_id = 0;

/* Py_Finalize() calls _PyRuntimeState_Fini() which clears the mutex.

Create a new mutex if needed. */

if (interpreters->mutex == NULL) {

/* Force default allocator, since _PyRuntimeState_Fini() must

use the same allocator than this function. */

PyMemAllocatorEx old_alloc;

_PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

interpreters->mutex = PyThread_allocate_lock();

PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

if (interpreters->mutex == NULL) {

return _PyStatus_ERR("Can't initialize threads for interpreter");

}

}

return _PyStatus_OK();

}

PyInterpreterState *

PyInterpreterState_New(void)

{

if (PySys_Audit("cpython.PyInterpreterState_New", NULL) < 0) {

return NULL;

}

PyInterpreterState *interp = PyMem_RawMalloc(sizeof(PyInterpreterState));

if (interp == NULL) {

return NULL;

}

memset(interp, 0, sizeof(*interp));

interp->id_refcount = -1;

_PyRuntimeState *runtime = &_PyRuntime;

interp->runtime = runtime;

_PyGC_InitState(&interp->gc);

PyConfig_InitPythonConfig(&interp->config);

interp->eval_frame = _PyEval_EvalFrameDefault;

#ifdef HAVE_DLOPEN

#if HAVE_DECL_RTLD_NOW

interp->dlopenflags = RTLD_NOW;

#else

interp->dlopenflags = RTLD_LAZY;

#endif

#endif

struct pyinterpreters *interpreters = &runtime->interpreters;

HEAD_LOCK(runtime);

if (interpreters->next_id < 0) {

/* overflow or Py_Initialize() not called! */

PyErr_SetString(PyExc_RuntimeError,

"failed to get an interpreter ID");

PyMem_RawFree(interp);

interp = NULL;

}

else {

interp->id = interpreters->next_id;

interpreters->next_id += 1;

interp->next = interpreters->head;

if (interpreters->main == NULL) {

interpreters->main = interp;

}

interpreters->head = interp;

}

HEAD_UNLOCK(runtime);

if (interp == NULL) {

return NULL;

}

interp->tstate_next_unique_id = 0;

interp->audit_hooks = NULL;

return interp;

}

void

PyInterpreterState_Clear(PyInterpreterState *interp)

{

_PyRuntimeState *runtime = interp->runtime;

if (PySys_Audit("cpython.PyInterpreterState_Clear", NULL) < 0) {

PyErr_Clear();

}

HEAD_LOCK(runtime);

for (PyThreadState *p = interp->tstate_head; p != NULL; p = p->next) {

PyThreadState_Clear(p);

}

HEAD_UNLOCK(runtime);

Py_CLEAR(interp->audit_hooks);

PyConfig_Clear(&interp->config);

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);

Py_CLEAR(interp->builtins_copy);

Py_CLEAR(interp->importlib);

Py_CLEAR(interp->import_func);

Py_CLEAR(interp->dict);

#ifdef HAVE_FORK

Py_CLEAR(interp->before_forkers);

Py_CLEAR(interp->after_forkers_parent);

Py_CLEAR(interp->after_forkers_child);

#endif

if (_PyRuntimeState_GetFinalizing(runtime) == NULL) {

_PyWarnings_Fini(interp);

}

// XXX Once we have one allocator per interpreter (i.e.

// per-interpreter GC) we must ensure that all of the interpreter's

// objects have been cleaned up at the point.

}

static void

zapthreads(PyInterpreterState *interp, int check_current)

{

PyThreadState *tstate;

/* No need to lock the mutex here because this should only happen

when the threads are all really dead (XXX famous last words). */

while ((tstate = interp->tstate_head) != NULL) {

_PyThreadState_Delete(tstate, check_current);

}

}

void

PyInterpreterState_Delete(PyInterpreterState *interp)

{

_PyRuntimeState *runtime = interp->runtime;

struct pyinterpreters *interpreters = &runtime->interpreters;

zapthreads(interp, 0);

/* Delete current thread. After this, many C API calls become crashy. */

_PyThreadState_Swap(&runtime->gilstate, NULL);

HEAD_LOCK(runtime);

PyInterpreterState **p;

for (p = &interpreters->head; ; p = &(*p)->next) {

if (*p == NULL) {

Py_FatalError("invalid interp");

}

if (*p == interp) {

break;

}

}

if (interp->tstate_head != NULL) {

Py_FatalError("remaining threads");

}

*p = interp->next;

if (interpreters->main == interp) {

interpreters->main = NULL;

if (interpreters->head != NULL) {

Py_FatalError("remaining subinterpreters");

}

}

HEAD_UNLOCK(runtime);

if (interp->id_mutex != NULL) {

PyThread_free_lock(interp->id_mutex);

}

PyMem_RawFree(interp);

}

/*

* Delete all interpreter states except the main interpreter. If there

* is a current interpreter state, it *must* be the main interpreter.

*/

void

_PyInterpreterState_DeleteExceptMain(_PyRuntimeState *runtime)

{

struct _gilstate_runtime_state *gilstate = &runtime->gilstate;

struct pyinterpreters *interpreters = &runtime->interpreters;

PyThreadState *tstate = _PyThreadState_Swap(gilstate, NULL);

if (tstate != NULL && tstate->interp != interpreters->main) {

Py_FatalError("not main interpreter");

}

HEAD_LOCK(runtime);

PyInterpreterState *interp = interpreters->head;

interpreters->head = NULL;

while (interp != NULL) {

if (interp == interpreters->main) {

interpreters->main->next = NULL;

interpreters->head = interp;

interp = interp->next;

continue;

}

PyInterpreterState_Clear(interp); // XXX must activate?

zapthreads(interp, 1);

if (interp->id_mutex != NULL) {

PyThread_free_lock(interp->id_mutex);

}

PyInterpreterState *prev_interp = interp;

interp = interp->next;

PyMem_RawFree(prev_interp);

}

HEAD_UNLOCK(runtime);

if (interpreters->head == NULL) {

Py_FatalError("missing main");

}

_PyThreadState_Swap(gilstate, tstate);

}

PyInterpreterState *

PyInterpreterState_Get(void)

{

PyThreadState *tstate = _PyThreadState_GET();

if (tstate == NULL) {

Py_FatalError("no current thread state");

}

PyInterpreterState *interp = tstate->interp;

if (interp == NULL) {

Py_FatalError("no current interpreter");

}

return interp;

}

int64_t

PyInterpreterState_GetID(PyInterpreterState *interp)

{

if (interp == NULL) {

PyErr_SetString(PyExc_RuntimeError, "no interpreter provided");

return -1;

}

return interp->id;

}

static PyInterpreterState *

interp_look_up_id(_PyRuntimeState *runtime, PY_INT64_T requested_id)

{

PyInterpreterState *interp = runtime->interpreters.head;

while (interp != NULL) {

PY_INT64_T id = PyInterpreterState_GetID(interp);

if (id < 0) {

return NULL;

}

if (requested_id == id) {

return interp;

}

interp = PyInterpreterState_Next(interp);

}

return NULL;

}

PyInterpreterState *

_PyInterpreterState_LookUpID(PY_INT64_T requested_id)

{

PyInterpreterState *interp = NULL;

if (requested_id >= 0) {

_PyRuntimeState *runtime = &_PyRuntime;

HEAD_LOCK(runtime);

interp = interp_look_up_id(runtime, requested_id);

HEAD_UNLOCK(runtime);

}

if (interp == NULL && !PyErr_Occurred()) {

PyErr_Format(PyExc_RuntimeError,

"unrecognized interpreter ID %lld", requested_id);

}

return interp;

}

int

_PyInterpreterState_IDInitref(PyInterpreterState *interp)

{

if (interp->id_mutex != NULL) {

return 0;

}

interp->id_mutex = PyThread_allocate_lock();

if (interp->id_mutex == NULL) {

PyErr_SetString(PyExc_RuntimeError,

"failed to create init interpreter ID mutex");

return -1;

}

interp->id_refcount = 0;

return 0;

}

void

_PyInterpreterState_IDIncref(PyInterpreterState *interp)

{

if (interp->id_mutex == NULL) {

return;

}

PyThread_acquire_lock(interp->id_mutex, WAIT_LOCK);

interp->id_refcount += 1;

PyThread_release_lock(interp->id_mutex);

}

void

_PyInterpreterState_IDDecref(PyInterpreterState *interp)

{

if (interp->id_mutex == NULL) {

return;

}

struct _gilstate_runtime_state *gilstate = &_PyRuntime.gilstate;

PyThread_acquire_lock(interp->id_mutex, WAIT_LOCK);

assert(interp->id_refcount != 0);

interp->id_refcount -= 1;

int64_t refcount = interp->id_refcount;

PyThread_release_lock(interp->id_mutex);

if (refcount == 0 && interp->requires_idref) {

// XXX Using the "head" thread isn't strictly correct.

PyThreadState *tstate = PyInterpreterState_ThreadHead(interp);

// XXX Possible GILState issues?

PyThreadState *save_tstate = _PyThreadState_Swap(gilstate, tstate);

Py_EndInterpreter(tstate);

_PyThreadState_Swap(gilstate, save_tstate);

}

}

int

_PyInterpreterState_RequiresIDRef(PyInterpreterState *interp)

{

return interp->requires_idref;

}

void

_PyInterpreterState_RequireIDRef(PyInterpreterState *interp, int required)

{

interp->requires_idref = required ? 1 : 0;

}

PyObject *

_PyInterpreterState_GetMainModule(PyInterpreterState *interp)

{

if (interp->modules == NULL) {

PyErr_SetString(PyExc_RuntimeError, "interpreter not initialized");

return NULL;

}

return PyMapping_GetItemString(interp->modules, "__main__");

}

PyObject *

PyInterpreterState_GetDict(PyInterpreterState *interp)

{

if (interp->dict == NULL) {

interp->dict = PyDict_New();

if (interp->dict == NULL) {

PyErr_Clear();

}

}

/* Returning NULL means no per-interpreter dict is available. */

return interp->dict;

}

/* Default implementation for _PyThreadState_GetFrame */

static struct _frame *

threadstate_getframe(PyThreadState *self)

{

return self->frame;

}

static PyThreadState *

new_threadstate(PyInterpreterState *interp, int init)

{

_PyRuntimeState *runtime = interp->runtime;

PyThreadState *tstate = (PyThreadState *)PyMem_RawMalloc(sizeof(PyThreadState));

if (tstate == NULL) {

return NULL;

}

if (_PyThreadState_GetFrame == NULL) {

_PyThreadState_GetFrame = threadstate_getframe;

}

tstate->interp = interp;

tstate->frame = NULL;

tstate->recursion_depth = 0;

tstate->overflowed = 0;

tstate->recursion_critical = 0;

tstate->stackcheck_counter = 0;

tstate->tracing = 0;

tstate->use_tracing = 0;

tstate->gilstate_counter = 0;

tstate->async_exc = NULL;

tstate->thread_id = PyThread_get_thread_ident();

tstate->dict = NULL;

tstate->curexc_type = NULL;

tstate->curexc_value = NULL;

tstate->curexc_traceback = NULL;

tstate->exc_state.exc_type = NULL;

tstate->exc_state.exc_value = NULL;

tstate->exc_state.exc_traceback = NULL;

tstate->exc_state.previous_item = NULL;

tstate->exc_info = &tstate->exc_state;

tstate->c_profilefunc = NULL;

tstate->c_tracefunc = NULL;

tstate->c_profileobj = NULL;

tstate->c_traceobj = NULL;

tstate->trash_delete_nesting = 0;

tstate->trash_delete_later = NULL;

tstate->on_delete = NULL;

tstate->on_delete_data = NULL;

tstate->coroutine_origin_tracking_depth = 0;

tstate->async_gen_firstiter = NULL;

tstate->async_gen_finalizer = NULL;

tstate->context = NULL;

tstate->context_ver = 1;

if (init) {

_PyThreadState_Init(tstate);

}

HEAD_LOCK(runtime);

tstate->id = ++interp->tstate_next_unique_id;

tstate->prev = NULL;

tstate->next = interp->tstate_head;

if (tstate->next)

tstate->next->prev = tstate;

interp->tstate_head = tstate;

HEAD_UNLOCK(runtime);

return tstate;

}

PyThreadState *

PyThreadState_New(PyInterpreterState *interp)

{

return new_threadstate(interp, 1);

}

PyThreadState *

_PyThreadState_Prealloc(PyInterpreterState *interp)

{

return new_threadstate(interp, 0);

}

void

_PyThreadState_Init(PyThreadState *tstate)

{

_PyGILState_NoteThreadState(&tstate->interp->runtime->gilstate, tstate);

}

PyObject*

PyState_FindModule(struct PyModuleDef* module)

{

Py_ssize_t index = module->m_base.m_index;

PyInterpreterState *state = _PyInterpreterState_GET_UNSAFE();

PyObject *res;

if (module->m_slots) {

return NULL;

}

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;

}

int

_PyState_AddModule(PyThreadState *tstate, PyObject* module, struct PyModuleDef* def)

{

if (!def) {

assert(PyErr_Occurred());

return -1;

}

if (def->m_slots) {

PyErr_SetString(PyExc_SystemError,

"PyState_AddModule called on module with slots");

return -1;

}

PyInterpreterState *interp = tstate->interp;

if (!interp->modules_by_index) {

interp->modules_by_index = PyList_New(0);

if (!interp->modules_by_index) {

return -1;

}

}

while (PyList_GET_SIZE(interp->modules_by_index) <= def->m_base.m_index) {

if (PyList_Append(interp->modules_by_index, Py_None) < 0) {

return -1;

}

}

Py_INCREF(module);

return PyList_SetItem(interp->modules_by_index,

def->m_base.m_index, module);

}

int

PyState_AddModule(PyObject* module, struct PyModuleDef* def)

{

if (!def) {

Py_FatalError("Module Definition is NULL");

return -1;

}

PyThreadState *tstate = _PyThreadState_GET();

PyInterpreterState *interp = tstate->interp;

Py_ssize_t index = def->m_base.m_index;

if (interp->modules_by_index &&

index < PyList_GET_SIZE(interp->modules_by_index) &&

module == PyList_GET_ITEM(interp->modules_by_index, index))

{

Py_FatalError("Module already added");

return -1;

}

return _PyState_AddModule(tstate, module, def);

}

int

PyState_RemoveModule(struct PyModuleDef* def)

{

PyInterpreterState *state;

Py_ssize_t index = def->m_base.m_index;

if (def->m_slots) {

PyErr_SetString(PyExc_SystemError,

"PyState_RemoveModule called on module with slots");

return -1;

}

state = _PyInterpreterState_GET_UNSAFE();

if (index == 0) {

Py_FatalError("Module index invalid");

return -1;

}

if (state->modules_by_index == NULL) {

Py_FatalError("Interpreters module-list not accessible.");

return -1;

}

if (index > PyList_GET_SIZE(state->modules_by_index)) {

Py_FatalError("Module index out of bounds.");

return -1;

}

Py_INCREF(Py_None);

return PyList_SetItem(state->modules_by_index, index, Py_None);

}

/* Used by PyImport_Cleanup() */

void

_PyInterpreterState_ClearModules(PyInterpreterState *interp)

{

if (!interp->modules_by_index) {

return;

}

Py_ssize_t i;

for (i = 0; i < PyList_GET_SIZE(interp->modules_by_index); i++) {

PyObject *m = PyList_GET_ITEM(interp->modules_by_index, i);

if (PyModule_Check(m)) {

/* cleanup the saved copy of module dicts */

PyModuleDef *md = PyModule_GetDef(m);

if (md) {

Py_CLEAR(md->m_base.m_copy);

}

}

}

/* Setting modules_by_index to NULL could be dangerous, so we

clear the list instead. */

if (PyList_SetSlice(interp->modules_by_index,

0, PyList_GET_SIZE(interp->modules_by_index),

NULL)) {

PyErr_WriteUnraisable(interp->modules_by_index);

}

}

void

PyThreadState_Clear(PyThreadState *tstate)

{

int verbose = tstate->interp->config.verbose;

if (verbose && tstate->frame != NULL)

fprintf(stderr,

"PyThreadState_Clear: warning: thread still has a frame\n");

Py_CLEAR(tstate->frame);

Py_CLEAR(tstate->dict);

Py_CLEAR(tstate->async_exc);

Py_CLEAR(tstate->curexc_type);

Py_CLEAR(tstate->curexc_value);

Py_CLEAR(tstate->curexc_traceback);

Py_CLEAR(tstate->exc_state.exc_type);

Py_CLEAR(tstate->exc_state.exc_value);

Py_CLEAR(tstate->exc_state.exc_traceback);

/* The stack of exception states should contain just this thread. */

if (verbose && tstate->exc_info != &tstate->exc_state) {

fprintf(stderr,

"PyThreadState_Clear: warning: thread still has a generator\n");

}

tstate->c_profilefunc = NULL;

tstate->c_tracefunc = NULL;

Py_CLEAR(tstate->c_profileobj);

Py_CLEAR(tstate->c_traceobj);

Py_CLEAR(tstate->async_gen_firstiter);

Py_CLEAR(tstate->async_gen_finalizer);

Py_CLEAR(tstate->context);

if (tstate->on_delete != NULL) {

tstate->on_delete(tstate->on_delete_data);

}

}

/* Common code for PyThreadState_Delete() and PyThreadState_DeleteCurrent() */

static void

tstate_delete_common(PyThreadState *tstate,

struct _gilstate_runtime_state *gilstate)

{

_PyRuntimeState *runtime = tstate->interp->runtime;

if (tstate == NULL) {

Py_FatalError("NULL tstate");

}

PyInterpreterState *interp = tstate->interp;

if (interp == NULL) {

Py_FatalError("NULL interp");

}

HEAD_LOCK(runtime);

if (tstate->prev)

tstate->prev->next = tstate->next;

else

interp->tstate_head = tstate->next;

if (tstate->next)

tstate->next->prev = tstate->prev;

HEAD_UNLOCK(runtime);

PyMem_RawFree(tstate);

if (gilstate->autoInterpreterState &&

PyThread_tss_get(&gilstate->autoTSSkey) == tstate)

{

PyThread_tss_set(&gilstate->autoTSSkey, NULL);

}

}

static void

_PyThreadState_Delete(PyThreadState *tstate, int check_current)

{

struct _gilstate_runtime_state *gilstate = &tstate->interp->runtime->gilstate;

if (check_current) {

if (tstate == _PyRuntimeGILState_GetThreadState(gilstate)) {

Py_FatalError("tstate is still current");

}

}

tstate_delete_common(tstate, gilstate);

}

void

PyThreadState_Delete(PyThreadState *tstate)

{

_PyThreadState_Delete(tstate, 1);

}

void

_PyThreadState_DeleteCurrent(_PyRuntimeState *runtime)

{

struct _gilstate_runtime_state *gilstate = &runtime->gilstate;

PyThreadState *tstate = _PyRuntimeGILState_GetThreadState(gilstate);

if (tstate == NULL) {

Py_FatalError("no current tstate");

}

tstate_delete_common(tstate, gilstate);

_PyRuntimeGILState_SetThreadState(gilstate, NULL);

PyEval_ReleaseLock();

}

void

PyThreadState_DeleteCurrent(void)

{

_PyThreadState_DeleteCurrent(&_PyRuntime);

}

/*

* Delete all thread states except the one passed as argument.

* Note that, if there is a current thread state, it *must* be the one

* passed as argument. Also, this won't touch any other interpreters

* than the current one, since we don't know which thread state should

* be kept in those other interpreters.

*/

void

_PyThreadState_DeleteExcept(_PyRuntimeState *runtime, PyThreadState *tstate)

{

PyInterpreterState *interp = tstate->interp;

HEAD_LOCK(runtime);

/* Remove all thread states, except tstate, from the linked list of

thread states. This will allow calling PyThreadState_Clear()

without holding the lock. */

PyThreadState *list = interp->tstate_head;

if (list == tstate) {

list = tstate->next;

}

if (tstate->prev) {

tstate->prev->next = tstate->next;

}

if (tstate->next) {

tstate->next->prev = tstate->prev;

}

tstate->prev = tstate->next = NULL;

interp->tstate_head = tstate;

HEAD_UNLOCK(runtime);

/* Clear and deallocate all stale thread states. Even if this

executes Python code, we should be safe since it executes

in the current thread, not one of the stale threads. */

PyThreadState *p, *next;

for (p = list; p; p = next) {

next = p->next;

PyThreadState_Clear(p);

PyMem_RawFree(p);

}

}

PyThreadState *

_PyThreadState_UncheckedGet(void)

{

return _PyThreadState_GET();

}

PyThreadState *

PyThreadState_Get(void)

{

PyThreadState *tstate = _PyThreadState_GET();

if (tstate == NULL) {

Py_FatalError("no current thread");

}

return tstate;

}

PyThreadState *

_PyThreadState_Swap(struct _gilstate_runtime_state *gilstate, PyThreadState *newts)

{

PyThreadState *oldts = _PyRuntimeGILState_GetThreadState(gilstate);

_PyRuntimeGILState_SetThreadState(gilstate, 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.

*/

#if defined(Py_DEBUG)

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(gilstate);

if (check && check->interp == newts->interp && check != newts)

Py_FatalError("Invalid thread state for this thread");

errno = err;

}

#endif

return oldts;

}

PyThreadState *

PyThreadState_Swap(PyThreadState *newts)

{

return _PyThreadState_Swap(&_PyRuntime.gilstate, newts);

}

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

PyThreadState_GetDict() returns NULL, an exception has *not* been raised

and the caller should assume no per-thread state is available. */

PyObject *

PyThreadState_GetDict(void)

{

PyThreadState *tstate = _PyThreadState_GET();

if (tstate == NULL)

return NULL;

if (tstate->dict == NULL) {

PyObject *d;

tstate->dict = d = PyDict_New();

if (d == NULL)

PyErr_Clear();

}

return tstate->dict;

}