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

#include "Python.h"

#include "pycore_ceval.h"

#include "pycore_initconfig.h"

#include "pycore_pyerrors.h"

#include "pycore_pylifecycle.h"

#include "pycore_pymem.h" // _PyMem_SetDefaultAllocator()

#include "pycore_pystate.h" // _PyThreadState_GET()

#include "pycore_sysmodule.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_InitRuntimeState(&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);

}

#ifdef HAVE_FORK

/* This function is called from PyOS_AfterFork_Child to ensure that

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

PyStatus

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

int reinit_interp = _PyThread_at_fork_reinit(&runtime->interpreters.mutex);

int reinit_main_id = _PyThread_at_fork_reinit(&runtime->interpreters.main->id_mutex);

int reinit_xidregistry = _PyThread_at_fork_reinit(&runtime->xidregistry.mutex);

PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

if (reinit_interp < 0

|| reinit_main_id < 0

|| reinit_xidregistry < 0)

{

return _PyStatus_ERR("Failed to reinitialize runtime locks");

}

return _PyStatus_OK();

}

#endif

#define HEAD_LOCK(runtime) \

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

#define HEAD_UNLOCK(runtime) \

PyThread_release_lock((runtime)->interpreters.mutex)

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

{

PyThreadState *tstate = _PyThreadState_GET();

/* tstate is NULL when Py_InitializeFromConfig() calls

PyInterpreterState_New() to create the main interpreter. */

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

return NULL;

}

PyInterpreterState *interp = PyMem_RawCalloc(1, sizeof(PyInterpreterState));

if (interp == NULL) {

return NULL;

}

interp->id_refcount = -1;

/* Don't get runtime from tstate since tstate can be NULL */

_PyRuntimeState *runtime = &_PyRuntime;

interp->runtime = runtime;

if (_PyEval_InitState(&interp->ceval) < 0) {

goto out_of_memory;

}

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

if (tstate != NULL) {

_PyErr_SetString(tstate, 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;

out_of_memory:

if (tstate != NULL) {

_PyErr_NoMemory(tstate);

}

PyMem_RawFree(interp);

return NULL;

}

static void

interpreter_clear(PyInterpreterState *interp, PyThreadState *tstate)

{

_PyRuntimeState *runtime = interp->runtime;

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

_PyErr_Clear(tstate);

}

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

}

/* Last garbage collection on this interpreter */

_PyGC_CollectNoFail(tstate);

_PyGC_Fini(tstate);

/* We don't clear sysdict and builtins until the end of this function.

Because clearing other attributes can execute arbitrary Python code

which requires sysdict and builtins. */

PyDict_Clear(interp->sysdict);

PyDict_Clear(interp->builtins);

Py_CLEAR(interp->sysdict);

Py_CLEAR(interp->builtins);

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

}

void

PyInterpreterState_Clear(PyInterpreterState *interp)

{

// Use the current Python thread state to call audit hooks and to collect

// garbage. It can be different than the current Python thread state

// of 'interp'.

PyThreadState *current_tstate = _PyThreadState_GET();

interpreter_clear(interp, current_tstate);

}

void

_PyInterpreterState_Clear(PyThreadState *tstate)

{

interpreter_clear(tstate->interp, tstate);

}

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

_PyEval_FiniState(&interp->ceval);

/* 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("NULL interpreter");

}

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

}

#ifdef HAVE_FORK

/*

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

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

*/

PyStatus

_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) {

return _PyStatus_ERR("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) {

return _PyStatus_ERR("missing main interpreter");

}

_PyThreadState_Swap(gilstate, tstate);

return _PyStatus_OK();

}

#endif

PyInterpreterState *

PyInterpreterState_Get(void)

{

PyThreadState *tstate = _PyThreadState_GET();

_Py_EnsureTstateNotNULL(tstate);

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, int64_t requested_id)

{

PyInterpreterState *interp = runtime->interpreters.head;

while (interp != NULL) {

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

}

static PyThreadState *

new_threadstate(PyInterpreterState *interp, int init)

{

_PyRuntimeState *runtime = interp->runtime;

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

if (tstate == NULL) {

return NULL;

}

tstate->interp = interp;

tstate->frame = NULL;

tstate->recursion_depth = 0;

tstate->overflowed = 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();

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

return -1;

}

if (def->m_slots) {

_PyErr_SetString(tstate,

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_FatalErrorFormat(__func__, "module %p already added", module);

return -1;

}

return _PyState_AddModule(tstate, module, def);

}

int

PyState_RemoveModule(struct PyModuleDef* def)

{

PyThreadState *tstate = _PyThreadState_GET();

PyInterpreterState *interp = tstate->interp;

if (def->m_slots) {

_PyErr_SetString(tstate,

PyExc_SystemError,

"PyState_RemoveModule called on module with slots");

return -1;

}

Py_ssize_t index = def->m_base.m_index;

if (index == 0) {

Py_FatalError("invalid module index");

}

if (interp->modules_by_index == NULL) {

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

}

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

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

}

Py_INCREF(Py_None);

return PyList_SetItem(interp->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 = _PyInterpreterState_GetConfig(tstate->interp)->verbose;

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

/* bpo-20526: After the main thread calls

_PyRuntimeState_SetFinalizing() in Py_FinalizeEx(), threads must

exit when trying to take the GIL. If a thread exit in the middle of

_PyEval_EvalFrameDefault(), tstate->frame is not reset to its

previous value. It is more likely with daemon threads, but it can

happen with regular threads if threading._shutdown() fails

(ex: interrupted by CTRL+C). */

fprintf(stderr,

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

}

/* Don't clear tstate->frame: it is a borrowed reference */

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)

{

_Py_EnsureTstateNotNULL(tstate);

PyInterpreterState *interp = tstate->interp;

if (interp == NULL) {

Py_FatalError("NULL interpreter");

}

_PyRuntimeState *runtime = interp->runtime;

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

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_FatalErrorFormat(__func__, "tstate %p is still current", tstate);

}

}

tstate_delete_common(tstate, gilstate);

PyMem_RawFree(tstate);

}

void

PyThreadState_Delete(PyThreadState *tstate)

{

_PyThreadState_Delete(tstate, 1);

}

void

_PyThreadState_DeleteCurrent(PyThreadState *tstate)

{

_Py_EnsureTstateNotNULL(tstate);

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

tstate_delete_common(tstate, gilstate);

_PyRuntimeGILState_SetThreadState(gilstate, NULL);

_PyEval_ReleaseLock(tstate);

PyMem_RawFree(tstate);

}

void

PyThreadState_DeleteCurrent(void)

{

struct _gilstate_runtime_state *gilstate = &_PyRuntime.gilstate;

PyThreadState *tstate = _PyRuntimeGILState_GetThreadState(gilstate);

_PyThreadState_DeleteCurrent(tstate);

}

/*

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

}

}

#ifdef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS

PyThreadState*

_PyThreadState_GetTSS(void) {

return PyThread_tss_get(&_PyRuntime.gilstate.autoTSSkey);

}

#endif

PyThreadState *

_PyThreadState_UncheckedGet(void)

{

return _PyThreadState_GET();

}

PyThreadState *

PyThreadState_Get(void)

{

PyThreadState *tstate = _PyThreadState_GET();

_Py_EnsureTstateNotNULL(tstate);

return tstate;

}

PyThreadState *

_PyThreadState_Swap(struct _gilstate_runtime_state *gilstate, PyThreadState *newts)

{