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

#include "Python.h"

#include "pycore_coreconfig.h"

#include "pycore_pymem.h"

#include "pycore_pystate.h"

#define _PyThreadState_SET(value) \

_Py_atomic_store_relaxed(&_PyRuntime.gilstate.tstate_current, \

(uintptr_t)(value))

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

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

static _PyInitError

_PyRuntimeState_Init_impl(_PyRuntimeState *runtime)

{

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

_PyGC_Initialize(&runtime->gc);

_PyEval_Initialize(&runtime->ceval);

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 _Py_INIT_ERR("Can't initialize threads for interpreter");

}

runtime->interpreters.next_id = -1;

runtime->xidregistry.mutex = PyThread_allocate_lock();

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

return _Py_INIT_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 _Py_INIT_OK();

}

_PyInitError

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

_PyInitError err = _PyRuntimeState_Init_impl(runtime);

PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

return err;

}

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(void)

{

// This was initially set in _PyRuntimeState_Init().

_PyRuntime.main_thread = PyThread_get_thread_ident();

_PyRuntime.interpreters.mutex = PyThread_allocate_lock();

if (_PyRuntime.interpreters.mutex == NULL) {

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

}

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

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

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

}

_PyRuntime.xidregistry.mutex = PyThread_allocate_lock();

if (_PyRuntime.xidregistry.mutex == NULL) {

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

}

}

#define HEAD_LOCK() PyThread_acquire_lock(_PyRuntime.interpreters.mutex, \

WAIT_LOCK)

#define HEAD_UNLOCK() PyThread_release_lock(_PyRuntime.interpreters.mutex)

static void _PyGILState_NoteThreadState(PyThreadState* tstate);

_PyInitError

_PyInterpreterState_Enable(_PyRuntimeState *runtime)

{

runtime->interpreters.next_id = 0;

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

Create a new mutex if needed. */

if (runtime->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);

runtime->interpreters.mutex = PyThread_allocate_lock();

PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

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

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

}

}

return _Py_INIT_OK();

}

PyInterpreterState *

PyInterpreterState_New(void)

{

PyInterpreterState *interp = (PyInterpreterState *)

PyMem_RawMalloc(sizeof(PyInterpreterState));

if (interp == NULL) {

return NULL;

}

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

interp->id_refcount = -1;

interp->check_interval = 100;

interp->core_config = _PyCoreConfig_INIT;

interp->config = _PyMainInterpreterConfig_INIT;

interp->eval_frame = _PyEval_EvalFrameDefault;

#ifdef HAVE_DLOPEN

#if HAVE_DECL_RTLD_NOW

interp->dlopenflags = RTLD_NOW;

#else

interp->dlopenflags = RTLD_LAZY;

#endif

#endif

HEAD_LOCK();

if (_PyRuntime.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 = _PyRuntime.interpreters.next_id;

_PyRuntime.interpreters.next_id += 1;

interp->next = _PyRuntime.interpreters.head;

if (_PyRuntime.interpreters.main == NULL) {

_PyRuntime.interpreters.main = interp;

}

_PyRuntime.interpreters.head = interp;

}

HEAD_UNLOCK();

if (interp == NULL) {

return NULL;

}

interp->tstate_next_unique_id = 0;

return interp;

}

void

PyInterpreterState_Clear(PyInterpreterState *interp)

{

PyThreadState *p;

HEAD_LOCK();

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

PyThreadState_Clear(p);

HEAD_UNLOCK();

_PyCoreConfig_Clear(&interp->core_config);

_PyMainInterpreterConfig_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

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

{

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

}

}

void

PyInterpreterState_Delete(PyInterpreterState *interp)

