#include "Python.h"

#include "pycore_ceval.h"

#include "pycore_code.h" // stats

#include "pycore_dtoa.h" // _dtoa_state_INIT()

#include "pycore_frame.h"

#include "pycore_initconfig.h"

#include "pycore_object.h" // _PyType_InitCache()

#include "pycore_pyerrors.h"

#include "pycore_pylifecycle.h"

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

#include "pycore_pystate.h"

#include "pycore_runtime_init.h" // _PyRuntimeState_INIT

#include "pycore_sysmodule.h"

#ifdef HAVE_DLOPEN

#ifdef HAVE_DLFCN_H

#include <dlfcn.h>

#if !HAVE_DECL_RTLD_LAZY

#define RTLD_LAZY 1

#ifdef __cplusplus

extern "C" {

static inline PyThreadState *

current_fast_get(_PyRuntimeState *runtime)

{

return (PyThreadState*)_Py_atomic_load_relaxed(&runtime->tstate_current);

}

static inline void

current_fast_set(_PyRuntimeState *runtime, PyThreadState *tstate)

{

assert(tstate != NULL);

_Py_atomic_store_relaxed(&runtime->tstate_current, (uintptr_t)tstate);

}

static inline void

current_fast_clear(_PyRuntimeState *runtime)

{

_Py_atomic_store_relaxed(&runtime->tstate_current, (uintptr_t)NULL);

}

#define tstate_verify_not_active(tstate) \

if (tstate == current_fast_get((tstate)->interp->runtime)) { \

_Py_FatalErrorFormat(__func__, "tstate %p is still current", tstate); \

}

static inline int

tstate_tss_initialized(Py_tss_t *key)

{

return PyThread_tss_is_created(key);

}

static inline int

tstate_tss_init(Py_tss_t *key)

{

assert(!tstate_tss_initialized(key));

return PyThread_tss_create(key);

}

static inline void

tstate_tss_fini(Py_tss_t *key)

{

assert(tstate_tss_initialized(key));

PyThread_tss_delete(key);

}

static inline PyThreadState *

tstate_tss_get(Py_tss_t *key)

{

assert(tstate_tss_initialized(key));

return (PyThreadState *)PyThread_tss_get(key);

}

static inline int

tstate_tss_set(Py_tss_t *key, PyThreadState *tstate)

{

assert(tstate != NULL);

assert(tstate_tss_initialized(key));

return PyThread_tss_set(key, (void *)tstate);

}

static inline int

tstate_tss_clear(Py_tss_t *key)

{

assert(tstate_tss_initialized(key));

return PyThread_tss_set(key, (void *)NULL);

}

#ifdef HAVE_FORK

static PyStatus

tstate_tss_reinit(Py_tss_t *key)

{

if (!tstate_tss_initialized(key)) {

return _PyStatus_OK();

}

PyThreadState *tstate = tstate_tss_get(key);

tstate_tss_fini(key);

if (tstate_tss_init(key) != 0) {

return _PyStatus_NO_MEMORY();

}

/* If the thread had an associated auto thread state, reassociate it with

if (tstate && tstate_tss_set(key, tstate) != 0) {

return _PyStatus_ERR("failed to re-set autoTSSkey");

}

return _PyStatus_OK();

}

#define gilstate_tss_initialized(runtime) \

tstate_tss_initialized(&(runtime)->autoTSSkey)

#define gilstate_tss_init(runtime) \

tstate_tss_init(&(runtime)->autoTSSkey)

#define gilstate_tss_fini(runtime) \

tstate_tss_fini(&(runtime)->autoTSSkey)

#define gilstate_tss_get(runtime) \

tstate_tss_get(&(runtime)->autoTSSkey)

#define _gilstate_tss_set(runtime, tstate) \

tstate_tss_set(&(runtime)->autoTSSkey, tstate)

#define _gilstate_tss_clear(runtime) \

tstate_tss_clear(&(runtime)->autoTSSkey)

#define gilstate_tss_reinit(runtime) \

tstate_tss_reinit(&(runtime)->autoTSSkey)

static inline void

gilstate_tss_set(_PyRuntimeState *runtime, PyThreadState *tstate)

{

assert(tstate != NULL && tstate->interp->runtime == runtime);

if (_gilstate_tss_set(runtime, tstate) != 0) {

Py_FatalError("failed to set current tstate (TSS)");

}

}

static inline void

gilstate_tss_clear(_PyRuntimeState *runtime)

{

if (_gilstate_tss_clear(runtime) != 0) {

Py_FatalError("failed to clear current tstate (TSS)");

}

}

#ifndef NDEBUG

static inline int tstate_is_alive(PyThreadState *tstate);

static inline int

tstate_is_bound(PyThreadState *tstate)

{

return tstate->_status.bound && !tstate->_status.unbound;

}

#endif // !NDEBUG

static void bind_gilstate_tstate(PyThreadState *);

static void unbind_gilstate_tstate(PyThreadState *);

static void

bind_tstate(PyThreadState *tstate)

{

assert(tstate != NULL);

assert(tstate_is_alive(tstate) && !tstate->_status.bound);

assert(!tstate->_status.unbound); // just in case

assert(!tstate->_status.bound_gilstate);

assert(tstate != gilstate_tss_get(tstate->interp->runtime));

assert(!tstate->_status.active);

assert(tstate->thread_id == 0);

assert(tstate->native_thread_id == 0);

// Currently we don't necessarily store the thread state

// in thread-local storage (e.g. per-interpreter).

tstate->thread_id = PyThread_get_thread_ident();

#ifdef PY_HAVE_THREAD_NATIVE_ID

tstate->native_thread_id = PyThread_get_thread_native_id();

tstate->_status.bound = 1;

}

static void

unbind_tstate(PyThreadState *tstate)

{

assert(tstate != NULL);

// XXX assert(tstate_is_alive(tstate));

assert(tstate_is_bound(tstate));

// XXX assert(!tstate->_status.active);

assert(tstate->thread_id > 0);

#ifdef PY_HAVE_THREAD_NATIVE_ID

assert(tstate->native_thread_id > 0);

// We leave thread_id and native_thread_id alone

// since they can be useful for debugging.

// Check the `_status` field to know if these values

// are still valid.

// We leave tstate->_status.bound set to 1

// to indicate it was previously bound.

tstate->_status.unbound = 1;

}

static void

bind_gilstate_tstate(PyThreadState *tstate)

{

assert(tstate != NULL);

assert(tstate_is_alive(tstate));

assert(tstate_is_bound(tstate));

// XXX assert(!tstate->_status.active);

assert(!tstate->_status.bound_gilstate);

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

PyThreadState *tcur = gilstate_tss_get(runtime);

assert(tstate != tcur);

if (tcur != NULL) {

tcur->_status.bound_gilstate = 0;

}

gilstate_tss_set(runtime, tstate);

tstate->_status.bound_gilstate = 1;

}

static void

unbind_gilstate_tstate(PyThreadState *tstate)

{

assert(tstate != NULL);

// XXX assert(tstate_is_alive(tstate));

assert(tstate_is_bound(tstate));

// XXX assert(!tstate->_status.active);

assert(tstate->_status.bound_gilstate);

assert(tstate == gilstate_tss_get(tstate->interp->runtime));

gilstate_tss_clear(tstate->interp->runtime);

tstate->_status.bound_gilstate = 0;

}

static int

holds_gil(PyThreadState *tstate)

{

// XXX Fall back to tstate->interp->runtime->ceval.gil.last_holder

// (and tstate->interp->runtime->ceval.gil.locked).

assert(tstate != NULL);

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

/* Must be the tstate for this thread */

assert(tstate == gilstate_tss_get(runtime));

return tstate == current_fast_get(runtime);

}

static const _PyRuntimeState initial = _PyRuntimeState_INIT(_PyRuntime);

static int

alloc_for_runtime(PyThread_type_lock *plock1, PyThread_type_lock *plock2,

PyThread_type_lock *plock3, PyThread_type_lock *plock4)

{

/* Force default allocator, since _PyRuntimeState_Fini() must

PyMemAllocatorEx old_alloc;

_PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

PyThread_type_lock lock1 = PyThread_allocate_lock();

if (lock1 == NULL) {

return -1;

}

PyThread_type_lock lock2 = PyThread_allocate_lock();

if (lock2 == NULL) {

PyThread_free_lock(lock1);

return -1;

}

PyThread_type_lock lock3 = PyThread_allocate_lock();

if (lock3 == NULL) {

PyThread_free_lock(lock1);

PyThread_free_lock(lock2);

return -1;

}

PyThread_type_lock lock4 = PyThread_allocate_lock();

if (lock4 == NULL) {

PyThread_free_lock(lock1);

PyThread_free_lock(lock2);

PyThread_free_lock(lock3);

return -1;

}

PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

*plock1 = lock1;

*plock2 = lock2;

*plock3 = lock3;

*plock4 = lock4;

return 0;

}

static void

init_runtime(_PyRuntimeState *runtime,

PyThread_type_lock getargs_mutex)

{

if (runtime->_initialized) {

Py_FatalError("runtime already initialized");

}

assert(!runtime->preinitializing &&

!runtime->preinitialized &&

!runtime->core_initialized &&

!runtime->initialized);

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->interpreters.mutex = interpreters_mutex;

runtime->xidregistry.mutex = xidregistry_mutex;

runtime->getargs.mutex = getargs_mutex;

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

runtime->main_thread = PyThread_get_thread_ident();

runtime->unicode_state.ids.next_index = unicode_next_index;

runtime->unicode_state.ids.lock = unicode_ids_mutex;

runtime->_initialized = 1;

}

_PyRuntimeState_Init(_PyRuntimeState *runtime)

{

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

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;

// bpo-42882: Preserve next_index value if Py_Initialize()/Py_Finalize()

// is called multiple times.

Py_ssize_t unicode_next_index = runtime->unicode_state.ids.next_index;

PyThread_type_lock lock1, lock2, lock3, lock4;

if (alloc_for_runtime(&lock1, &lock2, &lock3, &lock4) != 0) {

return _PyStatus_NO_MEMORY();

}

if (runtime->_initialized) {

// Py_Initialize() must be running again.

// Reset to _PyRuntimeState_INIT.

memcpy(runtime, &initial, sizeof(*runtime));

}

if (gilstate_tss_init(runtime) != 0) {

_PyRuntimeState_Fini(runtime);

return _PyStatus_NO_MEMORY();

}

if (PyThread_tss_create(&runtime->trashTSSkey) != 0) {

_PyRuntimeState_Fini(runtime);

return _PyStatus_NO_MEMORY();

}

init_runtime(runtime, open_code_hook, open_code_userdata, audit_hook_head,

unicode_next_index, lock1, lock2, lock3, lock4);

return _PyStatus_OK();

}

_PyRuntimeState_Fini(_PyRuntimeState *runtime)

{

#ifdef Py_REF_DEBUG

/* The count is cleared by _Py_FinalizeRefTotal(). */

assert(runtime->object_state.interpreter_leaks == 0);

if (gilstate_tss_initialized(runtime)) {

gilstate_tss_fini(runtime);

}

if (PyThread_tss_is_created(&runtime->trashTSSkey)) {

PyThread_tss_delete(&runtime->trashTSSkey);

}

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

PyMemAllocatorEx old_alloc;

_PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

#define FREE_LOCK(LOCK) \

if (LOCK != NULL) { \

PyThread_free_lock(LOCK); \

LOCK = NULL; \

}

FREE_LOCK(runtime->interpreters.mutex);

FREE_LOCK(runtime->xidregistry.mutex);

FREE_LOCK(runtime->unicode_state.ids.lock);

FREE_LOCK(runtime->getargs.mutex);

#undef FREE_LOCK

PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

}

#ifdef HAVE_FORK

_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

PyMemAllocatorEx old_alloc;

_PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

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

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

int reinit_unicode_ids = _PyThread_at_fork_reinit(&runtime->unicode_state.ids.lock);

int reinit_getargs = _PyThread_at_fork_reinit(&runtime->getargs.mutex);

PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);

