Branch data     Line data    Source code

       1                 :            : #ifndef Py_INTERNAL_RUNTIME_H
       2                 :            : #define Py_INTERNAL_RUNTIME_H
       3                 :            : #ifdef __cplusplus
       4                 :            : extern "C" {
       5                 :            : #endif
       6                 :            : 
       7                 :            : #ifndef Py_BUILD_CORE
       8                 :            : #  error "this header requires Py_BUILD_CORE define"
       9                 :            : #endif
      10                 :            : 
      11                 :            : #include "pycore_atomic.h"          /* _Py_atomic_address */
      12                 :            : #include "pycore_gil.h"             // struct _gil_runtime_state
      13                 :            : #include "pycore_global_objects.h"  // struct _Py_global_objects
      14                 :            : #include "pycore_interp.h"          // PyInterpreterState
      15                 :            : #include "pycore_unicodeobject.h"   // struct _Py_unicode_runtime_ids
      16                 :            : 
      17                 :            : 
      18                 :            : /* ceval state */
      19                 :            : 
      20                 :            : struct _ceval_runtime_state {
      21                 :            :     /* Request for checking signals. It is shared by all interpreters (see
      22                 :            :        bpo-40513). Any thread of any interpreter can receive a signal, but only
      23                 :            :        the main thread of the main interpreter can handle signals: see
      24                 :            :        _Py_ThreadCanHandleSignals(). */
      25                 :            :     _Py_atomic_int signals_pending;
      26                 :            :     struct _gil_runtime_state gil;
      27                 :            : };
      28                 :            : 
      29                 :            : /* GIL state */
      30                 :            : 
      31                 :            : struct _gilstate_runtime_state {
      32                 :            :     /* bpo-26558: Flag to disable PyGILState_Check().
      33                 :            :        If set to non-zero, PyGILState_Check() always return 1. */
      34                 :            :     int check_enabled;
      35                 :            :     /* Assuming the current thread holds the GIL, this is the
      36                 :            :        PyThreadState for the current thread. */
      37                 :            :     _Py_atomic_address tstate_current;
      38                 :            :     /* The single PyInterpreterState used by this process'
      39                 :            :        GILState implementation
      40                 :            :     */
      41                 :            :     /* TODO: Given interp_main, it may be possible to kill this ref */
      42                 :            :     PyInterpreterState *autoInterpreterState;
      43                 :            :     Py_tss_t autoTSSkey;
      44                 :            : };
      45                 :            : 
      46                 :            : /* Runtime audit hook state */
      47                 :            : 
      48                 :            : typedef struct _Py_AuditHookEntry {
      49                 :            :     struct _Py_AuditHookEntry *next;
      50                 :            :     Py_AuditHookFunction hookCFunction;
      51                 :            :     void *userData;
      52                 :            : } _Py_AuditHookEntry;
      53                 :            : 
      54                 :            : /* Full Python runtime state */
      55                 :            : 
      56                 :            : /* _PyRuntimeState holds the global state for the CPython runtime.
      57                 :            :    That data is exposed in the internal API as a static variable (_PyRuntime).
      58                 :            :    */
      59                 :            : typedef struct pyruntimestate {
      60                 :            :     /* Has been initialized to a safe state.
      61                 :            : 
      62                 :            :        In order to be effective, this must be set to 0 during or right
      63                 :            :        after allocation. */
      64                 :            :     int _initialized;
      65                 :            : 
      66                 :            :     /* Is running Py_PreInitialize()? */
      67                 :            :     int preinitializing;
      68                 :            : 
      69                 :            :     /* Is Python preinitialized? Set to 1 by Py_PreInitialize() */
      70                 :            :     int preinitialized;
      71                 :            : 
      72                 :            :     /* Is Python core initialized? Set to 1 by _Py_InitializeCore() */
      73                 :            :     int core_initialized;
      74                 :            : 
      75                 :            :     /* Is Python fully initialized? Set to 1 by Py_Initialize() */
      76                 :            :     int initialized;
      77                 :            : 
      78                 :            :     /* Set by Py_FinalizeEx(). Only reset to NULL if Py_Initialize()
      79                 :            :        is called again.
      80                 :            : 
      81                 :            :        Use _PyRuntimeState_GetFinalizing() and _PyRuntimeState_SetFinalizing()
      82                 :            :        to access it, don't access it directly. */
      83                 :            :     _Py_atomic_address _finalizing;
      84                 :            : 
      85                 :            :     struct pyinterpreters {
      86                 :            :         PyThread_type_lock mutex;
      87                 :            :         /* The linked list of interpreters, newest first. */
      88                 :            :         PyInterpreterState *head;
      89                 :            :         /* The runtime's initial interpreter, which has a special role
      90                 :            :            in the operation of the runtime.  It is also often the only
      91                 :            :            interpreter. */
      92                 :            :         PyInterpreterState *main;
      93                 :            :         /* _next_interp_id is an auto-numbered sequence of small
      94                 :            :            integers.  It gets initialized in _PyInterpreterState_Init(),
      95                 :            :            which is called in Py_Initialize(), and used in
      96                 :            :            PyInterpreterState_New().  A negative interpreter ID
      97                 :            :            indicates an error occurred.  The main interpreter will
      98                 :            :            always have an ID of 0.  Overflow results in a RuntimeError.
      99                 :            :            If that becomes a problem later then we can adjust, e.g. by
     100                 :            :            using a Python int. */
     101                 :            :         int64_t next_id;
     102                 :            :     } interpreters;
     103                 :            :     // XXX Remove this field once we have a tp_* slot.
     104                 :            :     struct _xidregistry {
     105                 :            :         PyThread_type_lock mutex;
     106                 :            :         struct _xidregitem *head;
     107                 :            :     } xidregistry;
     108                 :            : 
     109                 :            :     unsigned long main_thread;
     110                 :            : 
     111                 :            : #define NEXITFUNCS 32
     112                 :            :     void (*exitfuncs[NEXITFUNCS])(void);
     113                 :            :     int nexitfuncs;
     114                 :            : 
     115                 :            :     struct _ceval_runtime_state ceval;
     116                 :            :     struct _gilstate_runtime_state gilstate;
     117                 :            : 
     118                 :            :     PyPreConfig preconfig;
     119                 :            : 
     120                 :            :     // Audit values must be preserved when Py_Initialize()/Py_Finalize()
     121                 :            :     // is called multiple times.
     122                 :            :     Py_OpenCodeHookFunction open_code_hook;
     123                 :            :     void *open_code_userdata;
     124                 :            :     _Py_AuditHookEntry *audit_hook_head;
     125                 :            : 
     126                 :            :     struct _Py_unicode_runtime_ids unicode_ids;
     127                 :            : 
     128                 :            :     /* All the objects that are shared by the runtime's interpreters. */
     129                 :            :     struct _Py_global_objects global_objects;
     130                 :            : 
     131                 :            :     /* The following fields are here to avoid allocation during init.
     132                 :            :        The data is exposed through _PyRuntimeState pointer fields.
     133                 :            :        These fields should not be accessed directly outside of init.
     134                 :            : 
     135                 :            :        All other _PyRuntimeState pointer fields are populated when
     136                 :            :        needed and default to NULL.
     137                 :            : 
     138                 :            :        For now there are some exceptions to that rule, which require
     139                 :            :        allocation during init.  These will be addressed on a case-by-case
     140                 :            :        basis.  Most notably, we don't pre-allocated the several mutex
     141                 :            :        (PyThread_type_lock) fields, because on Windows we only ever get
     142                 :            :        a pointer type.
     143                 :            :        */
     144                 :            : 
     145                 :            :     /* PyInterpreterState.interpreters.main */
     146                 :            :     PyInterpreterState _main_interpreter;
     147                 :            : } _PyRuntimeState;
     148                 :            : 
     149                 :            : 
     150                 :            : /* other API */
     151                 :            : 
     152                 :            : PyAPI_DATA(_PyRuntimeState) _PyRuntime;
     153                 :            : 
     154                 :            : PyAPI_FUNC(PyStatus) _PyRuntimeState_Init(_PyRuntimeState *runtime);
     155                 :            : PyAPI_FUNC(void) _PyRuntimeState_Fini(_PyRuntimeState *runtime);
     156                 :            : 
     157                 :            : #ifdef HAVE_FORK
     158                 :            : extern PyStatus _PyRuntimeState_ReInitThreads(_PyRuntimeState *runtime);
     159                 :            : #endif
     160                 :            : 
     161                 :            : /* Initialize _PyRuntimeState.
     162                 :            :    Return NULL on success, or return an error message on failure. */
     163                 :            : PyAPI_FUNC(PyStatus) _PyRuntime_Initialize(void);
     164                 :            : 
     165                 :            : PyAPI_FUNC(void) _PyRuntime_Finalize(void);
     166                 :            : 
     167                 :            : 
     168                 :            : static inline PyThreadState*
     169                 :   18716308 : _PyRuntimeState_GetFinalizing(_PyRuntimeState *runtime) {
     170                 :   18716308 :     return (PyThreadState*)_Py_atomic_load_relaxed(&runtime->_finalizing);
     171                 :            : }
     172                 :            : 
     173                 :            : static inline void
     174                 :       5924 : _PyRuntimeState_SetFinalizing(_PyRuntimeState *runtime, PyThreadState *tstate) {
     175                 :       5924 :     _Py_atomic_store_relaxed(&runtime->_finalizing, (uintptr_t)tstate);
     176                 :       5924 : }
     177                 :            : 
     178                 :            : #ifdef __cplusplus
     179                 :            : }
     180                 :            : #endif
     181                 :            : #endif /* !Py_INTERNAL_RUNTIME_H */