{

PyInterpreterState **p;

zapthreads(interp);

HEAD_LOCK();

for (p = &_PyRuntime.interpreters.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;

if (_PyRuntime.interpreters.main == interp) {

_PyRuntime.interpreters.main = NULL;

if (_PyRuntime.interpreters.head != NULL)

Py_FatalError("PyInterpreterState_Delete: remaining subinterpreters");

}

HEAD_UNLOCK();

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

{

PyThreadState *tstate = PyThreadState_Swap(NULL);

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

Py_FatalError("PyInterpreterState_DeleteExceptMain: not main interpreter");

}

HEAD_LOCK();

PyInterpreterState *interp = _PyRuntime.interpreters.head;

_PyRuntime.interpreters.head = NULL;

while (interp != NULL) {

if (interp == _PyRuntime.interpreters.main) {

_PyRuntime.interpreters.main->next = NULL;

_PyRuntime.interpreters.head = interp;

interp = interp->next;

continue;

}

PyInterpreterState_Clear(interp); // XXX must activate?

zapthreads(interp);

if (interp->id_mutex != NULL) {

PyThread_free_lock(interp->id_mutex);

}

PyInterpreterState *prev_interp = interp;

interp = interp->next;

PyMem_RawFree(prev_interp);

}

HEAD_UNLOCK();

if (_PyRuntime.interpreters.head == NULL) {

Py_FatalError("PyInterpreterState_DeleteExceptMain: missing main");

}

PyThreadState_Swap(tstate);

}

PyInterpreterState *

_PyInterpreterState_Get(void)

{

PyThreadState *tstate = _PyThreadState_GET();

if (tstate == NULL) {

Py_FatalError("_PyInterpreterState_Get(): no current thread state");

}

PyInterpreterState *interp = tstate->interp;

if (interp == NULL) {

Py_FatalError("_PyInterpreterState_Get(): 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(PY_INT64_T requested_id)

{

PyInterpreterState *interp = PyInterpreterState_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) {

HEAD_LOCK();

interp = interp_look_up_id(requested_id);

HEAD_UNLOCK();

}

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;

}

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

Py_EndInterpreter(tstate);

PyThreadState_Swap(save_tstate);

}

}

int

_PyInterpreterState_RequiresIDRef(PyInterpreterState *interp)

{

return interp->requires_idref;

}

void

_PyInterpreterState_RequireIDRef(PyInterpreterState *interp, int required)

{

interp->requires_idref = required ? 1 : 0;

}

_PyCoreConfig *

_PyInterpreterState_GetCoreConfig(PyInterpreterState *interp)

{

return &interp->core_config;

}

_PyMainInterpreterConfig *

_PyInterpreterState_GetMainConfig(PyInterpreterState *interp)

{

return &interp->config;

}

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)

{

PyThreadState *tstate = (PyThreadState *)PyMem_RawMalloc(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->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->coroutine_wrapper = NULL;

tstate->in_coroutine_wrapper = 0;

tstate->async_gen_firstiter = NULL;

tstate->async_gen_finalizer = NULL;

tstate->context = NULL;

tstate->context_ver = 1;

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

if (init)

_PyThreadState_Init(tstate);

HEAD_LOCK();

tstate->prev = NULL;

tstate->next = interp->tstate_head;

if (tstate->next)

tstate->next->prev = tstate;

interp->tstate_head = tstate;

HEAD_UNLOCK();

}

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

}

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(PyObject* module, struct PyModuleDef* def)

{

PyInterpreterState *state;

if (!def) {

assert(PyErr_Occurred());

return -1;

}

if (def->m_slots) {

PyErr_SetString(PyExc_SystemError,

"PyState_AddModule called on module with slots");

return -1;

}

state = _PyInterpreterState_GET_UNSAFE();

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

}

int

PyState_AddModule(PyObject* module, struct PyModuleDef* def)

{

Py_ssize_t index;

PyInterpreterState *state = _PyInterpreterState_GET_UNSAFE();

if (!def) {

Py_FatalError("PyState_AddModule: Module Definition is NULL");

return -1;

}

index = def->m_base.m_index;

if (state->modules_by_index) {

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

if(module == PyList_GET_ITEM(state->modules_by_index, index)) {

Py_FatalError("PyState_AddModule: Module already added!");

return -1;

}

}

}

return _PyState_AddModule(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("PyState_RemoveModule: Module index invalid.");

return -1;

}

if (state->modules_by_index == NULL) {

Py_FatalError("PyState_RemoveModule: Interpreters module-list not acessible.");

return -1;

}

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

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

return -1;

}

Py_INCREF(Py_None);

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

}

/* used by import.c:PyImport_Cleanup */

void

_PyState_ClearModules(void)