/* bpo-42540: id_mutex is freed by _PyInterpreterState_Delete, which does

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

if (reinit_interp < 0

|| reinit_main_id < 0

|| reinit_xidregistry < 0

|| reinit_unicode_ids < 0

|| reinit_getargs < 0)

{

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

}

PyStatus status = gilstate_tss_reinit(runtime);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

if (PyThread_tss_is_created(&runtime->trashTSSkey)) {

PyThread_tss_delete(&runtime->trashTSSkey);

}

if (PyThread_tss_create(&runtime->trashTSSkey) != 0) {

return _PyStatus_NO_MEMORY();

}

return _PyStatus_OK();

}

_PyInterpreterState_Enable(_PyRuntimeState *runtime)

{

struct pyinterpreters *interpreters = &runtime->interpreters;

interpreters->next_id = 0;

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

if (interpreters->mutex == NULL) {

/* Force default allocator, since _PyRuntimeState_Fini() must

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

}

static PyInterpreterState *

alloc_interpreter(void)

{

return PyMem_RawCalloc(1, sizeof(PyInterpreterState));

}

static void

free_interpreter(PyInterpreterState *interp)

{

// The main interpreter is statically allocated so

// should not be freed.

if (interp != &_PyRuntime._main_interpreter) {

PyMem_RawFree(interp);

}

}

static void

init_interpreter(PyInterpreterState *interp,

_PyRuntimeState *runtime, int64_t id,

PyInterpreterState *next,

PyThread_type_lock pending_lock)

{

if (interp->_initialized) {

Py_FatalError("interpreter already initialized");

}

assert(runtime != NULL);

interp->runtime = runtime;

assert(id > 0 || (id == 0 && interp == runtime->interpreters.main));

interp->id = id;

assert(runtime->interpreters.head == interp);

assert(next != NULL || (interp == runtime->interpreters.main));

interp->next = next;

_PyEval_InitState(&interp->ceval, pending_lock);

_PyGC_InitState(&interp->gc);

PyConfig_InitPythonConfig(&interp->config);

_PyType_InitCache(interp);

if (interp != &runtime->_main_interpreter) {

/* Fix the self-referential, statically initialized fields. */

