| #ifndef Py_CPYTHON_PYSTATE_H | |
| # error "this header file must not be included directly" | |
| #endif | |
| /* private interpreter helpers */ | |
| PyAPI_FUNC(int) _PyInterpreterState_RequiresIDRef(PyInterpreterState *); | |
| PyAPI_FUNC(void) _PyInterpreterState_RequireIDRef(PyInterpreterState *, int); | |
| /* State unique per thread */ | |
| /* Py_tracefunc return -1 when raising an exception, or 0 for success. */ | |
| typedef int (*Py_tracefunc)(PyObject *, PyFrameObject *, int, PyObject *); | |
| /* The following values are used for 'what' for tracefunc functions | |
| * | |
| * To add a new kind of trace event, also update "trace_init" in | |
| * Python/sysmodule.c to define the Python level event name | |
| */ | |
| #define PyTrace_CALL 0 | |
| #define PyTrace_EXCEPTION 1 | |
| #define PyTrace_LINE 2 | |
| #define PyTrace_RETURN 3 | |
| #define PyTrace_C_CALL 4 | |
| #define PyTrace_C_EXCEPTION 5 | |
| #define PyTrace_C_RETURN 6 | |
| #define PyTrace_OPCODE 7 | |
| /* Remote debugger support */ | |
| #define _Py_MAX_SCRIPT_PATH_SIZE 512 | |
| typedef struct { | |
| int32_t debugger_pending_call; | |
| char debugger_script_path[_Py_MAX_SCRIPT_PATH_SIZE]; | |
| } _PyRemoteDebuggerSupport; | |
| typedef struct _err_stackitem { | |
| /* This struct represents a single execution context where we might | |
| * be currently handling an exception. It is a per-coroutine state | |
| * (coroutine in the computer science sense, including the thread | |
| * and generators). | |
| * | |
| * This is used as an entry on the exception stack, where each | |
| * entry indicates if it is currently handling an exception. | |
| * This ensures that the exception state is not impacted | |
| * by "yields" from an except handler. The thread | |
| * always has an entry (the bottom-most one). | |
| */ | |
| /* The exception currently being handled in this context, if any. */ | |
| PyObject *exc_value; | |
| struct _err_stackitem *previous_item; | |
| } _PyErr_StackItem; | |
| typedef struct _stack_chunk { | |
| struct _stack_chunk *previous; | |
| size_t size; | |
| size_t top; | |
| PyObject * data[1]; /* Variable sized */ | |
| } _PyStackChunk; | |
| /* Minimum size of data stack chunk */ | |
| #define _PY_DATA_STACK_CHUNK_SIZE (16*1024) | |
| struct _ts { | |
| /* See Python/ceval.c for comments explaining most fields */ | |
| PyThreadState *prev; | |
| PyThreadState *next; | |
| PyInterpreterState *interp; | |
| /* The global instrumentation version in high bits, plus flags indicating | |
| when to break out of the interpreter loop in lower bits. See details in | |
| pycore_ceval.h. */ | |
| uintptr_t eval_breaker; | |
| struct { | |
| /* Has been initialized to a safe state. | |
| In order to be effective, this must be set to 0 during or right | |
| after allocation. */ | |
| unsigned int initialized:1; | |
| /* Has been bound to an OS thread. */ | |
| unsigned int bound:1; | |
| /* Has been unbound from its OS thread. */ | |
| unsigned int unbound:1; | |
| /* Has been bound aa current for the GILState API. */ | |
| unsigned int bound_gilstate:1; | |
| /* Currently in use (maybe holds the GIL). */ | |
| unsigned int active:1; | |
| /* various stages of finalization */ | |
| unsigned int finalizing:1; | |
| unsigned int cleared:1; | |
| unsigned int finalized:1; | |
| /* padding to align to 4 bytes */ | |
| unsigned int :24; | |
| } _status; | |
| #ifdef Py_BUILD_CORE | |
| # define _PyThreadState_WHENCE_NOTSET -1 | |
| # define _PyThreadState_WHENCE_UNKNOWN 0 | |
| # define _PyThreadState_WHENCE_INIT 1 | |
| # define _PyThreadState_WHENCE_FINI 2 | |
| # define _PyThreadState_WHENCE_THREADING 3 | |
| # define _PyThreadState_WHENCE_C_API 4 | |
| # define _PyThreadState_WHENCE_EXEC 5 | |
| # define _PyThreadState_WHENCE_THREADING_DAEMON 6 | |
| #endif | |
| /* Currently holds the GIL. Must be its own field to avoid data races */ | |
| int holds_gil; | |
| /* Currently requesting the GIL */ | |
| int gil_requested; | |
| int _whence; | |
| /* Thread state. See Include/internal/pycore_pystate.h for details. */ | |
| int state; | |
| int py_recursion_remaining; | |
| int py_recursion_limit; | |
| int recursion_headroom; /* Allow 50 more calls to handle any errors. */ | |
| /* 'tracing' keeps track of the execution depth when tracing/profiling. | |
| This is to prevent the actual trace/profile code from being recorded in | |
| the trace/profile. */ | |
| int tracing; | |
| int what_event; /* The event currently being monitored, if any. */ | |
| /* Pointer to currently executing frame. */ | |
| struct _PyInterpreterFrame *current_frame; | |
| /* Pointer to the base frame (bottommost sentinel frame). | |
| Used by profilers to validate complete stack unwinding. | |
| Points to the embedded base_frame in _PyThreadStateImpl. | |
| The frame is embedded there rather than here because _PyInterpreterFrame | |
| is defined in internal headers that cannot be exposed in the public API. */ | |
| struct _PyInterpreterFrame *base_frame; | |
| struct _PyInterpreterFrame *last_profiled_frame; | |
| uintptr_t last_profiled_frame_seq; | |
| Py_tracefunc c_profilefunc; | |
| Py_tracefunc c_tracefunc; | |
| PyObject *c_profileobj; | |
| PyObject *c_traceobj; | |
| /* The exception currently being raised */ | |
| PyObject *current_exception; | |
| /* Pointer to the top of the exception stack for the exceptions | |
| * we may be currently handling. (See _PyErr_StackItem above.) | |
| * This is never NULL. */ | |
| _PyErr_StackItem *exc_info; | |
| PyObject *dict; /* Stores per-thread state */ | |
| int gilstate_counter; | |
| PyObject *async_exc; /* Asynchronous exception to raise */ | |
| unsigned long thread_id; /* Thread id where this tstate was created */ | |
| /* Native thread id where this tstate was created. This will be 0 except on | |
| * those platforms that have the notion of native thread id, for which the | |
| * macro PY_HAVE_THREAD_NATIVE_ID is then defined. | |
| */ | |
| unsigned long native_thread_id; | |
| /* List of objects that still need to be cleaned up, singly linked | |
| * via their gc headers' gc_next pointers. The list is populated by | |
| * _PyTrash_thread_deposit_object and cleaned up by | |
| * _PyTrash_thread_destroy_chain. | |
| */ | |
| PyObject *delete_later; | |
| /* Tagged pointer to top-most critical section, or zero if there is no | |
| * active critical section. Critical sections are only used in | |
| * `--disable-gil` builds (i.e., when Py_GIL_DISABLED is defined to 1). In the | |
| * default build, this field is always zero. | |
| */ | |
| uintptr_t critical_section; | |
| int coroutine_origin_tracking_depth; | |
| PyObject *async_gen_firstiter; | |
| PyObject *async_gen_finalizer; | |
| PyObject *context; | |
| uint64_t context_ver; | |
| /* Unique thread state id. */ | |
| uint64_t id; | |
| _PyStackChunk *datastack_chunk; | |
| PyObject **datastack_top; | |
| PyObject **datastack_limit; | |
| _PyStackChunk *datastack_cached_chunk; | |
| /* XXX signal handlers should also be here */ | |
| /* The following fields are here to avoid allocation during init. | |
| The data is exposed through PyThreadState pointer fields. | |
| These fields should not be accessed directly outside of init. | |
| This is indicated by an underscore prefix on the field names. | |
| All other PyInterpreterState pointer fields are populated when | |
| needed and default to NULL. | |
| */ | |
| // Note some fields do not have a leading underscore for backward | |
| // compatibility. See https://bugs.python.org/issue45953#msg412046. | |
| /* The thread's exception stack entry. (Always the last entry.) */ | |
| _PyErr_StackItem exc_state; | |
| PyObject *current_executor; | |
| /* Internal to the JIT */ | |
| struct _PyExitData *jit_exit; | |
| uint64_t dict_global_version; | |
| /* Used to store/retrieve `threading.local` keys/values for this thread */ | |
| PyObject *threading_local_key; | |
| /* Used by `threading.local`s to be remove keys/values for dying threads. | |
| The PyThreadObject must hold the only reference to this value. | |
| */ | |
| PyObject *threading_local_sentinel; | |
| _PyRemoteDebuggerSupport remote_debugger_support; | |
| #ifdef Py_STATS | |
| // Pointer to PyStats structure, NULL if recording is off. For the | |
| // free-threaded build, the structure is per-thread (stored as a pointer | |
| // in _PyThreadStateImpl). For the default build, the structure is stored | |
| // in the PyInterpreterState structure (threads do not have their own | |
| // structure and all share the same per-interpreter structure). | |
| PyStats *pystats; | |
| #endif | |
| struct { | |
| /* Number of nested PyThreadState_Ensure() calls on this thread state */ | |
| Py_ssize_t counter; | |
| /* Should this thread state be deleted upon calling | |
| PyThreadState_Release() (with the counter at 1)? | |
| This is only true for thread states created by PyThreadState_Ensure() */ | |
| int delete_on_release; | |
| /* The interpreter guard owned by PyThreadState_EnsureFromView(), if any. */ | |
| PyInterpreterGuard *owned_guard; | |
| } ensure; | |
| }; | |
| /* other API */ | |
| /* Similar to PyThreadState_Get(), but don't issue a fatal error | |
| * if it is NULL. */ | |
| PyAPI_FUNC(PyThreadState *) PyThreadState_GetUnchecked(void); | |
| // Deprecated alias kept for backward compatibility | |
| Py_DEPRECATED(3.14) static inline PyThreadState* | |
| _PyThreadState_UncheckedGet(void) | |
| { | |
| return PyThreadState_GetUnchecked(); | |
| } | |
| // Disable tracing and profiling. | |
| PyAPI_FUNC(void) PyThreadState_EnterTracing(PyThreadState *tstate); | |
| // Reset tracing and profiling: enable them if a trace function or a profile | |
| // function is set, otherwise disable them. | |
| PyAPI_FUNC(void) PyThreadState_LeaveTracing(PyThreadState *tstate); | |
| #ifdef Py_STATS | |
| #if defined(HAVE_THREAD_LOCAL) && !defined(Py_BUILD_CORE_MODULE) | |
| extern _Py_thread_local PyThreadState *_Py_tss_tstate; | |
| static inline PyStats* | |
| _PyThreadState_GetStatsFast(void) | |
| { | |
| if (_Py_tss_tstate == NULL) { | |
| return NULL; // no attached thread state | |
| } | |
| return _Py_tss_tstate->pystats; | |
| } | |
| #endif | |
| #endif // Py_STATS | |
| /* PyGILState */ | |
| /* Helper/diagnostic function - return 1 if the current thread | |
| currently holds the GIL, 0 otherwise. | |
| The function returns 1 if _PyGILState_check_enabled is non-zero. */ | |
| PyAPI_FUNC(int) PyGILState_Check(void); | |
| /* The implementation of sys._current_frames() Returns a dict mapping | |
| thread id to that thread's current frame. | |
| */ | |
| PyAPI_FUNC(PyObject*) _PyThread_CurrentFrames(void); | |
| // Set the stack protection start address and stack protection size | |
| // of a Python thread state | |
| PyAPI_FUNC(int) PyUnstable_ThreadState_SetStackProtection( | |
| PyThreadState *tstate, | |
| void *stack_start_addr, // Stack start address | |
| size_t stack_size); // Stack size (in bytes) | |
| // Reset the stack protection start address and stack protection size | |
| // of a Python thread state | |
| PyAPI_FUNC(void) PyUnstable_ThreadState_ResetStackProtection( | |
| PyThreadState *tstate); | |
| /* Routines for advanced debuggers, requested by David Beazley. | |
| Don't use unless you know what you are doing! */ | |
| PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Main(void); | |
| PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Head(void); | |
| PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Next(PyInterpreterState *); | |
| PyAPI_FUNC(PyThreadState *) PyInterpreterState_ThreadHead(PyInterpreterState *); | |
| PyAPI_FUNC(PyThreadState *) PyThreadState_Next(PyThreadState *); | |
| PyAPI_FUNC(void) PyThreadState_DeleteCurrent(void); | |
| /* Frame evaluation API */ | |
| typedef PyObject* (*_PyFrameEvalFunction)(PyThreadState *tstate, struct _PyInterpreterFrame *, int); | |
| PyAPI_FUNC(_PyFrameEvalFunction) _PyInterpreterState_GetEvalFrameFunc( | |
| PyInterpreterState *interp); | |
| PyAPI_FUNC(void) _PyInterpreterState_SetEvalFrameFunc( | |
| PyInterpreterState *interp, | |
| _PyFrameEvalFunction eval_frame); | |
| PyAPI_FUNC(void) _PyInterpreterState_SetEvalFrameAllowSpecialization( | |
| PyInterpreterState *interp, | |
| int allow_specialization); | |
| PyAPI_FUNC(int) _PyInterpreterState_IsSpecializationEnabled( | |
| PyInterpreterState *interp); |