{

PyInterpreterState *state = _PyInterpreterState_GET_UNSAFE();

if (state->modules_by_index) {

Py_ssize_t i;

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

PyObject *m = PyList_GET_ITEM(state->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(state->modules_by_index,

0, PyList_GET_SIZE(state->modules_by_index),

NULL))

PyErr_WriteUnraisable(state->modules_by_index);

}

}

void

PyThreadState_Clear(PyThreadState *tstate)

{

int verbose = tstate->interp->core_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->coroutine_wrapper);

Py_CLEAR(tstate->async_gen_firstiter);

Py_CLEAR(tstate->async_gen_finalizer);

Py_CLEAR(tstate->context);

}

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

static void

tstate_delete_common(PyThreadState *tstate)

{

PyInterpreterState *interp;

if (tstate == NULL)

Py_FatalError("PyThreadState_Delete: NULL tstate");

interp = tstate->interp;

if (interp == NULL)

Py_FatalError("PyThreadState_Delete: NULL interp");

HEAD_LOCK();

if (tstate->prev)

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

else

interp->tstate_head = tstate->next;

if (tstate->next)

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

HEAD_UNLOCK();

if (tstate->on_delete != NULL) {

tstate->on_delete(tstate->on_delete_data);

}

PyMem_RawFree(tstate);

}

void

PyThreadState_Delete(PyThreadState *tstate)

{

if (tstate == _PyThreadState_GET())

Py_FatalError("PyThreadState_Delete: tstate is still current");

if (_PyRuntime.gilstate.autoInterpreterState &&

PyThread_tss_get(&_PyRuntime.gilstate.autoTSSkey) == tstate)

{

PyThread_tss_set(&_PyRuntime.gilstate.autoTSSkey, NULL);

}

tstate_delete_common(tstate);

}

void

PyThreadState_DeleteCurrent()

{

PyThreadState *tstate = _PyThreadState_GET();

if (tstate == NULL)

Py_FatalError(

"PyThreadState_DeleteCurrent: no current tstate");

tstate_delete_common(tstate);

if (_PyRuntime.gilstate.autoInterpreterState &&

PyThread_tss_get(&_PyRuntime.gilstate.autoTSSkey) == tstate)

{

PyThread_tss_set(&_PyRuntime.gilstate.autoTSSkey, NULL);

}

_PyThreadState_SET(NULL);

PyEval_ReleaseLock();

}

/*

* 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 interpreteres.

*/

void

_PyThreadState_DeleteExcept(PyThreadState *tstate)

{

PyInterpreterState *interp = tstate->interp;

PyThreadState *p, *next, *garbage;

HEAD_LOCK();

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

thread states. This will allow calling PyThreadState_Clear()

without holding the lock. */

garbage = interp->tstate_head;

if (garbage == tstate)

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

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

for (p = garbage; 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("PyThreadState_Get: no current thread");

return tstate;

}

PyThreadState *

PyThreadState_Swap(PyThreadState *newts)

{

PyThreadState *oldts = _PyThreadState_GET();

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

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

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

errno = err;

}

#endif

return oldts;

}

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

}

/* Asynchronously raise an exception in a thread.

Requested by Just van Rossum and Alex Martelli.

To prevent naive misuse, you must write your own extension

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

int

PyThreadState_SetAsyncExc(unsigned long id, PyObject *exc)

{

PyInterpreterState *interp = _PyInterpreterState_GET_UNSAFE();

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;

}

/* Routines for advanced debuggers, requested by David Beazley.

Don't use unless you know what you are doing! */

PyInterpreterState *

PyInterpreterState_Head(void)

{

return _PyRuntime.interpreters.head;

}

PyInterpreterState *

PyInterpreterState_Main(void)

{

return _PyRuntime.interpreters.main;

}

PyInterpreterState *

PyInterpreterState_Next(PyInterpreterState *interp) {

return interp->next;

}

PyThreadState *

PyInterpreterState_ThreadHead(PyInterpreterState *interp) {

return interp->tstate_head;

}

PyThreadState *

PyThreadState_Next(PyThreadState *tstate) {

return tstate->next;

}

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

{

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

* Because these lists can mutate even when the GIL is held, we

* need to grab head_mutex for the duration.

*/

HEAD_LOCK();

for (i = _PyRuntime.interpreters.head; i != NULL; i = i->next) {

PyThreadState *t;

for (t = i->tstate_head; t != NULL; t = t->next) {

PyObject *id;