interp->dtoa = (struct _dtoa_state)_dtoa_state_INIT(interp);

}

interp->_initialized = 1;

}

PyInterpreterState *

PyInterpreterState_New(void)

{

PyInterpreterState *interp;

_PyRuntimeState *runtime = &_PyRuntime;

PyThreadState *tstate = current_fast_get(runtime);

/* tstate is NULL when Py_InitializeFromConfig() calls

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

return NULL;

}

PyThread_type_lock pending_lock = PyThread_allocate_lock();

if (pending_lock == NULL) {

if (tstate != NULL) {

_PyErr_NoMemory(tstate);

}

return NULL;

}

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

struct pyinterpreters *interpreters = &runtime->interpreters;

/* We completely serialize creation of multiple interpreters, since

HEAD_LOCK(runtime);

int64_t id = interpreters->next_id;

interpreters->next_id += 1;

// Allocate the interpreter and add it to the runtime state.

PyInterpreterState *old_head = interpreters->head;

if (old_head == NULL) {

// We are creating the main interpreter.

assert(interpreters->main == NULL);

assert(id == 0);

interp = &runtime->_main_interpreter;

assert(interp->id == 0);

assert(interp->next == NULL);

interpreters->main = interp;

}

else {

assert(interpreters->main != NULL);

assert(id != 0);

interp = alloc_interpreter();

if (interp == NULL) {

goto error;

}

// Set to _PyInterpreterState_INIT.

memcpy(interp, &initial._main_interpreter,

sizeof(*interp));

if (id < 0) {

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

if (tstate != NULL) {

_PyErr_SetString(tstate, PyExc_RuntimeError,

"failed to get an interpreter ID");

}

goto error;

}

}

interpreters->head = interp;

init_interpreter(interp, runtime, id, old_head, pending_lock);

HEAD_UNLOCK(runtime);

return interp;

error:

HEAD_UNLOCK(runtime);

PyThread_free_lock(pending_lock);

if (interp != NULL) {

free_interpreter(interp);

}

return NULL;

}

static void

interpreter_clear(PyInterpreterState *interp, PyThreadState *tstate)

{

assert(interp != NULL);

assert(tstate != NULL);

_PyRuntimeState *runtime = interp->runtime;

/* XXX Conditions we need to enforce:

// XXX Ideally, we would not rely on any thread state in this function

// (and we would drop the "tstate" argument).

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

_PyErr_Clear(tstate);

}

// Clear the current/main thread state last.

HEAD_LOCK(runtime);

PyThreadState *p = interp->threads.head;

HEAD_UNLOCK(runtime);

while (p != NULL) {

// See https://github.com/python/cpython/issues/102126

// Must be called without HEAD_LOCK held as it can deadlock

// if any finalizer tries to acquire that lock.

PyThreadState_Clear(p);

HEAD_LOCK(runtime);

p = p->next;

HEAD_UNLOCK(runtime);

}

/* It is possible that any of the objects below have a finalizer

// XXX Make sure we properly deal with problematic finalizers.

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

assert(interp->imports.modules == NULL);

assert(interp->imports.modules_by_index == NULL);

assert(interp->imports.importlib == NULL);

assert(interp->imports.import_func == NULL);

Py_CLEAR(interp->sysdict_copy);

Py_CLEAR(interp->builtins_copy);

Py_CLEAR(interp->dict);

#ifdef HAVE_FORK

Py_CLEAR(interp->before_forkers);

Py_CLEAR(interp->after_forkers_parent);

Py_CLEAR(interp->after_forkers_child);

_PyAST_Fini(interp);

_PyWarnings_Fini(interp);

_PyAtExit_Fini(interp);

// All Python types must be destroyed before the last GC collection. Python

// types create a reference cycle to themselves in their in their

// PyTypeObject.tp_mro member (the tuple contains the type).

/* Last garbage collection on this interpreter */

_PyGC_CollectNoFail(tstate);

_PyGC_Fini(interp);

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

PyDict_Clear(interp->sysdict);

PyDict_Clear(interp->builtins);

Py_CLEAR(interp->sysdict);

Py_CLEAR(interp->builtins);

Py_CLEAR(interp->interpreter_trampoline);

for (int i=0; i < DICT_MAX_WATCHERS; i++) {

interp->dict_state.watchers[i] = NULL;

}

for (int i=0; i < TYPE_MAX_WATCHERS; i++) {

interp->type_watchers[i] = NULL;

}

for (int i=0; i < FUNC_MAX_WATCHERS; i++) {

interp->func_watchers[i] = NULL;

}

interp->active_func_watchers = 0;

for (int i=0; i < CODE_MAX_WATCHERS; i++) {

interp->code_watchers[i] = NULL;

}

interp->active_code_watchers = 0;

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

}

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 = current_fast_get(interp->runtime);

_PyImport_ClearCore(interp);

interpreter_clear(interp, current_tstate);

}

_PyInterpreterState_Clear(PyThreadState *tstate)

{

_PyImport_ClearCore(tstate->interp);

interpreter_clear(tstate->interp, tstate);

}

static void zapthreads(PyInterpreterState *interp);

PyInterpreterState_Delete(PyInterpreterState *interp)

{

_PyRuntimeState *runtime = interp->runtime;

struct pyinterpreters *interpreters = &runtime->interpreters;

// XXX Clearing the "current" thread state should happen before

// we start finalizing the interpreter (or the current thread state).

PyThreadState *tcur = current_fast_get(runtime);

if (tcur != NULL && interp == tcur->interp) {

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

_PyThreadState_Swap(runtime, NULL);

}

zapthreads(interp);

_PyEval_FiniState(&interp->ceval);

#ifdef Py_REF_DEBUG

// XXX This call should be done at the end of clear_interpreter(),

// but currently some objects get decref'ed after that.

_PyInterpreterState_FinalizeRefTotal(interp);

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

}

free_interpreter(interp);

}

#ifdef HAVE_FORK

_PyInterpreterState_DeleteExceptMain(_PyRuntimeState *runtime)

{

struct pyinterpreters *interpreters = &runtime->interpreters;

PyThreadState *tstate = _PyThreadState_Swap(runtime, 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;

}

// XXX Won't this fail since PyInterpreterState_Clear() requires

// the "current" tstate to be set?

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;

free_interpreter(prev_interp);

}

HEAD_UNLOCK(runtime);

if (interpreters->head == NULL) {

return _PyStatus_ERR("missing main interpreter");

}

_PyThreadState_Swap(runtime, tstate);

return _PyStatus_OK();

}

PyInterpreterState_GetID(PyInterpreterState *interp)

{

if (interp == NULL) {

PyErr_SetString(PyExc_RuntimeError, "no interpreter provided");

return -1;