Branch data Line data Source code
1 : :
2 : : /* Thread and interpreter state structures and their interfaces */
3 : :
4 : : #include "Python.h"
5 : : #include "pycore_ceval.h"
6 : : #include "pycore_code.h" // stats
7 : : #include "pycore_dtoa.h" // _dtoa_state_INIT()
8 : : #include "pycore_frame.h"
9 : : #include "pycore_initconfig.h"
10 : : #include "pycore_object.h" // _PyType_InitCache()
11 : : #include "pycore_pyerrors.h"
12 : : #include "pycore_pylifecycle.h"
13 : : #include "pycore_pymem.h" // _PyMem_SetDefaultAllocator()
14 : : #include "pycore_pystate.h"
15 : : #include "pycore_runtime_init.h" // _PyRuntimeState_INIT
16 : : #include "pycore_sysmodule.h"
17 : :
18 : : /* --------------------------------------------------------------------------
19 : : CAUTION
20 : :
21 : : Always use PyMem_RawMalloc() and PyMem_RawFree() directly in this file. A
22 : : number of these functions are advertised as safe to call when the GIL isn't
23 : : held, and in a debug build Python redirects (e.g.) PyMem_NEW (etc) to Python's
24 : : debugging obmalloc functions. Those aren't thread-safe (they rely on the GIL
25 : : to avoid the expense of doing their own locking).
26 : : -------------------------------------------------------------------------- */
27 : :
28 : : #ifdef HAVE_DLOPEN
29 : : #ifdef HAVE_DLFCN_H
30 : : #include <dlfcn.h>
31 : : #endif
32 : : #if !HAVE_DECL_RTLD_LAZY
33 : : #define RTLD_LAZY 1
34 : : #endif
35 : : #endif
36 : :
37 : : #ifdef __cplusplus
38 : : extern "C" {
39 : : #endif
40 : :
41 : :
42 : : /****************************************/
43 : : /* helpers for the current thread state */
44 : : /****************************************/
45 : :
46 : : // API for the current thread state is further down.
47 : :
48 : : /* "current" means one of:
49 : : - bound to the current OS thread
50 : : - holds the GIL
51 : : */
52 : :
53 : : //-------------------------------------------------
54 : : // a highly efficient lookup for the current thread
55 : : //-------------------------------------------------
56 : :
57 : : /*
58 : : The stored thread state is set by PyThreadState_Swap().
59 : :
60 : : For each of these functions, the GIL must be held by the current thread.
61 : : */
62 : :
63 : : static inline PyThreadState *
64 : 7479704 : current_fast_get(_PyRuntimeState *runtime)
65 : : {
66 : 7479704 : return (PyThreadState*)_Py_atomic_load_relaxed(&runtime->tstate_current);
67 : : }
68 : :
69 : : static inline void
70 : 30180 : current_fast_set(_PyRuntimeState *runtime, PyThreadState *tstate)
71 : : {
72 : : assert(tstate != NULL);
73 : 30180 : _Py_atomic_store_relaxed(&runtime->tstate_current, (uintptr_t)tstate);
74 : 30180 : }
75 : :
76 : : static inline void
77 : 60356 : current_fast_clear(_PyRuntimeState *runtime)
78 : : {
79 : 60356 : _Py_atomic_store_relaxed(&runtime->tstate_current, (uintptr_t)NULL);
80 : 60356 : }
81 : :
82 : : #define tstate_verify_not_active(tstate) \
83 : : if (tstate == current_fast_get((tstate)->interp->runtime)) { \
84 : : _Py_FatalErrorFormat(__func__, "tstate %p is still current", tstate); \
85 : : }
86 : :
87 : :
88 : : //------------------------------------------------
89 : : // the thread state bound to the current OS thread
90 : : //------------------------------------------------
91 : :
92 : : static inline int
93 : 50 : tstate_tss_initialized(Py_tss_t *key)
94 : : {
95 : 50 : return PyThread_tss_is_created(key);
96 : : }
97 : :
98 : : static inline int
99 : 29 : tstate_tss_init(Py_tss_t *key)
100 : : {
101 : : assert(!tstate_tss_initialized(key));
102 : 29 : return PyThread_tss_create(key);
103 : : }
104 : :
105 : : static inline void
106 : 25 : tstate_tss_fini(Py_tss_t *key)
107 : : {
108 : : assert(tstate_tss_initialized(key));
109 : 25 : PyThread_tss_delete(key);
110 : 25 : }
111 : :
112 : : static inline PyThreadState *
113 : 58 : tstate_tss_get(Py_tss_t *key)
114 : : {
115 : : assert(tstate_tss_initialized(key));
116 : 58 : return (PyThreadState *)PyThread_tss_get(key);
117 : : }
118 : :
119 : : static inline int
120 : 29 : tstate_tss_set(Py_tss_t *key, PyThreadState *tstate)
121 : : {
122 : : assert(tstate != NULL);
123 : : assert(tstate_tss_initialized(key));
124 : 29 : return PyThread_tss_set(key, (void *)tstate);
125 : : }
126 : :
127 : : static inline int
128 : 25 : tstate_tss_clear(Py_tss_t *key)
129 : : {
130 : : assert(tstate_tss_initialized(key));
131 : 25 : return PyThread_tss_set(key, (void *)NULL);
132 : : }
133 : :
134 : : #ifdef HAVE_FORK
135 : : /* Reset the TSS key - called by PyOS_AfterFork_Child().
136 : : * This should not be necessary, but some - buggy - pthread implementations
137 : : * don't reset TSS upon fork(), see issue #10517.
138 : : */
139 : : static PyStatus
140 : 0 : tstate_tss_reinit(Py_tss_t *key)
141 : : {
142 [ # # ]: 0 : if (!tstate_tss_initialized(key)) {
143 : 0 : return _PyStatus_OK();
144 : : }
145 : 0 : PyThreadState *tstate = tstate_tss_get(key);
146 : :
147 : 0 : tstate_tss_fini(key);
148 [ # # ]: 0 : if (tstate_tss_init(key) != 0) {
149 : 0 : return _PyStatus_NO_MEMORY();
150 : : }
151 : :
152 : : /* If the thread had an associated auto thread state, reassociate it with
153 : : * the new key. */
154 [ # # # # ]: 0 : if (tstate && tstate_tss_set(key, tstate) != 0) {
155 : 0 : return _PyStatus_ERR("failed to re-set autoTSSkey");
156 : : }
157 : 0 : return _PyStatus_OK();
158 : : }
159 : : #endif
160 : :
161 : :
162 : : /*
163 : : The stored thread state is set by bind_tstate() (AKA PyThreadState_Bind().
164 : :
165 : : The GIL does no need to be held for these.
166 : : */
167 : :
168 : : #define gilstate_tss_initialized(runtime) \
169 : : tstate_tss_initialized(&(runtime)->autoTSSkey)
170 : : #define gilstate_tss_init(runtime) \
171 : : tstate_tss_init(&(runtime)->autoTSSkey)
172 : : #define gilstate_tss_fini(runtime) \
173 : : tstate_tss_fini(&(runtime)->autoTSSkey)
174 : : #define gilstate_tss_get(runtime) \
175 : : tstate_tss_get(&(runtime)->autoTSSkey)
176 : : #define _gilstate_tss_set(runtime, tstate) \
177 : : tstate_tss_set(&(runtime)->autoTSSkey, tstate)
178 : : #define _gilstate_tss_clear(runtime) \
179 : : tstate_tss_clear(&(runtime)->autoTSSkey)
180 : : #define gilstate_tss_reinit(runtime) \
181 : : tstate_tss_reinit(&(runtime)->autoTSSkey)
182 : :
183 : : static inline void
184 : 29 : gilstate_tss_set(_PyRuntimeState *runtime, PyThreadState *tstate)
185 : : {
186 : : assert(tstate != NULL && tstate->interp->runtime == runtime);
187 [ - + ]: 29 : if (_gilstate_tss_set(runtime, tstate) != 0) {
188 : 0 : Py_FatalError("failed to set current tstate (TSS)");
189 : : }
190 : 29 : }
191 : :
192 : : static inline void
193 : 25 : gilstate_tss_clear(_PyRuntimeState *runtime)
194 : : {
195 [ - + ]: 25 : if (_gilstate_tss_clear(runtime) != 0) {
196 : 0 : Py_FatalError("failed to clear current tstate (TSS)");
197 : : }
198 : 25 : }
199 : :
200 : :
201 : : #ifndef NDEBUG
202 : : static inline int tstate_is_alive(PyThreadState *tstate);
203 : :
204 : : static inline int
205 : : tstate_is_bound(PyThreadState *tstate)
206 : : {
207 : : return tstate->_status.bound && !tstate->_status.unbound;
208 : : }
209 : : #endif // !NDEBUG
210 : :
211 : : static void bind_gilstate_tstate(PyThreadState *);
212 : : static void unbind_gilstate_tstate(PyThreadState *);
213 : :
214 : : static void
215 : 29 : bind_tstate(PyThreadState *tstate)
216 : : {
217 : : assert(tstate != NULL);
218 : : assert(tstate_is_alive(tstate) && !tstate->_status.bound);
219 : : assert(!tstate->_status.unbound); // just in case
220 : : assert(!tstate->_status.bound_gilstate);
221 : : assert(tstate != gilstate_tss_get(tstate->interp->runtime));
222 : : assert(!tstate->_status.active);
223 : : assert(tstate->thread_id == 0);
224 : : assert(tstate->native_thread_id == 0);
225 : :
226 : : // Currently we don't necessarily store the thread state
227 : : // in thread-local storage (e.g. per-interpreter).
228 : :
229 : 29 : tstate->thread_id = PyThread_get_thread_ident();
230 : : #ifdef PY_HAVE_THREAD_NATIVE_ID
231 : 29 : tstate->native_thread_id = PyThread_get_thread_native_id();
232 : : #endif
233 : :
234 : 29 : tstate->_status.bound = 1;
235 : 29 : }
236 : :
237 : : static void
238 : 25 : unbind_tstate(PyThreadState *tstate)
239 : : {
240 : : assert(tstate != NULL);
241 : : // XXX assert(tstate_is_alive(tstate));
242 : : assert(tstate_is_bound(tstate));
243 : : // XXX assert(!tstate->_status.active);
244 : : assert(tstate->thread_id > 0);
245 : : #ifdef PY_HAVE_THREAD_NATIVE_ID
246 : : assert(tstate->native_thread_id > 0);
247 : : #endif
248 : :
249 : : // We leave thread_id and native_thread_id alone
250 : : // since they can be useful for debugging.
251 : : // Check the `_status` field to know if these values
252 : : // are still valid.
253 : :
254 : : // We leave tstate->_status.bound set to 1
255 : : // to indicate it was previously bound.
256 : 25 : tstate->_status.unbound = 1;
257 : 25 : }
258 : :
259 : :
260 : : /* Stick the thread state for this thread in thread specific storage.
261 : :
262 : : When a thread state is created for a thread by some mechanism
263 : : other than PyGILState_Ensure(), it's important that the GILState
264 : : machinery knows about it so it doesn't try to create another
265 : : thread state for the thread.
266 : : (This is a better fix for SF bug #1010677 than the first one attempted.)
267 : :
268 : : The only situation where you can legitimately have more than one
269 : : thread state for an OS level thread is when there are multiple
270 : : interpreters.
271 : :
272 : : Before 3.12, the PyGILState_*() APIs didn't work with multiple
273 : : interpreters (see bpo-10915 and bpo-15751), so this function used
274 : : to set TSS only once. Thus, the first thread state created for that
275 : : given OS level thread would "win", which seemed reasonable behaviour.
276 : : */
277 : :
278 : : static void
279 : 29 : bind_gilstate_tstate(PyThreadState *tstate)
280 : : {
281 : : assert(tstate != NULL);
282 : : assert(tstate_is_alive(tstate));
283 : : assert(tstate_is_bound(tstate));
284 : : // XXX assert(!tstate->_status.active);
285 : : assert(!tstate->_status.bound_gilstate);
286 : :
287 : 29 : _PyRuntimeState *runtime = tstate->interp->runtime;
288 : 29 : PyThreadState *tcur = gilstate_tss_get(runtime);
289 : : assert(tstate != tcur);
290 : :
291 [ - + ]: 29 : if (tcur != NULL) {
292 : 0 : tcur->_status.bound_gilstate = 0;
293 : : }
294 : 29 : gilstate_tss_set(runtime, tstate);
295 : 29 : tstate->_status.bound_gilstate = 1;
296 : 29 : }
297 : :
298 : : static void
299 : 25 : unbind_gilstate_tstate(PyThreadState *tstate)
300 : : {
301 : : assert(tstate != NULL);
302 : : // XXX assert(tstate_is_alive(tstate));
303 : : assert(tstate_is_bound(tstate));
304 : : // XXX assert(!tstate->_status.active);
305 : : assert(tstate->_status.bound_gilstate);
306 : : assert(tstate == gilstate_tss_get(tstate->interp->runtime));
307 : :
308 : 25 : gilstate_tss_clear(tstate->interp->runtime);
309 : 25 : tstate->_status.bound_gilstate = 0;
310 : 25 : }
311 : :
312 : :
313 : : //----------------------------------------------
314 : : // the thread state that currently holds the GIL
315 : : //----------------------------------------------
316 : :
317 : : /* This is not exported, as it is not reliable! It can only
318 : : ever be compared to the state for the *current* thread.
319 : : * If not equal, then it doesn't matter that the actual
320 : : value may change immediately after comparison, as it can't
321 : : possibly change to the current thread's state.
322 : : * If equal, then the current thread holds the lock, so the value can't
323 : : change until we yield the lock.
324 : : */
325 : : static int
326 : 0 : holds_gil(PyThreadState *tstate)
327 : : {
328 : : // XXX Fall back to tstate->interp->runtime->ceval.gil.last_holder
329 : : // (and tstate->interp->runtime->ceval.gil.locked).
330 : : assert(tstate != NULL);
331 : 0 : _PyRuntimeState *runtime = tstate->interp->runtime;
332 : : /* Must be the tstate for this thread */
333 : : assert(tstate == gilstate_tss_get(runtime));
334 : 0 : return tstate == current_fast_get(runtime);
335 : : }
336 : :
337 : :
338 : : /****************************/
339 : : /* the global runtime state */
340 : : /****************************/
341 : :
342 : : //----------
343 : : // lifecycle
344 : : //----------
345 : :
346 : : /* Suppress deprecation warning for PyBytesObject.ob_shash */
347 : : _Py_COMP_DIAG_PUSH
348 : : _Py_COMP_DIAG_IGNORE_DEPR_DECLS
349 : : /* We use "initial" if the runtime gets re-used
350 : : (e.g. Py_Finalize() followed by Py_Initialize().
351 : : Note that we initialize "initial" relative to _PyRuntime,
352 : : to ensure pre-initialized pointers point to the active
353 : : runtime state (and not "initial"). */
354 : : static const _PyRuntimeState initial = _PyRuntimeState_INIT(_PyRuntime);
355 : : _Py_COMP_DIAG_POP
356 : :
357 : : static int
358 : 29 : alloc_for_runtime(PyThread_type_lock *plock1, PyThread_type_lock *plock2,
359 : : PyThread_type_lock *plock3, PyThread_type_lock *plock4)
360 : : {
361 : : /* Force default allocator, since _PyRuntimeState_Fini() must
362 : : use the same allocator than this function. */
363 : : PyMemAllocatorEx old_alloc;
364 : 29 : _PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
365 : :
366 : 29 : PyThread_type_lock lock1 = PyThread_allocate_lock();
367 [ - + ]: 29 : if (lock1 == NULL) {
368 : 0 : return -1;
369 : : }
370 : :
371 : 29 : PyThread_type_lock lock2 = PyThread_allocate_lock();
372 [ - + ]: 29 : if (lock2 == NULL) {
373 : 0 : PyThread_free_lock(lock1);
374 : 0 : return -1;
375 : : }
376 : :
377 : 29 : PyThread_type_lock lock3 = PyThread_allocate_lock();
378 [ - + ]: 29 : if (lock3 == NULL) {
379 : 0 : PyThread_free_lock(lock1);
380 : 0 : PyThread_free_lock(lock2);
381 : 0 : return -1;
382 : : }
383 : :
384 : 29 : PyThread_type_lock lock4 = PyThread_allocate_lock();
385 [ - + ]: 29 : if (lock4 == NULL) {
386 : 0 : PyThread_free_lock(lock1);
387 : 0 : PyThread_free_lock(lock2);
388 : 0 : PyThread_free_lock(lock3);
389 : 0 : return -1;
390 : : }
391 : :
392 : 29 : PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
393 : :
394 : 29 : *plock1 = lock1;
395 : 29 : *plock2 = lock2;
396 : 29 : *plock3 = lock3;
397 : 29 : *plock4 = lock4;
398 : 29 : return 0;
399 : : }
400 : :
401 : : static void
402 : 29 : init_runtime(_PyRuntimeState *runtime,
403 : : void *open_code_hook, void *open_code_userdata,
404 : : _Py_AuditHookEntry *audit_hook_head,
405 : : Py_ssize_t unicode_next_index,
406 : : PyThread_type_lock unicode_ids_mutex,
407 : : PyThread_type_lock interpreters_mutex,
408 : : PyThread_type_lock xidregistry_mutex,
409 : : PyThread_type_lock getargs_mutex)
410 : : {
411 [ - + ]: 29 : if (runtime->_initialized) {
412 : 0 : Py_FatalError("runtime already initialized");
413 : : }
414 : : assert(!runtime->preinitializing &&
415 : : !runtime->preinitialized &&
416 : : !runtime->core_initialized &&
417 : : !runtime->initialized);
418 : :
419 : 29 : runtime->open_code_hook = open_code_hook;
420 : 29 : runtime->open_code_userdata = open_code_userdata;
421 : 29 : runtime->audit_hook_head = audit_hook_head;
422 : :
423 : 29 : _PyEval_InitRuntimeState(&runtime->ceval);
424 : :
425 : 29 : PyPreConfig_InitPythonConfig(&runtime->preconfig);
426 : :
427 : 29 : runtime->interpreters.mutex = interpreters_mutex;
428 : :
429 : 29 : runtime->xidregistry.mutex = xidregistry_mutex;
430 : :
431 : 29 : runtime->getargs.mutex = getargs_mutex;
432 : :
433 : : // Set it to the ID of the main thread of the main interpreter.
434 : 29 : runtime->main_thread = PyThread_get_thread_ident();
435 : :
436 : 29 : runtime->unicode_state.ids.next_index = unicode_next_index;
437 : 29 : runtime->unicode_state.ids.lock = unicode_ids_mutex;
438 : :
439 : 29 : runtime->_initialized = 1;
440 : 29 : }
441 : :
442 : : PyStatus
443 : 29 : _PyRuntimeState_Init(_PyRuntimeState *runtime)
444 : : {
445 : : /* We preserve the hook across init, because there is
446 : : currently no public API to set it between runtime
447 : : initialization and interpreter initialization. */
448 : 29 : void *open_code_hook = runtime->open_code_hook;
449 : 29 : void *open_code_userdata = runtime->open_code_userdata;
450 : 29 : _Py_AuditHookEntry *audit_hook_head = runtime->audit_hook_head;
451 : : // bpo-42882: Preserve next_index value if Py_Initialize()/Py_Finalize()
452 : : // is called multiple times.
453 : 29 : Py_ssize_t unicode_next_index = runtime->unicode_state.ids.next_index;
454 : :
455 : : PyThread_type_lock lock1, lock2, lock3, lock4;
456 [ - + ]: 29 : if (alloc_for_runtime(&lock1, &lock2, &lock3, &lock4) != 0) {
457 : 0 : return _PyStatus_NO_MEMORY();
458 : : }
459 : :
460 [ - + ]: 29 : if (runtime->_initialized) {
461 : : // Py_Initialize() must be running again.
462 : : // Reset to _PyRuntimeState_INIT.
463 : 0 : memcpy(runtime, &initial, sizeof(*runtime));
464 : : }
465 : :
466 [ - + ]: 29 : if (gilstate_tss_init(runtime) != 0) {
467 : 0 : _PyRuntimeState_Fini(runtime);
468 : 0 : return _PyStatus_NO_MEMORY();
469 : : }
470 : :
471 [ - + ]: 29 : if (PyThread_tss_create(&runtime->trashTSSkey) != 0) {
472 : 0 : _PyRuntimeState_Fini(runtime);
473 : 0 : return _PyStatus_NO_MEMORY();
474 : : }
475 : :
476 : 29 : init_runtime(runtime, open_code_hook, open_code_userdata, audit_hook_head,
477 : : unicode_next_index, lock1, lock2, lock3, lock4);
478 : :
479 : 29 : return _PyStatus_OK();
480 : : }
481 : :
482 : : void
483 : 50 : _PyRuntimeState_Fini(_PyRuntimeState *runtime)
484 : : {
485 [ + + ]: 50 : if (gilstate_tss_initialized(runtime)) {
486 : 25 : gilstate_tss_fini(runtime);
487 : : }
488 : :
489 [ + + ]: 50 : if (PyThread_tss_is_created(&runtime->trashTSSkey)) {
490 : 25 : PyThread_tss_delete(&runtime->trashTSSkey);
491 : : }
492 : :
493 : : /* Force the allocator used by _PyRuntimeState_Init(). */
494 : : PyMemAllocatorEx old_alloc;
495 : 50 : _PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
496 : : #define FREE_LOCK(LOCK) \
497 : : if (LOCK != NULL) { \
498 : : PyThread_free_lock(LOCK); \
499 : : LOCK = NULL; \
500 : : }
501 : :
502 [ + + ]: 50 : FREE_LOCK(runtime->interpreters.mutex);
503 [ + + ]: 50 : FREE_LOCK(runtime->xidregistry.mutex);
504 [ + + ]: 50 : FREE_LOCK(runtime->unicode_state.ids.lock);
505 [ + + ]: 50 : FREE_LOCK(runtime->getargs.mutex);
506 : :
507 : : #undef FREE_LOCK
508 : 50 : PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
509 : 50 : }
510 : :
511 : : #ifdef HAVE_FORK
512 : : /* This function is called from PyOS_AfterFork_Child to ensure that
513 : : newly created child processes do not share locks with the parent. */
514 : : PyStatus
515 : 0 : _PyRuntimeState_ReInitThreads(_PyRuntimeState *runtime)
516 : : {
517 : : // This was initially set in _PyRuntimeState_Init().
518 : 0 : runtime->main_thread = PyThread_get_thread_ident();
519 : :
520 : : /* Force default allocator, since _PyRuntimeState_Fini() must
521 : : use the same allocator than this function. */
522 : : PyMemAllocatorEx old_alloc;
523 : 0 : _PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
524 : :
525 : 0 : int reinit_interp = _PyThread_at_fork_reinit(&runtime->interpreters.mutex);
526 : 0 : int reinit_xidregistry = _PyThread_at_fork_reinit(&runtime->xidregistry.mutex);
527 : 0 : int reinit_unicode_ids = _PyThread_at_fork_reinit(&runtime->unicode_state.ids.lock);
528 : 0 : int reinit_getargs = _PyThread_at_fork_reinit(&runtime->getargs.mutex);
529 : :
530 : 0 : PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
531 : :
532 : : /* bpo-42540: id_mutex is freed by _PyInterpreterState_Delete, which does
533 : : * not force the default allocator. */
534 : 0 : int reinit_main_id = _PyThread_at_fork_reinit(&runtime->interpreters.main->id_mutex);
535 : :
536 [ # # ]: 0 : if (reinit_interp < 0
537 [ # # ]: 0 : || reinit_main_id < 0
538 [ # # ]: 0 : || reinit_xidregistry < 0
539 [ # # ]: 0 : || reinit_unicode_ids < 0
540 [ # # ]: 0 : || reinit_getargs < 0)
541 : : {
542 : 0 : return _PyStatus_ERR("Failed to reinitialize runtime locks");
543 : :
544 : : }
545 : :
546 : 0 : PyStatus status = gilstate_tss_reinit(runtime);
547 [ # # ]: 0 : if (_PyStatus_EXCEPTION(status)) {
548 : 0 : return status;
549 : : }
550 : :
551 [ # # ]: 0 : if (PyThread_tss_is_created(&runtime->trashTSSkey)) {
552 : 0 : PyThread_tss_delete(&runtime->trashTSSkey);
553 : : }
554 [ # # ]: 0 : if (PyThread_tss_create(&runtime->trashTSSkey) != 0) {
555 : 0 : return _PyStatus_NO_MEMORY();
556 : : }
557 : :
558 : 0 : return _PyStatus_OK();
559 : : }
560 : : #endif
561 : :
562 : :
563 : : /*************************************/
564 : : /* the per-interpreter runtime state */
565 : : /*************************************/
566 : :
567 : : //----------
568 : : // lifecycle
569 : : //----------
570 : :
571 : : /* Calling this indicates that the runtime is ready to create interpreters. */
572 : :
573 : : PyStatus
574 : 29 : _PyInterpreterState_Enable(_PyRuntimeState *runtime)
575 : : {
576 : 29 : struct pyinterpreters *interpreters = &runtime->interpreters;
577 : 29 : interpreters->next_id = 0;
578 : :
579 : : /* Py_Finalize() calls _PyRuntimeState_Fini() which clears the mutex.
580 : : Create a new mutex if needed. */
581 [ - + ]: 29 : if (interpreters->mutex == NULL) {
582 : : /* Force default allocator, since _PyRuntimeState_Fini() must
583 : : use the same allocator than this function. */
584 : : PyMemAllocatorEx old_alloc;
585 : 0 : _PyMem_SetDefaultAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
586 : :
587 : 0 : interpreters->mutex = PyThread_allocate_lock();
588 : :
589 : 0 : PyMem_SetAllocator(PYMEM_DOMAIN_RAW, &old_alloc);
590 : :
591 [ # # ]: 0 : if (interpreters->mutex == NULL) {
592 : 0 : return _PyStatus_ERR("Can't initialize threads for interpreter");
593 : : }
594 : : }
595 : :
596 : 29 : return _PyStatus_OK();
597 : : }
598 : :
599 : :
600 : : static PyInterpreterState *
601 : 0 : alloc_interpreter(void)
602 : : {
603 : 0 : return PyMem_RawCalloc(1, sizeof(PyInterpreterState));
604 : : }
605 : :
606 : : static void
607 : 25 : free_interpreter(PyInterpreterState *interp)
608 : : {
609 : : // The main interpreter is statically allocated so
610 : : // should not be freed.
611 [ - + ]: 25 : if (interp != &_PyRuntime._main_interpreter) {
612 : 0 : PyMem_RawFree(interp);
613 : : }
614 : 25 : }
615 : :
616 : : /* Get the interpreter state to a minimal consistent state.
617 : : Further init happens in pylifecycle.c before it can be used.
618 : : All fields not initialized here are expected to be zeroed out,
619 : : e.g. by PyMem_RawCalloc() or memset(), or otherwise pre-initialized.
620 : : The runtime state is not manipulated. Instead it is assumed that
621 : : the interpreter is getting added to the runtime.
622 : :
623 : : Note that the main interpreter was statically initialized as part
624 : : of the runtime and most state is already set properly. That leaves
625 : : a small number of fields to initialize dynamically, as well as some
626 : : that are initialized lazily.
627 : :
628 : : For subinterpreters we memcpy() the main interpreter in
629 : : PyInterpreterState_New(), leaving it in the same mostly-initialized
630 : : state. The only difference is that the interpreter has some
631 : : self-referential state that is statically initializexd to the
632 : : main interpreter. We fix those fields here, in addition
633 : : to the other dynamically initialized fields.
634 : : */
635 : :
636 : : static void
637 : 29 : init_interpreter(PyInterpreterState *interp,
638 : : _PyRuntimeState *runtime, int64_t id,
639 : : PyInterpreterState *next,
640 : : PyThread_type_lock pending_lock)
641 : : {
642 [ - + ]: 29 : if (interp->_initialized) {
643 : 0 : Py_FatalError("interpreter already initialized");
644 : : }
645 : :
646 : : assert(runtime != NULL);
647 : 29 : interp->runtime = runtime;
648 : :
649 : : assert(id > 0 || (id == 0 && interp == runtime->interpreters.main));
650 : 29 : interp->id = id;
651 : :
652 : : assert(runtime->interpreters.head == interp);
653 : : assert(next != NULL || (interp == runtime->interpreters.main));
654 : 29 : interp->next = next;
655 : :
656 : 29 : _PyEval_InitState(&interp->ceval, pending_lock);
657 : 29 : _PyGC_InitState(&interp->gc);
658 : 29 : PyConfig_InitPythonConfig(&interp->config);
659 : 29 : _PyType_InitCache(interp);
660 : :
661 [ - + ]: 29 : if (interp != &runtime->_main_interpreter) {
662 : : /* Fix the self-referential, statically initialized fields. */
663 : 0 : interp->dtoa = (struct _dtoa_state)_dtoa_state_INIT(interp);
664 : : }
665 : :
666 : 29 : interp->_initialized = 1;
667 : 29 : }
668 : :
669 : : PyInterpreterState *
670 : 29 : PyInterpreterState_New(void)
671 : : {
672 : : PyInterpreterState *interp;
673 : 29 : _PyRuntimeState *runtime = &_PyRuntime;
674 : 29 : PyThreadState *tstate = current_fast_get(runtime);
675 : :
676 : : /* tstate is NULL when Py_InitializeFromConfig() calls
677 : : PyInterpreterState_New() to create the main interpreter. */
678 [ - + ]: 29 : if (_PySys_Audit(tstate, "cpython.PyInterpreterState_New", NULL) < 0) {
679 : 0 : return NULL;
680 : : }
681 : :
682 : 29 : PyThread_type_lock pending_lock = PyThread_allocate_lock();
683 [ - + ]: 29 : if (pending_lock == NULL) {
684 [ # # ]: 0 : if (tstate != NULL) {
685 : 0 : _PyErr_NoMemory(tstate);
686 : : }
687 : 0 : return NULL;
688 : : }
689 : :
690 : : /* Don't get runtime from tstate since tstate can be NULL. */
691 : 29 : struct pyinterpreters *interpreters = &runtime->interpreters;
692 : :
693 : : /* We completely serialize creation of multiple interpreters, since
694 : : it simplifies things here and blocking concurrent calls isn't a problem.
695 : : Regardless, we must fully block subinterpreter creation until
696 : : after the main interpreter is created. */
697 : 29 : HEAD_LOCK(runtime);
698 : :
699 : 29 : int64_t id = interpreters->next_id;
700 : 29 : interpreters->next_id += 1;
701 : :
702 : : // Allocate the interpreter and add it to the runtime state.
703 : 29 : PyInterpreterState *old_head = interpreters->head;
704 [ + - ]: 29 : if (old_head == NULL) {
705 : : // We are creating the main interpreter.
706 : : assert(interpreters->main == NULL);
707 : : assert(id == 0);
708 : :
709 : 29 : interp = &runtime->_main_interpreter;
710 : : assert(interp->id == 0);
711 : : assert(interp->next == NULL);
712 : :
713 : 29 : interpreters->main = interp;
714 : : }
715 : : else {
716 : : assert(interpreters->main != NULL);
717 : : assert(id != 0);
718 : :
719 : 0 : interp = alloc_interpreter();
720 [ # # ]: 0 : if (interp == NULL) {
721 : 0 : goto error;
722 : : }
723 : : // Set to _PyInterpreterState_INIT.
724 : 0 : memcpy(interp, &initial._main_interpreter,
725 : : sizeof(*interp));
726 : :
727 [ # # ]: 0 : if (id < 0) {
728 : : /* overflow or Py_Initialize() not called yet! */
729 [ # # ]: 0 : if (tstate != NULL) {
730 : 0 : _PyErr_SetString(tstate, PyExc_RuntimeError,
731 : : "failed to get an interpreter ID");
732 : : }
733 : 0 : goto error;
734 : : }
735 : : }
736 : 29 : interpreters->head = interp;
737 : :
738 : 29 : init_interpreter(interp, runtime, id, old_head, pending_lock);
739 : :
740 : 29 : HEAD_UNLOCK(runtime);
741 : 29 : return interp;
742 : :
743 : 0 : error:
744 : 0 : HEAD_UNLOCK(runtime);
745 : :
746 : 0 : PyThread_free_lock(pending_lock);
747 [ # # ]: 0 : if (interp != NULL) {
748 : 0 : free_interpreter(interp);
749 : : }
750 : 0 : return NULL;
751 : : }
752 : :
753 : :
754 : : static void
755 : 25 : interpreter_clear(PyInterpreterState *interp, PyThreadState *tstate)
756 : : {
757 : : assert(interp != NULL);
758 : : assert(tstate != NULL);
759 : 25 : _PyRuntimeState *runtime = interp->runtime;
760 : :
761 : : /* XXX Conditions we need to enforce:
762 : :
763 : : * the GIL must be held by the current thread
764 : : * tstate must be the "current" thread state (current_fast_get())
765 : : * tstate->interp must be interp
766 : : * for the main interpreter, tstate must be the main thread
767 : : */
768 : : // XXX Ideally, we would not rely on any thread state in this function
769 : : // (and we would drop the "tstate" argument).
770 : :
771 [ - + ]: 25 : if (_PySys_Audit(tstate, "cpython.PyInterpreterState_Clear", NULL) < 0) {
772 : 0 : _PyErr_Clear(tstate);
773 : : }
774 : :
775 : : // Clear the current/main thread state last.
776 : 25 : HEAD_LOCK(runtime);
777 : 25 : PyThreadState *p = interp->threads.head;
778 : 25 : HEAD_UNLOCK(runtime);
779 [ + + ]: 50 : while (p != NULL) {
780 : : // See https://github.com/python/cpython/issues/102126
781 : : // Must be called without HEAD_LOCK held as it can deadlock
782 : : // if any finalizer tries to acquire that lock.
783 : 25 : PyThreadState_Clear(p);
784 : 25 : HEAD_LOCK(runtime);
785 : 25 : p = p->next;
786 : 25 : HEAD_UNLOCK(runtime);
787 : : }
788 : :
789 : : /* It is possible that any of the objects below have a finalizer
790 : : that runs Python code or otherwise relies on a thread state
791 : : or even the interpreter state. For now we trust that isn't
792 : : a problem.
793 : : */
794 : : // XXX Make sure we properly deal with problematic finalizers.
795 : :
796 [ + + ]: 25 : Py_CLEAR(interp->audit_hooks);
797 : :
798 : 25 : PyConfig_Clear(&interp->config);
799 [ + - ]: 25 : Py_CLEAR(interp->codec_search_path);
800 [ + - ]: 25 : Py_CLEAR(interp->codec_search_cache);
801 [ + - ]: 25 : Py_CLEAR(interp->codec_error_registry);
802 : :
803 : : assert(interp->imports.modules == NULL);
804 : : assert(interp->imports.modules_by_index == NULL);
805 : : assert(interp->imports.importlib == NULL);
806 : : assert(interp->imports.import_func == NULL);
807 : :
808 [ + - ]: 25 : Py_CLEAR(interp->sysdict_copy);
809 [ + - ]: 25 : Py_CLEAR(interp->builtins_copy);
810 [ - + ]: 25 : Py_CLEAR(interp->dict);
811 : : #ifdef HAVE_FORK
812 [ + + ]: 25 : Py_CLEAR(interp->before_forkers);
813 [ + + ]: 25 : Py_CLEAR(interp->after_forkers_parent);
814 [ + + ]: 25 : Py_CLEAR(interp->after_forkers_child);
815 : : #endif
816 : :
817 : 25 : _PyAST_Fini(interp);
818 : 25 : _PyWarnings_Fini(interp);
819 : 25 : _PyAtExit_Fini(interp);
820 : :
821 : : // All Python types must be destroyed before the last GC collection. Python
822 : : // types create a reference cycle to themselves in their in their
823 : : // PyTypeObject.tp_mro member (the tuple contains the type).
824 : :
825 : : /* Last garbage collection on this interpreter */
826 : 25 : _PyGC_CollectNoFail(tstate);
827 : 25 : _PyGC_Fini(interp);
828 : :
829 : : /* We don't clear sysdict and builtins until the end of this function.
830 : : Because clearing other attributes can execute arbitrary Python code
831 : : which requires sysdict and builtins. */
832 : 25 : PyDict_Clear(interp->sysdict);
833 : 25 : PyDict_Clear(interp->builtins);
834 [ + - ]: 25 : Py_CLEAR(interp->sysdict);
835 [ + - ]: 25 : Py_CLEAR(interp->builtins);
836 [ + - ]: 25 : Py_CLEAR(interp->interpreter_trampoline);
837 : :
838 [ + + ]: 225 : for (int i=0; i < DICT_MAX_WATCHERS; i++) {
839 : 200 : interp->dict_state.watchers[i] = NULL;
840 : : }
841 : :
842 [ + + ]: 225 : for (int i=0; i < TYPE_MAX_WATCHERS; i++) {
843 : 200 : interp->type_watchers[i] = NULL;
844 : : }
845 : :
846 [ + + ]: 225 : for (int i=0; i < FUNC_MAX_WATCHERS; i++) {
847 : 200 : interp->func_watchers[i] = NULL;
848 : : }
849 : 25 : interp->active_func_watchers = 0;
850 : :
851 [ + + ]: 225 : for (int i=0; i < CODE_MAX_WATCHERS; i++) {
852 : 200 : interp->code_watchers[i] = NULL;
853 : : }
854 : 25 : interp->active_code_watchers = 0;
855 : :
856 : : // XXX Once we have one allocator per interpreter (i.e.
857 : : // per-interpreter GC) we must ensure that all of the interpreter's
858 : : // objects have been cleaned up at the point.
859 : 25 : }
860 : :
861 : :
862 : : void
863 : 0 : PyInterpreterState_Clear(PyInterpreterState *interp)
864 : : {
865 : : // Use the current Python thread state to call audit hooks and to collect
866 : : // garbage. It can be different than the current Python thread state
867 : : // of 'interp'.
868 : 0 : PyThreadState *current_tstate = current_fast_get(interp->runtime);
869 : 0 : _PyImport_ClearCore(interp);
870 : 0 : interpreter_clear(interp, current_tstate);
871 : 0 : }
872 : :
873 : :
874 : : void
875 : 25 : _PyInterpreterState_Clear(PyThreadState *tstate)
876 : : {
877 : 25 : _PyImport_ClearCore(tstate->interp);
878 : 25 : interpreter_clear(tstate->interp, tstate);
879 : 25 : }
880 : :
881 : :
882 : : static void zapthreads(PyInterpreterState *interp);
883 : :
884 : : void
885 : 25 : PyInterpreterState_Delete(PyInterpreterState *interp)
886 : : {
887 : 25 : _PyRuntimeState *runtime = interp->runtime;
888 : 25 : struct pyinterpreters *interpreters = &runtime->interpreters;
889 : :
890 : : // XXX Clearing the "current" thread state should happen before
891 : : // we start finalizing the interpreter (or the current thread state).
892 : 25 : PyThreadState *tcur = current_fast_get(runtime);
893 [ + - + - ]: 25 : if (tcur != NULL && interp == tcur->interp) {
894 : : /* Unset current thread. After this, many C API calls become crashy. */
895 : 25 : _PyThreadState_Swap(runtime, NULL);
896 : : }
897 : :
898 : 25 : zapthreads(interp);
899 : :
900 : 25 : _PyEval_FiniState(&interp->ceval);
901 : :
902 : 25 : HEAD_LOCK(runtime);
903 : : PyInterpreterState **p;
904 : 25 : for (p = &interpreters->head; ; p = &(*p)->next) {
905 [ - + ]: 25 : if (*p == NULL) {
906 : 0 : Py_FatalError("NULL interpreter");
907 : : }
908 [ + - ]: 25 : if (*p == interp) {
909 : 25 : break;
910 : : }
911 : : }
912 [ - + ]: 25 : if (interp->threads.head != NULL) {
913 : 0 : Py_FatalError("remaining threads");
914 : : }
915 : 25 : *p = interp->next;
916 : :
917 [ + - ]: 25 : if (interpreters->main == interp) {
918 : 25 : interpreters->main = NULL;
919 [ - + ]: 25 : if (interpreters->head != NULL) {
920 : 0 : Py_FatalError("remaining subinterpreters");
921 : : }
922 : : }
923 : 25 : HEAD_UNLOCK(runtime);
924 : :
925 [ - + ]: 25 : if (interp->id_mutex != NULL) {
926 : 0 : PyThread_free_lock(interp->id_mutex);
927 : : }
928 : 25 : free_interpreter(interp);
929 : 25 : }
930 : :
931 : :
932 : : #ifdef HAVE_FORK
933 : : /*
934 : : * Delete all interpreter states except the main interpreter. If there
935 : : * is a current interpreter state, it *must* be the main interpreter.
936 : : */
937 : : PyStatus
938 : 0 : _PyInterpreterState_DeleteExceptMain(_PyRuntimeState *runtime)
939 : : {
940 : 0 : struct pyinterpreters *interpreters = &runtime->interpreters;
941 : :
942 : 0 : PyThreadState *tstate = _PyThreadState_Swap(runtime, NULL);
943 [ # # # # ]: 0 : if (tstate != NULL && tstate->interp != interpreters->main) {
944 : 0 : return _PyStatus_ERR("not main interpreter");
945 : : }
946 : :
947 : 0 : HEAD_LOCK(runtime);
948 : 0 : PyInterpreterState *interp = interpreters->head;
949 : 0 : interpreters->head = NULL;
950 [ # # ]: 0 : while (interp != NULL) {
951 [ # # ]: 0 : if (interp == interpreters->main) {
952 : 0 : interpreters->main->next = NULL;
953 : 0 : interpreters->head = interp;
954 : 0 : interp = interp->next;
955 : 0 : continue;
956 : : }
957 : :
958 : : // XXX Won't this fail since PyInterpreterState_Clear() requires
959 : : // the "current" tstate to be set?
960 : 0 : PyInterpreterState_Clear(interp); // XXX must activate?
961 : 0 : zapthreads(interp);
962 [ # # ]: 0 : if (interp->id_mutex != NULL) {
963 : 0 : PyThread_free_lock(interp->id_mutex);
964 : : }
965 : 0 : PyInterpreterState *prev_interp = interp;
966 : 0 : interp = interp->next;
967 : 0 : free_interpreter(prev_interp);
968 : : }
969 : 0 : HEAD_UNLOCK(runtime);
970 : :
971 [ # # ]: 0 : if (interpreters->head == NULL) {
972 : 0 : return _PyStatus_ERR("missing main interpreter");
973 : : }
974 : 0 : _PyThreadState_Swap(runtime, tstate);
975 : 0 : return _PyStatus_OK();
976 : : }
977 : : #endif
978 : :
979 : :
980 : : //----------
981 : : // accessors
982 : : //----------
983 : :
984 : : int64_t
985 : 0 : PyInterpreterState_GetID(PyInterpreterState *interp)
986 : : {
987 [ # # ]: 0 : if (interp == NULL) {
988 : 0 : PyErr_SetString(PyExc_RuntimeError, "no interpreter provided");
989 : 0 : return -1;
990 : : }
991 : 0 : return interp->id;
992 : : }
993 : :
994 : :
995 : : int
996 : 0 : _PyInterpreterState_IDInitref(PyInterpreterState *interp)
997 : : {
998 [ # # ]: 0 : if (interp->id_mutex != NULL) {
999 : 0 : return 0;
1000 : : }
1001 : 0 : interp->id_mutex = PyThread_allocate_lock();
1002 [ # # ]: 0 : if (interp->id_mutex == NULL) {
1003 : 0 : PyErr_SetString(PyExc_RuntimeError,
1004 : : "failed to create init interpreter ID mutex");
1005 : 0 : return -1;
1006 : : }
1007 : 0 : interp->id_refcount = 0;
1008 : 0 : return 0;
1009 : : }
1010 : :
1011 : :
1012 : : int
1013 : 0 : _PyInterpreterState_IDIncref(PyInterpreterState *interp)
1014 : : {
1015 [ # # ]: 0 : if (_PyInterpreterState_IDInitref(interp) < 0) {
1016 : 0 : return -1;
1017 : : }
1018 : :
1019 : 0 : PyThread_acquire_lock(interp->id_mutex, WAIT_LOCK);
1020 : 0 : interp->id_refcount += 1;
1021 : 0 : PyThread_release_lock(interp->id_mutex);
1022 : 0 : return 0;
1023 : : }
1024 : :
1025 : :
1026 : : void
1027 : 0 : _PyInterpreterState_IDDecref(PyInterpreterState *interp)
1028 : : {
1029 : : assert(interp->id_mutex != NULL);
1030 : 0 : _PyRuntimeState *runtime = interp->runtime;
1031 : :
1032 : 0 : PyThread_acquire_lock(interp->id_mutex, WAIT_LOCK);
1033 : : assert(interp->id_refcount != 0);
1034 : 0 : interp->id_refcount -= 1;
1035 : 0 : int64_t refcount = interp->id_refcount;
1036 : 0 : PyThread_release_lock(interp->id_mutex);
1037 : :
1038 [ # # # # ]: 0 : if (refcount == 0 && interp->requires_idref) {
1039 : : // XXX Using the "head" thread isn't strictly correct.
1040 : 0 : PyThreadState *tstate = PyInterpreterState_ThreadHead(interp);
1041 : : // XXX Possible GILState issues?
1042 : 0 : PyThreadState *save_tstate = _PyThreadState_Swap(runtime, tstate);
1043 : 0 : Py_EndInterpreter(tstate);
1044 : 0 : _PyThreadState_Swap(runtime, save_tstate);
1045 : : }
1046 : 0 : }
1047 : :
1048 : : int
1049 : 0 : _PyInterpreterState_RequiresIDRef(PyInterpreterState *interp)
1050 : : {
1051 : 0 : return interp->requires_idref;
1052 : : }
1053 : :
1054 : : void
1055 : 0 : _PyInterpreterState_RequireIDRef(PyInterpreterState *interp, int required)
1056 : : {
1057 : 0 : interp->requires_idref = required ? 1 : 0;
1058 : 0 : }
1059 : :
1060 : : PyObject *
1061 : 0 : _PyInterpreterState_GetMainModule(PyInterpreterState *interp)
1062 : : {
1063 : 0 : PyObject *modules = _PyImport_GetModules(interp);
1064 [ # # ]: 0 : if (modules == NULL) {
1065 : 0 : PyErr_SetString(PyExc_RuntimeError, "interpreter not initialized");
1066 : 0 : return NULL;
1067 : : }
1068 : 0 : return PyMapping_GetItemString(modules, "__main__");
1069 : : }
1070 : :
1071 : : PyObject *
1072 : 0 : PyInterpreterState_GetDict(PyInterpreterState *interp)
1073 : : {
1074 [ # # ]: 0 : if (interp->dict == NULL) {
1075 : 0 : interp->dict = PyDict_New();
1076 [ # # ]: 0 : if (interp->dict == NULL) {
1077 : 0 : PyErr_Clear();
1078 : : }
1079 : : }
1080 : : /* Returning NULL means no per-interpreter dict is available. */
1081 : 0 : return interp->dict;
1082 : : }
1083 : :
1084 : :
1085 : : //-----------------------------
1086 : : // look up an interpreter state
1087 : : //-----------------------------
1088 : :
1089 : : /* Return the interpreter associated with the current OS thread.
1090 : :
1091 : : The GIL must be held.
1092 : : */
1093 : :
1094 : : PyInterpreterState *
1095 : 102301 : PyInterpreterState_Get(void)
1096 : : {
1097 : 102301 : PyThreadState *tstate = current_fast_get(&_PyRuntime);
1098 : 102301 : _Py_EnsureTstateNotNULL(tstate);
1099 : 102301 : PyInterpreterState *interp = tstate->interp;
1100 [ - + ]: 102301 : if (interp == NULL) {
1101 : 0 : Py_FatalError("no current interpreter");
1102 : : }
1103 : 102301 : return interp;
1104 : : }
1105 : :
1106 : :
1107 : : static PyInterpreterState *
1108 : 0 : interp_look_up_id(_PyRuntimeState *runtime, int64_t requested_id)
1109 : : {
1110 : 0 : PyInterpreterState *interp = runtime->interpreters.head;
1111 [ # # ]: 0 : while (interp != NULL) {
1112 : 0 : int64_t id = PyInterpreterState_GetID(interp);
1113 [ # # ]: 0 : if (id < 0) {
1114 : 0 : return NULL;
1115 : : }
1116 [ # # ]: 0 : if (requested_id == id) {
1117 : 0 : return interp;
1118 : : }
1119 : 0 : interp = PyInterpreterState_Next(interp);
1120 : : }
1121 : 0 : return NULL;
1122 : : }
1123 : :
1124 : : /* Return the interpreter state with the given ID.
1125 : :
1126 : : Fail with RuntimeError if the interpreter is not found. */
1127 : :
1128 : : PyInterpreterState *
1129 : 0 : _PyInterpreterState_LookUpID(int64_t requested_id)
1130 : : {
1131 : 0 : PyInterpreterState *interp = NULL;
1132 [ # # ]: 0 : if (requested_id >= 0) {
1133 : 0 : _PyRuntimeState *runtime = &_PyRuntime;
1134 : 0 : HEAD_LOCK(runtime);
1135 : 0 : interp = interp_look_up_id(runtime, requested_id);
1136 : 0 : HEAD_UNLOCK(runtime);
1137 : : }
1138 [ # # # # ]: 0 : if (interp == NULL && !PyErr_Occurred()) {
1139 : 0 : PyErr_Format(PyExc_RuntimeError,
1140 : : "unrecognized interpreter ID %lld", requested_id);
1141 : : }
1142 : 0 : return interp;
1143 : : }
1144 : :
1145 : :
1146 : : /********************************/
1147 : : /* the per-thread runtime state */
1148 : : /********************************/
1149 : :
1150 : : #ifndef NDEBUG
1151 : : static inline int
1152 : : tstate_is_alive(PyThreadState *tstate)
1153 : : {
1154 : : return (tstate->_status.initialized &&
1155 : : !tstate->_status.finalized &&
1156 : : !tstate->_status.cleared &&
1157 : : !tstate->_status.finalizing);
1158 : : }
1159 : : #endif
1160 : :
1161 : :
1162 : : //----------
1163 : : // lifecycle
1164 : : //----------
1165 : :
1166 : : /* Minimum size of data stack chunk */
1167 : : #define DATA_STACK_CHUNK_SIZE (16*1024)
1168 : :
1169 : : static _PyStackChunk*
1170 : 25 : allocate_chunk(int size_in_bytes, _PyStackChunk* previous)
1171 : : {
1172 : : assert(size_in_bytes % sizeof(PyObject **) == 0);
1173 : 25 : _PyStackChunk *res = _PyObject_VirtualAlloc(size_in_bytes);
1174 [ - + ]: 25 : if (res == NULL) {
1175 : 0 : return NULL;
1176 : : }
1177 : 25 : res->previous = previous;
1178 : 25 : res->size = size_in_bytes;
1179 : 25 : res->top = 0;
1180 : 25 : return res;
1181 : : }
1182 : :
1183 : : static PyThreadState *
1184 : 29 : alloc_threadstate(void)
1185 : : {
1186 : 29 : return PyMem_RawCalloc(1, sizeof(PyThreadState));
1187 : : }
1188 : :
1189 : : static void
1190 : 25 : free_threadstate(PyThreadState *tstate)
1191 : : {
1192 : : // The initial thread state of the interpreter is allocated
1193 : : // as part of the interpreter state so should not be freed.
1194 [ - + ]: 25 : if (tstate != &tstate->interp->_initial_thread) {
1195 : 0 : PyMem_RawFree(tstate);
1196 : : }
1197 : 25 : }
1198 : :
1199 : : /* Get the thread state to a minimal consistent state.
1200 : : Further init happens in pylifecycle.c before it can be used.
1201 : : All fields not initialized here are expected to be zeroed out,
1202 : : e.g. by PyMem_RawCalloc() or memset(), or otherwise pre-initialized.
1203 : : The interpreter state is not manipulated. Instead it is assumed that
1204 : : the thread is getting added to the interpreter.
1205 : : */
1206 : :
1207 : : static void
1208 : 29 : init_threadstate(PyThreadState *tstate,
1209 : : PyInterpreterState *interp, uint64_t id,
1210 : : PyThreadState *next)
1211 : : {
1212 [ - + ]: 29 : if (tstate->_status.initialized) {
1213 : 0 : Py_FatalError("thread state already initialized");
1214 : : }
1215 : :
1216 : : assert(interp != NULL);
1217 : 29 : tstate->interp = interp;
1218 : :
1219 : : assert(id > 0);
1220 : 29 : tstate->id = id;
1221 : :
1222 : : assert(interp->threads.head == tstate);
1223 : : assert((next != NULL && id != 1) || (next == NULL && id == 1));
1224 [ - + ]: 29 : if (next != NULL) {
1225 : : assert(next->prev == NULL || next->prev == tstate);
1226 : 0 : next->prev = tstate;
1227 : : }
1228 : 29 : tstate->next = next;
1229 : : assert(tstate->prev == NULL);
1230 : :
1231 : : // thread_id and native_thread_id are set in bind_tstate().
1232 : :
1233 : 29 : tstate->py_recursion_limit = interp->ceval.recursion_limit,
1234 : 29 : tstate->py_recursion_remaining = interp->ceval.recursion_limit,
1235 : 29 : tstate->c_recursion_remaining = C_RECURSION_LIMIT;
1236 : :
1237 : 29 : tstate->exc_info = &tstate->exc_state;
1238 : :
1239 : : // PyGILState_Release must not try to delete this thread state.
1240 : : // This is cleared when PyGILState_Ensure() creates the thread state.
1241 : 29 : tstate->gilstate_counter = 1;
1242 : :
1243 : 29 : tstate->cframe = &tstate->root_cframe;
1244 : 29 : tstate->datastack_chunk = NULL;
1245 : 29 : tstate->datastack_top = NULL;
1246 : 29 : tstate->datastack_limit = NULL;
1247 : :
1248 : 29 : tstate->_status.initialized = 1;
1249 : 29 : }
1250 : :
1251 : : static PyThreadState *
1252 : 29 : new_threadstate(PyInterpreterState *interp)
1253 : : {
1254 : : PyThreadState *tstate;
1255 : 29 : _PyRuntimeState *runtime = interp->runtime;
1256 : : // We don't need to allocate a thread state for the main interpreter
1257 : : // (the common case), but doing it later for the other case revealed a
1258 : : // reentrancy problem (deadlock). So for now we always allocate before
1259 : : // taking the interpreters lock. See GH-96071.
1260 : 29 : PyThreadState *new_tstate = alloc_threadstate();
1261 : : int used_newtstate;
1262 [ - + ]: 29 : if (new_tstate == NULL) {
1263 : 0 : return NULL;
1264 : : }
1265 : : /* We serialize concurrent creation to protect global state. */
1266 : 29 : HEAD_LOCK(runtime);
1267 : :
1268 : 29 : interp->threads.next_unique_id += 1;
1269 : 29 : uint64_t id = interp->threads.next_unique_id;
1270 : :
1271 : : // Allocate the thread state and add it to the interpreter.
1272 : 29 : PyThreadState *old_head = interp->threads.head;
1273 [ + - ]: 29 : if (old_head == NULL) {
1274 : : // It's the interpreter's initial thread state.
1275 : : assert(id == 1);
1276 : 29 : used_newtstate = 0;
1277 : 29 : tstate = &interp->_initial_thread;
1278 : : }
1279 : : else {
1280 : : // Every valid interpreter must have at least one thread.
1281 : : assert(id > 1);
1282 : : assert(old_head->prev == NULL);
1283 : 0 : used_newtstate = 1;
1284 : 0 : tstate = new_tstate;
1285 : : // Set to _PyThreadState_INIT.
1286 : 0 : memcpy(tstate,
1287 : : &initial._main_interpreter._initial_thread,
1288 : : sizeof(*tstate));
1289 : : }
1290 : 29 : interp->threads.head = tstate;
1291 : :
1292 : 29 : init_threadstate(tstate, interp, id, old_head);
1293 : :
1294 : 29 : HEAD_UNLOCK(runtime);
1295 [ + - ]: 29 : if (!used_newtstate) {
1296 : : // Must be called with lock unlocked to avoid re-entrancy deadlock.
1297 : 29 : PyMem_RawFree(new_tstate);
1298 : : }
1299 : 29 : return tstate;
1300 : : }
1301 : :
1302 : : PyThreadState *
1303 : 0 : PyThreadState_New(PyInterpreterState *interp)
1304 : : {
1305 : 0 : PyThreadState *tstate = new_threadstate(interp);
1306 [ # # ]: 0 : if (tstate) {
1307 : 0 : bind_tstate(tstate);
1308 : : // This makes sure there's a gilstate tstate bound
1309 : : // as soon as possible.
1310 [ # # ]: 0 : if (gilstate_tss_get(tstate->interp->runtime) == NULL) {
1311 : 0 : bind_gilstate_tstate(tstate);
1312 : : }
1313 : : }
1314 : 0 : return tstate;
1315 : : }
1316 : :
1317 : : // This must be followed by a call to _PyThreadState_Bind();
1318 : : PyThreadState *
1319 : 29 : _PyThreadState_New(PyInterpreterState *interp)
1320 : : {
1321 : 29 : return new_threadstate(interp);
1322 : : }
1323 : :
1324 : : // We keep this for stable ABI compabibility.
1325 : : PyThreadState *
1326 : 0 : _PyThreadState_Prealloc(PyInterpreterState *interp)
1327 : : {
1328 : 0 : return _PyThreadState_New(interp);
1329 : : }
1330 : :
1331 : : // We keep this around for (accidental) stable ABI compatibility.
1332 : : // Realistically, no extensions are using it.
1333 : : void
1334 : 0 : _PyThreadState_Init(PyThreadState *tstate)
1335 : : {
1336 : 0 : Py_FatalError("_PyThreadState_Init() is for internal use only");
1337 : : }
1338 : :
1339 : : void
1340 : 25 : PyThreadState_Clear(PyThreadState *tstate)
1341 : : {
1342 : : assert(tstate->_status.initialized && !tstate->_status.cleared);
1343 : : // XXX assert(!tstate->_status.bound || tstate->_status.unbound);
1344 : 25 : tstate->_status.finalizing = 1; // just in case
1345 : :
1346 : : /* XXX Conditions we need to enforce:
1347 : :
1348 : : * the GIL must be held by the current thread
1349 : : * current_fast_get()->interp must match tstate->interp
1350 : : * for the main interpreter, current_fast_get() must be the main thread
1351 : : */
1352 : :
1353 : 25 : int verbose = _PyInterpreterState_GetConfig(tstate->interp)->verbose;
1354 : :
1355 [ - + - - ]: 25 : if (verbose && tstate->cframe->current_frame != NULL) {
1356 : : /* bpo-20526: After the main thread calls
1357 : : _PyRuntimeState_SetFinalizing() in Py_FinalizeEx(), threads must
1358 : : exit when trying to take the GIL. If a thread exit in the middle of
1359 : : _PyEval_EvalFrameDefault(), tstate->frame is not reset to its
1360 : : previous value. It is more likely with daemon threads, but it can
1361 : : happen with regular threads if threading._shutdown() fails
1362 : : (ex: interrupted by CTRL+C). */
1363 : 0 : fprintf(stderr,
1364 : : "PyThreadState_Clear: warning: thread still has a frame\n");
1365 : : }
1366 : :
1367 : : /* At this point tstate shouldn't be used any more,
1368 : : neither to run Python code nor for other uses.
1369 : :
1370 : : This is tricky when current_fast_get() == tstate, in the same way
1371 : : as noted in interpreter_clear() above. The below finalizers
1372 : : can possibly run Python code or otherwise use the partially
1373 : : cleared thread state. For now we trust that isn't a problem
1374 : : in practice.
1375 : : */
1376 : : // XXX Deal with the possibility of problematic finalizers.
1377 : :
1378 : : /* Don't clear tstate->pyframe: it is a borrowed reference */
1379 : :
1380 [ + + ]: 25 : Py_CLEAR(tstate->dict);
1381 [ - + ]: 25 : Py_CLEAR(tstate->async_exc);
1382 : :
1383 [ - + ]: 25 : Py_CLEAR(tstate->current_exception);
1384 : :
1385 [ + - ]: 25 : Py_CLEAR(tstate->exc_state.exc_value);
1386 : :
1387 : : /* The stack of exception states should contain just this thread. */
1388 [ - + - - ]: 25 : if (verbose && tstate->exc_info != &tstate->exc_state) {
1389 : 0 : fprintf(stderr,
1390 : : "PyThreadState_Clear: warning: thread still has a generator\n");
1391 : : }
1392 : :
1393 : 25 : tstate->c_profilefunc = NULL;
1394 : 25 : tstate->c_tracefunc = NULL;
1395 [ - + ]: 25 : Py_CLEAR(tstate->c_profileobj);
1396 [ - + ]: 25 : Py_CLEAR(tstate->c_traceobj);
1397 : :
1398 [ - + ]: 25 : Py_CLEAR(tstate->async_gen_firstiter);
1399 [ - + ]: 25 : Py_CLEAR(tstate->async_gen_finalizer);
1400 : :
1401 [ + + ]: 25 : Py_CLEAR(tstate->context);
1402 : :
1403 [ + + ]: 25 : if (tstate->on_delete != NULL) {
1404 : 4 : tstate->on_delete(tstate->on_delete_data);
1405 : : }
1406 : :
1407 : 25 : tstate->_status.cleared = 1;
1408 : :
1409 : : // XXX Call _PyThreadStateSwap(runtime, NULL) here if "current".
1410 : : // XXX Do it as early in the function as possible.
1411 : 25 : }
1412 : :
1413 : :
1414 : : /* Common code for PyThreadState_Delete() and PyThreadState_DeleteCurrent() */
1415 : : static void
1416 : 25 : tstate_delete_common(PyThreadState *tstate)
1417 : : {
1418 : : assert(tstate->_status.cleared && !tstate->_status.finalized);
1419 : :
1420 : 25 : PyInterpreterState *interp = tstate->interp;
1421 [ - + ]: 25 : if (interp == NULL) {
1422 : 0 : Py_FatalError("NULL interpreter");
1423 : : }
1424 : 25 : _PyRuntimeState *runtime = interp->runtime;
1425 : :
1426 : 25 : HEAD_LOCK(runtime);
1427 [ - + ]: 25 : if (tstate->prev) {
1428 : 0 : tstate->prev->next = tstate->next;
1429 : : }
1430 : : else {
1431 : 25 : interp->threads.head = tstate->next;
1432 : : }
1433 [ - + ]: 25 : if (tstate->next) {
1434 : 0 : tstate->next->prev = tstate->prev;
1435 : : }
1436 : 25 : HEAD_UNLOCK(runtime);
1437 : :
1438 : : // XXX Unbind in PyThreadState_Clear(), or earlier
1439 : : // (and assert not-equal here)?
1440 [ + - ]: 25 : if (tstate->_status.bound_gilstate) {
1441 : 25 : unbind_gilstate_tstate(tstate);
1442 : : }
1443 : 25 : unbind_tstate(tstate);
1444 : :
1445 : : // XXX Move to PyThreadState_Clear()?
1446 : 25 : _PyStackChunk *chunk = tstate->datastack_chunk;
1447 : 25 : tstate->datastack_chunk = NULL;
1448 [ + + ]: 50 : while (chunk != NULL) {
1449 : 25 : _PyStackChunk *prev = chunk->previous;
1450 : 25 : _PyObject_VirtualFree(chunk, chunk->size);
1451 : 25 : chunk = prev;
1452 : : }
1453 : :
1454 : 25 : tstate->_status.finalized = 1;
1455 : 25 : }
1456 : :
1457 : :
1458 : : static void
1459 : 25 : zapthreads(PyInterpreterState *interp)
1460 : : {
1461 : : PyThreadState *tstate;
1462 : : /* No need to lock the mutex here because this should only happen
1463 : : when the threads are all really dead (XXX famous last words). */
1464 [ + + ]: 50 : while ((tstate = interp->threads.head) != NULL) {
1465 [ - + ]: 25 : tstate_verify_not_active(tstate);
1466 : 25 : tstate_delete_common(tstate);
1467 : 25 : free_threadstate(tstate);
1468 : : }
1469 : 25 : }
1470 : :
1471 : :
1472 : : void
1473 : 0 : PyThreadState_Delete(PyThreadState *tstate)
1474 : : {
1475 : 0 : _Py_EnsureTstateNotNULL(tstate);
1476 [ # # ]: 0 : tstate_verify_not_active(tstate);
1477 : 0 : tstate_delete_common(tstate);
1478 : 0 : free_threadstate(tstate);
1479 : 0 : }
1480 : :
1481 : :
1482 : : void
1483 : 0 : _PyThreadState_DeleteCurrent(PyThreadState *tstate)
1484 : : {
1485 : 0 : _Py_EnsureTstateNotNULL(tstate);
1486 : 0 : tstate_delete_common(tstate);
1487 : 0 : current_fast_clear(tstate->interp->runtime);
1488 : 0 : _PyEval_ReleaseLock(tstate);
1489 : 0 : free_threadstate(tstate);
1490 : 0 : }
1491 : :
1492 : : void
1493 : 0 : PyThreadState_DeleteCurrent(void)
1494 : : {
1495 : 0 : PyThreadState *tstate = current_fast_get(&_PyRuntime);
1496 : 0 : _PyThreadState_DeleteCurrent(tstate);
1497 : 0 : }
1498 : :
1499 : :
1500 : : /*
1501 : : * Delete all thread states except the one passed as argument.
1502 : : * Note that, if there is a current thread state, it *must* be the one
1503 : : * passed as argument. Also, this won't touch any other interpreters
1504 : : * than the current one, since we don't know which thread state should
1505 : : * be kept in those other interpreters.
1506 : : */
1507 : : void
1508 : 25 : _PyThreadState_DeleteExcept(PyThreadState *tstate)
1509 : : {
1510 : : assert(tstate != NULL);
1511 : 25 : PyInterpreterState *interp = tstate->interp;
1512 : 25 : _PyRuntimeState *runtime = interp->runtime;
1513 : :
1514 : 25 : HEAD_LOCK(runtime);
1515 : : /* Remove all thread states, except tstate, from the linked list of
1516 : : thread states. This will allow calling PyThreadState_Clear()
1517 : : without holding the lock. */
1518 : 25 : PyThreadState *list = interp->threads.head;
1519 [ + - ]: 25 : if (list == tstate) {
1520 : 25 : list = tstate->next;
1521 : : }
1522 [ - + ]: 25 : if (tstate->prev) {
1523 : 0 : tstate->prev->next = tstate->next;
1524 : : }
1525 [ - + ]: 25 : if (tstate->next) {
1526 : 0 : tstate->next->prev = tstate->prev;
1527 : : }
1528 : 25 : tstate->prev = tstate->next = NULL;
1529 : 25 : interp->threads.head = tstate;
1530 : 25 : HEAD_UNLOCK(runtime);
1531 : :
1532 : : /* Clear and deallocate all stale thread states. Even if this
1533 : : executes Python code, we should be safe since it executes
1534 : : in the current thread, not one of the stale threads. */
1535 : : PyThreadState *p, *next;
1536 [ - + ]: 25 : for (p = list; p; p = next) {
1537 : 0 : next = p->next;
1538 : 0 : PyThreadState_Clear(p);
1539 : 0 : free_threadstate(p);
1540 : : }
1541 : 25 : }
1542 : :
1543 : :
1544 : : //----------
1545 : : // accessors
1546 : : //----------
1547 : :
1548 : : /* An extension mechanism to store arbitrary additional per-thread state.
1549 : : PyThreadState_GetDict() returns a dictionary that can be used to hold such
1550 : : state; the caller should pick a unique key and store its state there. If
1551 : : PyThreadState_GetDict() returns NULL, an exception has *not* been raised
1552 : : and the caller should assume no per-thread state is available. */
1553 : :
1554 : : PyObject *
1555 : 30209 : _PyThreadState_GetDict(PyThreadState *tstate)
1556 : : {
1557 : : assert(tstate != NULL);
1558 [ + + ]: 30209 : if (tstate->dict == NULL) {
1559 : 3 : tstate->dict = PyDict_New();
1560 [ - + ]: 3 : if (tstate->dict == NULL) {
1561 : 0 : _PyErr_Clear(tstate);
1562 : : }
1563 : : }
1564 : 30209 : return tstate->dict;
1565 : : }
1566 : :
1567 : :
1568 : : PyObject *
1569 : 30209 : PyThreadState_GetDict(void)
1570 : : {
1571 : 30209 : PyThreadState *tstate = current_fast_get(&_PyRuntime);
1572 [ - + ]: 30209 : if (tstate == NULL) {
1573 : 0 : return NULL;
1574 : : }
1575 : 30209 : return _PyThreadState_GetDict(tstate);
1576 : : }
1577 : :
1578 : :
1579 : : PyInterpreterState *
1580 : 4 : PyThreadState_GetInterpreter(PyThreadState *tstate)
1581 : : {
1582 : : assert(tstate != NULL);
1583 : 4 : return tstate->interp;
1584 : : }
1585 : :
1586 : :
1587 : : PyFrameObject*
1588 : 4 : PyThreadState_GetFrame(PyThreadState *tstate)
1589 : : {
1590 : : assert(tstate != NULL);
1591 : 4 : _PyInterpreterFrame *f = _PyThreadState_GetFrame(tstate);
1592 [ - + ]: 4 : if (f == NULL) {
1593 : 0 : return NULL;
1594 : : }
1595 : 4 : PyFrameObject *frame = _PyFrame_GetFrameObject(f);
1596 [ - + ]: 4 : if (frame == NULL) {
1597 : 0 : PyErr_Clear();
1598 : : }
1599 : 4 : return (PyFrameObject*)Py_XNewRef(frame);
1600 : : }
1601 : :
1602 : :
1603 : : uint64_t
1604 : 0 : PyThreadState_GetID(PyThreadState *tstate)
1605 : : {
1606 : : assert(tstate != NULL);
1607 : 0 : return tstate->id;
1608 : : }
1609 : :
1610 : :
1611 : : static inline void
1612 : 30180 : tstate_activate(PyThreadState *tstate)
1613 : : {
1614 : : assert(tstate != NULL);
1615 : : // XXX assert(tstate_is_alive(tstate));
1616 : : assert(tstate_is_bound(tstate));
1617 : : assert(!tstate->_status.active);
1618 : :
1619 : : assert(!tstate->_status.bound_gilstate ||
1620 : : tstate == gilstate_tss_get((tstate->interp->runtime)));
1621 [ - + ]: 30180 : if (!tstate->_status.bound_gilstate) {
1622 : 0 : bind_gilstate_tstate(tstate);
1623 : : }
1624 : :
1625 : 30180 : tstate->_status.active = 1;
1626 : 30180 : }
1627 : :
1628 : : static inline void
1629 : 30176 : tstate_deactivate(PyThreadState *tstate)
1630 : : {
1631 : : assert(tstate != NULL);
1632 : : // XXX assert(tstate_is_alive(tstate));
1633 : : assert(tstate_is_bound(tstate));
1634 : : assert(tstate->_status.active);
1635 : :
1636 : 30176 : tstate->_status.active = 0;
1637 : :
1638 : : // We do not unbind the gilstate tstate here.
1639 : : // It will still be used in PyGILState_Ensure().
1640 : 30176 : }
1641 : :
1642 : :
1643 : : //----------
1644 : : // other API
1645 : : //----------
1646 : :
1647 : : /* Asynchronously raise an exception in a thread.
1648 : : Requested by Just van Rossum and Alex Martelli.
1649 : : To prevent naive misuse, you must write your own extension
1650 : : to call this, or use ctypes. Must be called with the GIL held.
1651 : : Returns the number of tstates modified (normally 1, but 0 if `id` didn't
1652 : : match any known thread id). Can be called with exc=NULL to clear an
1653 : : existing async exception. This raises no exceptions. */
1654 : :
1655 : : // XXX Move this to Python/ceval_gil.c?
1656 : : // XXX Deprecate this.
1657 : : int
1658 : 0 : PyThreadState_SetAsyncExc(unsigned long id, PyObject *exc)
1659 : : {
1660 : 0 : _PyRuntimeState *runtime = &_PyRuntime;
1661 : 0 : PyInterpreterState *interp = _PyRuntimeState_GetThreadState(runtime)->interp;
1662 : :
1663 : : /* Although the GIL is held, a few C API functions can be called
1664 : : * without the GIL held, and in particular some that create and
1665 : : * destroy thread and interpreter states. Those can mutate the
1666 : : * list of thread states we're traversing, so to prevent that we lock
1667 : : * head_mutex for the duration.
1668 : : */
1669 : 0 : HEAD_LOCK(runtime);
1670 [ # # ]: 0 : for (PyThreadState *tstate = interp->threads.head; tstate != NULL; tstate = tstate->next) {
1671 [ # # ]: 0 : if (tstate->thread_id != id) {
1672 : 0 : continue;
1673 : : }
1674 : :
1675 : : /* Tricky: we need to decref the current value
1676 : : * (if any) in tstate->async_exc, but that can in turn
1677 : : * allow arbitrary Python code to run, including
1678 : : * perhaps calls to this function. To prevent
1679 : : * deadlock, we need to release head_mutex before
1680 : : * the decref.
1681 : : */
1682 : 0 : PyObject *old_exc = tstate->async_exc;
1683 : 0 : tstate->async_exc = Py_XNewRef(exc);
1684 : 0 : HEAD_UNLOCK(runtime);
1685 : :
1686 : 0 : Py_XDECREF(old_exc);
1687 : 0 : _PyEval_SignalAsyncExc(tstate->interp);
1688 : 0 : return 1;
1689 : : }
1690 : 0 : HEAD_UNLOCK(runtime);
1691 : 0 : return 0;
1692 : : }
1693 : :
1694 : :
1695 : : //---------------------------------
1696 : : // API for the current thread state
1697 : : //---------------------------------
1698 : :
1699 : : PyThreadState *
1700 : 7255519 : _PyThreadState_UncheckedGet(void)
1701 : : {
1702 : 7255519 : return current_fast_get(&_PyRuntime);
1703 : : }
1704 : :
1705 : :
1706 : : PyThreadState *
1707 : 0 : PyThreadState_Get(void)
1708 : : {
1709 : 0 : PyThreadState *tstate = current_fast_get(&_PyRuntime);
1710 : 0 : _Py_EnsureTstateNotNULL(tstate);
1711 : 0 : return tstate;
1712 : : }
1713 : :
1714 : :
1715 : : PyThreadState *
1716 : 60356 : _PyThreadState_Swap(_PyRuntimeState *runtime, PyThreadState *newts)
1717 : : {
1718 : : #if defined(Py_DEBUG)
1719 : : /* This can be called from PyEval_RestoreThread(). Similar
1720 : : to it, we need to ensure errno doesn't change.
1721 : : */
1722 : : int err = errno;
1723 : : #endif
1724 : 60356 : PyThreadState *oldts = current_fast_get(runtime);
1725 : :
1726 : 60356 : current_fast_clear(runtime);
1727 : :
1728 [ + + ]: 60356 : if (oldts != NULL) {
1729 : : // XXX assert(tstate_is_alive(oldts) && tstate_is_bound(oldts));
1730 : 30176 : tstate_deactivate(oldts);
1731 : : }
1732 : :
1733 [ + + ]: 60356 : if (newts != NULL) {
1734 : : // XXX assert(tstate_is_alive(newts));
1735 : : assert(tstate_is_bound(newts));
1736 : 30180 : current_fast_set(runtime, newts);
1737 : 30180 : tstate_activate(newts);
1738 : : }
1739 : :
1740 : : #if defined(Py_DEBUG)
1741 : : errno = err;
1742 : : #endif
1743 : 60356 : return oldts;
1744 : : }
1745 : :
1746 : : PyThreadState *
1747 : 29 : PyThreadState_Swap(PyThreadState *newts)
1748 : : {
1749 : 29 : return _PyThreadState_Swap(&_PyRuntime, newts);
1750 : : }
1751 : :
1752 : :
1753 : : void
1754 : 29 : _PyThreadState_Bind(PyThreadState *tstate)
1755 : : {
1756 : 29 : bind_tstate(tstate);
1757 : : // This makes sure there's a gilstate tstate bound
1758 : : // as soon as possible.
1759 [ + - ]: 29 : if (gilstate_tss_get(tstate->interp->runtime) == NULL) {
1760 : 29 : bind_gilstate_tstate(tstate);
1761 : : }
1762 : 29 : }
1763 : :
1764 : :
1765 : : /***********************************/
1766 : : /* routines for advanced debuggers */
1767 : : /***********************************/
1768 : :
1769 : : // (requested by David Beazley)
1770 : : // Don't use unless you know what you are doing!
1771 : :
1772 : : PyInterpreterState *
1773 : 0 : PyInterpreterState_Head(void)
1774 : : {
1775 : 0 : return _PyRuntime.interpreters.head;
1776 : : }
1777 : :
1778 : : PyInterpreterState *
1779 : 0 : PyInterpreterState_Main(void)
1780 : : {
1781 : 0 : return _PyInterpreterState_Main();
1782 : : }
1783 : :
1784 : : PyInterpreterState *
1785 : 0 : PyInterpreterState_Next(PyInterpreterState *interp) {
1786 : 0 : return interp->next;
1787 : : }
1788 : :
1789 : : PyThreadState *
1790 : 1 : PyInterpreterState_ThreadHead(PyInterpreterState *interp) {
1791 : 1 : return interp->threads.head;
1792 : : }
1793 : :
1794 : : PyThreadState *
1795 : 1 : PyThreadState_Next(PyThreadState *tstate) {
1796 : 1 : return tstate->next;
1797 : : }
1798 : :
1799 : :
1800 : : /********************************************/
1801 : : /* reporting execution state of all threads */
1802 : : /********************************************/
1803 : :
1804 : : /* The implementation of sys._current_frames(). This is intended to be
1805 : : called with the GIL held, as it will be when called via
1806 : : sys._current_frames(). It's possible it would work fine even without
1807 : : the GIL held, but haven't thought enough about that.
1808 : : */
1809 : : PyObject *
1810 : 0 : _PyThread_CurrentFrames(void)
1811 : : {
1812 : 0 : _PyRuntimeState *runtime = &_PyRuntime;
1813 : 0 : PyThreadState *tstate = current_fast_get(runtime);
1814 [ # # ]: 0 : if (_PySys_Audit(tstate, "sys._current_frames", NULL) < 0) {
1815 : 0 : return NULL;
1816 : : }
1817 : :
1818 : 0 : PyObject *result = PyDict_New();
1819 [ # # ]: 0 : if (result == NULL) {
1820 : 0 : return NULL;
1821 : : }
1822 : :
1823 : : /* for i in all interpreters:
1824 : : * for t in all of i's thread states:
1825 : : * if t's frame isn't NULL, map t's id to its frame
1826 : : * Because these lists can mutate even when the GIL is held, we
1827 : : * need to grab head_mutex for the duration.
1828 : : */
1829 : 0 : HEAD_LOCK(runtime);
1830 : : PyInterpreterState *i;
1831 [ # # ]: 0 : for (i = runtime->interpreters.head; i != NULL; i = i->next) {
1832 : : PyThreadState *t;
1833 [ # # ]: 0 : for (t = i->threads.head; t != NULL; t = t->next) {
1834 : 0 : _PyInterpreterFrame *frame = t->cframe->current_frame;
1835 : 0 : frame = _PyFrame_GetFirstComplete(frame);
1836 [ # # ]: 0 : if (frame == NULL) {
1837 : 0 : continue;
1838 : : }
1839 : 0 : PyObject *id = PyLong_FromUnsignedLong(t->thread_id);
1840 [ # # ]: 0 : if (id == NULL) {
1841 : 0 : goto fail;
1842 : : }
1843 : 0 : PyObject *frameobj = (PyObject *)_PyFrame_GetFrameObject(frame);
1844 [ # # ]: 0 : if (frameobj == NULL) {
1845 : 0 : Py_DECREF(id);
1846 : 0 : goto fail;
1847 : : }
1848 : 0 : int stat = PyDict_SetItem(result, id, frameobj);
1849 : 0 : Py_DECREF(id);
1850 [ # # ]: 0 : if (stat < 0) {
1851 : 0 : goto fail;
1852 : : }
1853 : : }
1854 : : }
1855 : 0 : goto done;
1856 : :
1857 : 0 : fail:
1858 [ # # ]: 0 : Py_CLEAR(result);
1859 : :
1860 : 0 : done:
1861 : 0 : HEAD_UNLOCK(runtime);
1862 : 0 : return result;
1863 : : }
1864 : :
1865 : : /* The implementation of sys._current_exceptions(). This is intended to be
1866 : : called with the GIL held, as it will be when called via
1867 : : sys._current_exceptions(). It's possible it would work fine even without
1868 : : the GIL held, but haven't thought enough about that.
1869 : : */
1870 : : PyObject *
1871 : 0 : _PyThread_CurrentExceptions(void)
1872 : : {
1873 : 0 : _PyRuntimeState *runtime = &_PyRuntime;
1874 : 0 : PyThreadState *tstate = current_fast_get(runtime);
1875 : :
1876 : 0 : _Py_EnsureTstateNotNULL(tstate);
1877 : :
1878 [ # # ]: 0 : if (_PySys_Audit(tstate, "sys._current_exceptions", NULL) < 0) {
1879 : 0 : return NULL;
1880 : : }
1881 : :
1882 : 0 : PyObject *result = PyDict_New();
1883 [ # # ]: 0 : if (result == NULL) {
1884 : 0 : return NULL;
1885 : : }
1886 : :
1887 : : /* for i in all interpreters:
1888 : : * for t in all of i's thread states:
1889 : : * if t's frame isn't NULL, map t's id to its frame
1890 : : * Because these lists can mutate even when the GIL is held, we
1891 : : * need to grab head_mutex for the duration.
1892 : : */
1893 : 0 : HEAD_LOCK(runtime);
1894 : : PyInterpreterState *i;
1895 [ # # ]: 0 : for (i = runtime->interpreters.head; i != NULL; i = i->next) {
1896 : : PyThreadState *t;
1897 [ # # ]: 0 : for (t = i->threads.head; t != NULL; t = t->next) {
1898 : 0 : _PyErr_StackItem *err_info = _PyErr_GetTopmostException(t);
1899 [ # # ]: 0 : if (err_info == NULL) {
1900 : 0 : continue;
1901 : : }
1902 : 0 : PyObject *id = PyLong_FromUnsignedLong(t->thread_id);
1903 [ # # ]: 0 : if (id == NULL) {
1904 : 0 : goto fail;
1905 : : }
1906 : 0 : PyObject *exc_info = _PyErr_StackItemToExcInfoTuple(err_info);
1907 [ # # ]: 0 : if (exc_info == NULL) {
1908 : 0 : Py_DECREF(id);
1909 : 0 : goto fail;
1910 : : }
1911 : 0 : int stat = PyDict_SetItem(result, id, exc_info);
1912 : 0 : Py_DECREF(id);
1913 : 0 : Py_DECREF(exc_info);
1914 [ # # ]: 0 : if (stat < 0) {
1915 : 0 : goto fail;
1916 : : }
1917 : : }
1918 : : }
1919 : 0 : goto done;
1920 : :
1921 : 0 : fail:
1922 [ # # ]: 0 : Py_CLEAR(result);
1923 : :
1924 : 0 : done:
1925 : 0 : HEAD_UNLOCK(runtime);
1926 : 0 : return result;
1927 : : }
1928 : :
1929 : :
1930 : : /***********************************/
1931 : : /* Python "auto thread state" API. */
1932 : : /***********************************/
1933 : :
1934 : : /* Internal initialization/finalization functions called by
1935 : : Py_Initialize/Py_FinalizeEx
1936 : : */
1937 : : PyStatus
1938 : 29 : _PyGILState_Init(PyInterpreterState *interp)
1939 : : {
1940 [ - + ]: 29 : if (!_Py_IsMainInterpreter(interp)) {
1941 : : /* Currently, PyGILState is shared by all interpreters. The main
1942 : : * interpreter is responsible to initialize it. */
1943 : 0 : return _PyStatus_OK();
1944 : : }
1945 : 29 : _PyRuntimeState *runtime = interp->runtime;
1946 : : assert(gilstate_tss_get(runtime) == NULL);
1947 : : assert(runtime->gilstate.autoInterpreterState == NULL);
1948 : 29 : runtime->gilstate.autoInterpreterState = interp;
1949 : 29 : return _PyStatus_OK();
1950 : : }
1951 : :
1952 : : void
1953 : 25 : _PyGILState_Fini(PyInterpreterState *interp)
1954 : : {
1955 [ - + ]: 25 : if (!_Py_IsMainInterpreter(interp)) {
1956 : : /* Currently, PyGILState is shared by all interpreters. The main
1957 : : * interpreter is responsible to initialize it. */
1958 : 0 : return;
1959 : : }
1960 : 25 : interp->runtime->gilstate.autoInterpreterState = NULL;
1961 : : }
1962 : :
1963 : :
1964 : : // XXX Drop this.
1965 : : PyStatus
1966 : 29 : _PyGILState_SetTstate(PyThreadState *tstate)
1967 : : {
1968 : : /* must init with valid states */
1969 : : assert(tstate != NULL);
1970 : : assert(tstate->interp != NULL);
1971 : :
1972 [ - + ]: 29 : if (!_Py_IsMainInterpreter(tstate->interp)) {
1973 : : /* Currently, PyGILState is shared by all interpreters. The main
1974 : : * interpreter is responsible to initialize it. */
1975 : 0 : return _PyStatus_OK();
1976 : : }
1977 : :
1978 : : #ifndef NDEBUG
1979 : : _PyRuntimeState *runtime = tstate->interp->runtime;
1980 : :
1981 : : assert(runtime->gilstate.autoInterpreterState == tstate->interp);
1982 : : assert(gilstate_tss_get(runtime) == tstate);
1983 : : assert(tstate->gilstate_counter == 1);
1984 : : #endif
1985 : :
1986 : 29 : return _PyStatus_OK();
1987 : : }
1988 : :
1989 : : PyInterpreterState *
1990 : 0 : _PyGILState_GetInterpreterStateUnsafe(void)
1991 : : {
1992 : 0 : return _PyRuntime.gilstate.autoInterpreterState;
1993 : : }
1994 : :
1995 : : /* The public functions */
1996 : :
1997 : : PyThreadState *
1998 : 0 : PyGILState_GetThisThreadState(void)
1999 : : {
2000 : 0 : _PyRuntimeState *runtime = &_PyRuntime;
2001 [ # # ]: 0 : if (!gilstate_tss_initialized(runtime)) {
2002 : 0 : return NULL;
2003 : : }
2004 : 0 : return gilstate_tss_get(runtime);
2005 : : }
2006 : :
2007 : : int
2008 : 0 : PyGILState_Check(void)
2009 : : {
2010 : 0 : _PyRuntimeState *runtime = &_PyRuntime;
2011 [ # # ]: 0 : if (!runtime->gilstate.check_enabled) {
2012 : 0 : return 1;
2013 : : }
2014 : :
2015 [ # # ]: 0 : if (!gilstate_tss_initialized(runtime)) {
2016 : 0 : return 1;
2017 : : }
2018 : :
2019 : 0 : PyThreadState *tstate = current_fast_get(runtime);
2020 [ # # ]: 0 : if (tstate == NULL) {
2021 : 0 : return 0;
2022 : : }
2023 : :
2024 : 0 : return (tstate == gilstate_tss_get(runtime));
2025 : : }
2026 : :
2027 : : PyGILState_STATE
2028 : 0 : PyGILState_Ensure(void)
2029 : : {
2030 : 0 : _PyRuntimeState *runtime = &_PyRuntime;
2031 : :
2032 : : /* Note that we do not auto-init Python here - apart from
2033 : : potential races with 2 threads auto-initializing, pep-311
2034 : : spells out other issues. Embedders are expected to have
2035 : : called Py_Initialize(). */
2036 : :
2037 : : /* Ensure that _PyEval_InitThreads() and _PyGILState_Init() have been
2038 : : called by Py_Initialize() */
2039 : : assert(_PyEval_ThreadsInitialized(runtime));
2040 : : assert(gilstate_tss_initialized(runtime));
2041 : : assert(runtime->gilstate.autoInterpreterState != NULL);
2042 : :
2043 : 0 : PyThreadState *tcur = gilstate_tss_get(runtime);
2044 : : int has_gil;
2045 [ # # ]: 0 : if (tcur == NULL) {
2046 : : /* Create a new Python thread state for this thread */
2047 : 0 : tcur = new_threadstate(runtime->gilstate.autoInterpreterState);
2048 [ # # ]: 0 : if (tcur == NULL) {
2049 : 0 : Py_FatalError("Couldn't create thread-state for new thread");
2050 : : }
2051 : 0 : bind_tstate(tcur);
2052 : 0 : bind_gilstate_tstate(tcur);
2053 : :
2054 : : /* This is our thread state! We'll need to delete it in the
2055 : : matching call to PyGILState_Release(). */
2056 : : assert(tcur->gilstate_counter == 1);
2057 : 0 : tcur->gilstate_counter = 0;
2058 : 0 : has_gil = 0; /* new thread state is never current */
2059 : : }
2060 : : else {
2061 : 0 : has_gil = holds_gil(tcur);
2062 : : }
2063 : :
2064 [ # # ]: 0 : if (!has_gil) {
2065 : 0 : PyEval_RestoreThread(tcur);
2066 : : }
2067 : :
2068 : : /* Update our counter in the thread-state - no need for locks:
2069 : : - tcur will remain valid as we hold the GIL.
2070 : : - the counter is safe as we are the only thread "allowed"
2071 : : to modify this value
2072 : : */
2073 : 0 : ++tcur->gilstate_counter;
2074 : :
2075 : 0 : return has_gil ? PyGILState_LOCKED : PyGILState_UNLOCKED;
2076 : : }
2077 : :
2078 : : void
2079 : 0 : PyGILState_Release(PyGILState_STATE oldstate)
2080 : : {
2081 : 0 : _PyRuntimeState *runtime = &_PyRuntime;
2082 : 0 : PyThreadState *tstate = gilstate_tss_get(runtime);
2083 [ # # ]: 0 : if (tstate == NULL) {
2084 : 0 : Py_FatalError("auto-releasing thread-state, "
2085 : : "but no thread-state for this thread");
2086 : : }
2087 : :
2088 : : /* We must hold the GIL and have our thread state current */
2089 : : /* XXX - remove the check - the assert should be fine,
2090 : : but while this is very new (April 2003), the extra check
2091 : : by release-only users can't hurt.
2092 : : */
2093 [ # # ]: 0 : if (!holds_gil(tstate)) {
2094 : 0 : _Py_FatalErrorFormat(__func__,
2095 : : "thread state %p must be current when releasing",
2096 : : tstate);
2097 : : }
2098 : : assert(holds_gil(tstate));
2099 : 0 : --tstate->gilstate_counter;
2100 : : assert(tstate->gilstate_counter >= 0); /* illegal counter value */
2101 : :
2102 : : /* If we're going to destroy this thread-state, we must
2103 : : * clear it while the GIL is held, as destructors may run.
2104 : : */
2105 [ # # ]: 0 : if (tstate->gilstate_counter == 0) {
2106 : : /* can't have been locked when we created it */
2107 : : assert(oldstate == PyGILState_UNLOCKED);
2108 : : // XXX Unbind tstate here.
2109 : 0 : PyThreadState_Clear(tstate);
2110 : : /* Delete the thread-state. Note this releases the GIL too!
2111 : : * It's vital that the GIL be held here, to avoid shutdown
2112 : : * races; see bugs 225673 and 1061968 (that nasty bug has a
2113 : : * habit of coming back).
2114 : : */
2115 : : assert(current_fast_get(runtime) == tstate);
2116 : 0 : _PyThreadState_DeleteCurrent(tstate);
2117 : : }
2118 : : /* Release the lock if necessary */
2119 [ # # ]: 0 : else if (oldstate == PyGILState_UNLOCKED) {
2120 : 0 : PyEval_SaveThread();
2121 : : }
2122 : 0 : }
2123 : :
2124 : :
2125 : : /**************************/
2126 : : /* cross-interpreter data */
2127 : : /**************************/
2128 : :
2129 : : /* cross-interpreter data */
2130 : :
2131 : : static inline void
2132 : 0 : _xidata_init(_PyCrossInterpreterData *data)
2133 : : {
2134 : : // If the value is being reused
2135 : : // then _xidata_clear() should have been called already.
2136 : : assert(data->data == NULL);
2137 : : assert(data->obj == NULL);
2138 : 0 : *data = (_PyCrossInterpreterData){0};
2139 : 0 : data->interp = -1;
2140 : 0 : }
2141 : :
2142 : : static inline void
2143 : 0 : _xidata_clear(_PyCrossInterpreterData *data)
2144 : : {
2145 [ # # ]: 0 : if (data->free != NULL) {
2146 : 0 : data->free(data->data);
2147 : : }
2148 : 0 : data->data = NULL;
2149 [ # # ]: 0 : Py_CLEAR(data->obj);
2150 : 0 : }
2151 : :
2152 : : void
2153 : 0 : _PyCrossInterpreterData_Init(_PyCrossInterpreterData *data,
2154 : : PyInterpreterState *interp,
2155 : : void *shared, PyObject *obj,
2156 : : xid_newobjectfunc new_object)
2157 : : {
2158 : : assert(data != NULL);
2159 : : assert(new_object != NULL);
2160 : 0 : _xidata_init(data);
2161 : 0 : data->data = shared;
2162 [ # # ]: 0 : if (obj != NULL) {
2163 : : assert(interp != NULL);
2164 : : // released in _PyCrossInterpreterData_Clear()
2165 : 0 : data->obj = Py_NewRef(obj);
2166 : : }
2167 : : // Ideally every object would know its owning interpreter.
2168 : : // Until then, we have to rely on the caller to identify it
2169 : : // (but we don't need it in all cases).
2170 [ # # ]: 0 : data->interp = (interp != NULL) ? interp->id : -1;
2171 : 0 : data->new_object = new_object;
2172 : 0 : }
2173 : :
2174 : : int
2175 : 0 : _PyCrossInterpreterData_InitWithSize(_PyCrossInterpreterData *data,
2176 : : PyInterpreterState *interp,
2177 : : const size_t size, PyObject *obj,
2178 : : xid_newobjectfunc new_object)
2179 : : {
2180 : : assert(size > 0);
2181 : : // For now we always free the shared data in the same interpreter
2182 : : // where it was allocated, so the interpreter is required.
2183 : : assert(interp != NULL);
2184 : 0 : _PyCrossInterpreterData_Init(data, interp, NULL, obj, new_object);
2185 : 0 : data->data = PyMem_Malloc(size);
2186 [ # # ]: 0 : if (data->data == NULL) {
2187 : 0 : return -1;
2188 : : }
2189 : 0 : data->free = PyMem_Free;
2190 : 0 : return 0;
2191 : : }
2192 : :
2193 : : void
2194 : 0 : _PyCrossInterpreterData_Clear(PyInterpreterState *interp,
2195 : : _PyCrossInterpreterData *data)
2196 : : {
2197 : : assert(data != NULL);
2198 : : // This must be called in the owning interpreter.
2199 : : assert(interp == NULL || data->interp == interp->id);
2200 : 0 : _xidata_clear(data);
2201 : 0 : }
2202 : :
2203 : : static int
2204 : 0 : _check_xidata(PyThreadState *tstate, _PyCrossInterpreterData *data)
2205 : : {
2206 : : // data->data can be anything, including NULL, so we don't check it.
2207 : :
2208 : : // data->obj may be NULL, so we don't check it.
2209 : :
2210 [ # # ]: 0 : if (data->interp < 0) {
2211 : 0 : _PyErr_SetString(tstate, PyExc_SystemError, "missing interp");
2212 : 0 : return -1;
2213 : : }
2214 : :
2215 [ # # ]: 0 : if (data->new_object == NULL) {
2216 : 0 : _PyErr_SetString(tstate, PyExc_SystemError, "missing new_object func");
2217 : 0 : return -1;
2218 : : }
2219 : :
2220 : : // data->free may be NULL, so we don't check it.
2221 : :
2222 : 0 : return 0;
2223 : : }
2224 : :
2225 : : crossinterpdatafunc _PyCrossInterpreterData_Lookup(PyObject *);
2226 : :
2227 : : /* This is a separate func from _PyCrossInterpreterData_Lookup in order
2228 : : to keep the registry code separate. */
2229 : : static crossinterpdatafunc
2230 : 0 : _lookup_getdata(PyObject *obj)
2231 : : {
2232 : 0 : crossinterpdatafunc getdata = _PyCrossInterpreterData_Lookup(obj);
2233 [ # # # # ]: 0 : if (getdata == NULL && PyErr_Occurred() == 0)
2234 : 0 : PyErr_Format(PyExc_ValueError,
2235 : : "%S does not support cross-interpreter data", obj);
2236 : 0 : return getdata;
2237 : : }
2238 : :
2239 : : int
2240 : 0 : _PyObject_CheckCrossInterpreterData(PyObject *obj)
2241 : : {
2242 : 0 : crossinterpdatafunc getdata = _lookup_getdata(obj);
2243 [ # # ]: 0 : if (getdata == NULL) {
2244 : 0 : return -1;
2245 : : }
2246 : 0 : return 0;
2247 : : }
2248 : :
2249 : : int
2250 : 0 : _PyObject_GetCrossInterpreterData(PyObject *obj, _PyCrossInterpreterData *data)
2251 : : {
2252 : 0 : _PyRuntimeState *runtime = &_PyRuntime;
2253 : 0 : PyThreadState *tstate = current_fast_get(runtime);
2254 : : #ifdef Py_DEBUG
2255 : : // The caller must hold the GIL
2256 : : _Py_EnsureTstateNotNULL(tstate);
2257 : : #endif
2258 : 0 : PyInterpreterState *interp = tstate->interp;
2259 : :
2260 : : // Reset data before re-populating.
2261 : 0 : *data = (_PyCrossInterpreterData){0};
2262 : 0 : data->interp = -1;
2263 : :
2264 : : // Call the "getdata" func for the object.
2265 : 0 : Py_INCREF(obj);
2266 : 0 : crossinterpdatafunc getdata = _lookup_getdata(obj);
2267 [ # # ]: 0 : if (getdata == NULL) {
2268 : 0 : Py_DECREF(obj);
2269 : 0 : return -1;
2270 : : }
2271 : 0 : int res = getdata(tstate, obj, data);
2272 : 0 : Py_DECREF(obj);
2273 [ # # ]: 0 : if (res != 0) {
2274 : 0 : return -1;
2275 : : }
2276 : :
2277 : : // Fill in the blanks and validate the result.
2278 : 0 : data->interp = interp->id;
2279 [ # # ]: 0 : if (_check_xidata(tstate, data) != 0) {
2280 : 0 : (void)_PyCrossInterpreterData_Release(data);
2281 : 0 : return -1;
2282 : : }
2283 : :
2284 : 0 : return 0;
2285 : : }
2286 : :
2287 : : PyObject *
2288 : 0 : _PyCrossInterpreterData_NewObject(_PyCrossInterpreterData *data)
2289 : : {
2290 : 0 : return data->new_object(data);
2291 : : }
2292 : :
2293 : : typedef void (*releasefunc)(PyInterpreterState *, void *);
2294 : :
2295 : : static void
2296 : 0 : _call_in_interpreter(PyInterpreterState *interp, releasefunc func, void *arg)
2297 : : {
2298 : : /* We would use Py_AddPendingCall() if it weren't specific to the
2299 : : * main interpreter (see bpo-33608). In the meantime we take a
2300 : : * naive approach.
2301 : : */
2302 : 0 : _PyRuntimeState *runtime = interp->runtime;
2303 : 0 : PyThreadState *save_tstate = NULL;
2304 [ # # ]: 0 : if (interp != current_fast_get(runtime)->interp) {
2305 : : // XXX Using the "head" thread isn't strictly correct.
2306 : 0 : PyThreadState *tstate = PyInterpreterState_ThreadHead(interp);
2307 : : // XXX Possible GILState issues?
2308 : 0 : save_tstate = _PyThreadState_Swap(runtime, tstate);
2309 : : }
2310 : :
2311 : : // XXX Once the GIL is per-interpreter, this should be called with the
2312 : : // calling interpreter's GIL released and the target interpreter's held.
2313 : 0 : func(interp, arg);
2314 : :
2315 : : // Switch back.
2316 [ # # ]: 0 : if (save_tstate != NULL) {
2317 : 0 : _PyThreadState_Swap(runtime, save_tstate);
2318 : : }
2319 : 0 : }
2320 : :
2321 : : int
2322 : 0 : _PyCrossInterpreterData_Release(_PyCrossInterpreterData *data)
2323 : : {
2324 [ # # # # ]: 0 : if (data->free == NULL && data->obj == NULL) {
2325 : : // Nothing to release!
2326 : 0 : data->data = NULL;
2327 : 0 : return 0;
2328 : : }
2329 : :
2330 : : // Switch to the original interpreter.
2331 : 0 : PyInterpreterState *interp = _PyInterpreterState_LookUpID(data->interp);
2332 [ # # ]: 0 : if (interp == NULL) {
2333 : : // The interpreter was already destroyed.
2334 : : // This function shouldn't have been called.
2335 : : // XXX Someone leaked some memory...
2336 : : assert(PyErr_Occurred());
2337 : 0 : return -1;
2338 : : }
2339 : :
2340 : : // "Release" the data and/or the object.
2341 : 0 : _call_in_interpreter(interp,
2342 : : (releasefunc)_PyCrossInterpreterData_Clear, data);
2343 : 0 : return 0;
2344 : : }
2345 : :
2346 : : /* registry of {type -> crossinterpdatafunc} */
2347 : :
2348 : : /* For now we use a global registry of shareable classes. An
2349 : : alternative would be to add a tp_* slot for a class's
2350 : : crossinterpdatafunc. It would be simpler and more efficient. */
2351 : :
2352 : : static int
2353 : 5 : _xidregistry_add_type(struct _xidregistry *xidregistry, PyTypeObject *cls,
2354 : : crossinterpdatafunc getdata)
2355 : : {
2356 : : // Note that we effectively replace already registered classes
2357 : : // rather than failing.
2358 : 5 : struct _xidregitem *newhead = PyMem_RawMalloc(sizeof(struct _xidregitem));
2359 [ - + ]: 5 : if (newhead == NULL) {
2360 : 0 : return -1;
2361 : : }
2362 : : // XXX Assign a callback to clear the entry from the registry?
2363 : 5 : newhead->cls = PyWeakref_NewRef((PyObject *)cls, NULL);
2364 [ - + ]: 5 : if (newhead->cls == NULL) {
2365 : 0 : PyMem_RawFree(newhead);
2366 : 0 : return -1;
2367 : : }
2368 : 5 : newhead->getdata = getdata;
2369 : 5 : newhead->prev = NULL;
2370 : 5 : newhead->next = xidregistry->head;
2371 [ + + ]: 5 : if (newhead->next != NULL) {
2372 : 4 : newhead->next->prev = newhead;
2373 : : }
2374 : 5 : xidregistry->head = newhead;
2375 : 5 : return 0;
2376 : : }
2377 : :
2378 : : static struct _xidregitem *
2379 : 1 : _xidregistry_remove_entry(struct _xidregistry *xidregistry,
2380 : : struct _xidregitem *entry)
2381 : : {
2382 : 1 : struct _xidregitem *next = entry->next;
2383 [ - + ]: 1 : if (entry->prev != NULL) {
2384 : : assert(entry->prev->next == entry);
2385 : 0 : entry->prev->next = next;
2386 : : }
2387 : : else {
2388 : : assert(xidregistry->head == entry);
2389 : 1 : xidregistry->head = next;
2390 : : }
2391 [ + - ]: 1 : if (next != NULL) {
2392 : 1 : next->prev = entry->prev;
2393 : : }
2394 : 1 : Py_DECREF(entry->cls);
2395 : 1 : PyMem_RawFree(entry);
2396 : 1 : return next;
2397 : : }
2398 : :
2399 : : static struct _xidregitem *
2400 : 1 : _xidregistry_find_type(struct _xidregistry *xidregistry, PyTypeObject *cls)
2401 : : {
2402 : 1 : struct _xidregitem *cur = xidregistry->head;
2403 [ + + ]: 6 : while (cur != NULL) {
2404 : 5 : PyObject *registered = PyWeakref_GetObject(cur->cls);
2405 [ + + ]: 5 : if (registered == Py_None) {
2406 : : // The weakly ref'ed object was freed.
2407 : 1 : cur = _xidregistry_remove_entry(xidregistry, cur);
2408 : : }
2409 : : else {
2410 : : assert(PyType_Check(registered));
2411 [ - + ]: 4 : if (registered == (PyObject *)cls) {
2412 : 0 : return cur;
2413 : : }
2414 : 4 : cur = cur->next;
2415 : : }
2416 : : }
2417 : 1 : return NULL;
2418 : : }
2419 : :
2420 : : static void _register_builtins_for_crossinterpreter_data(struct _xidregistry *xidregistry);
2421 : :
2422 : : int
2423 : 1 : _PyCrossInterpreterData_RegisterClass(PyTypeObject *cls,
2424 : : crossinterpdatafunc getdata)
2425 : : {
2426 [ - + ]: 1 : if (!PyType_Check(cls)) {
2427 : 0 : PyErr_Format(PyExc_ValueError, "only classes may be registered");
2428 : 0 : return -1;
2429 : : }
2430 [ - + ]: 1 : if (getdata == NULL) {
2431 : 0 : PyErr_Format(PyExc_ValueError, "missing 'getdata' func");
2432 : 0 : return -1;
2433 : : }
2434 : :
2435 : 1 : struct _xidregistry *xidregistry = &_PyRuntime.xidregistry ;
2436 : 1 : PyThread_acquire_lock(xidregistry->mutex, WAIT_LOCK);
2437 [ + - ]: 1 : if (xidregistry->head == NULL) {
2438 : 1 : _register_builtins_for_crossinterpreter_data(xidregistry);
2439 : : }
2440 : 1 : int res = _xidregistry_add_type(xidregistry, cls, getdata);
2441 : 1 : PyThread_release_lock(xidregistry->mutex);
2442 : 1 : return res;
2443 : : }
2444 : :
2445 : : int
2446 : 1 : _PyCrossInterpreterData_UnregisterClass(PyTypeObject *cls)
2447 : : {
2448 : 1 : int res = 0;
2449 : 1 : struct _xidregistry *xidregistry = &_PyRuntime.xidregistry ;
2450 : 1 : PyThread_acquire_lock(xidregistry->mutex, WAIT_LOCK);
2451 : 1 : struct _xidregitem *matched = _xidregistry_find_type(xidregistry, cls);
2452 [ - + ]: 1 : if (matched != NULL) {
2453 : 0 : (void)_xidregistry_remove_entry(xidregistry, matched);
2454 : 0 : res = 1;
2455 : : }
2456 : 1 : PyThread_release_lock(xidregistry->mutex);
2457 : 1 : return res;
2458 : : }
2459 : :
2460 : :
2461 : : /* Cross-interpreter objects are looked up by exact match on the class.
2462 : : We can reassess this policy when we move from a global registry to a
2463 : : tp_* slot. */
2464 : :
2465 : : crossinterpdatafunc
2466 : 0 : _PyCrossInterpreterData_Lookup(PyObject *obj)
2467 : : {
2468 : 0 : struct _xidregistry *xidregistry = &_PyRuntime.xidregistry ;
2469 : 0 : PyObject *cls = PyObject_Type(obj);
2470 : 0 : PyThread_acquire_lock(xidregistry->mutex, WAIT_LOCK);
2471 [ # # ]: 0 : if (xidregistry->head == NULL) {
2472 : 0 : _register_builtins_for_crossinterpreter_data(xidregistry);
2473 : : }
2474 : 0 : struct _xidregitem *matched = _xidregistry_find_type(xidregistry,
2475 : : (PyTypeObject *)cls);
2476 : 0 : Py_DECREF(cls);
2477 : 0 : PyThread_release_lock(xidregistry->mutex);
2478 [ # # ]: 0 : return matched != NULL ? matched->getdata : NULL;
2479 : : }
2480 : :
2481 : : /* cross-interpreter data for builtin types */
2482 : :
2483 : : struct _shared_bytes_data {
2484 : : char *bytes;
2485 : : Py_ssize_t len;
2486 : : };
2487 : :
2488 : : static PyObject *
2489 : 0 : _new_bytes_object(_PyCrossInterpreterData *data)
2490 : : {
2491 : 0 : struct _shared_bytes_data *shared = (struct _shared_bytes_data *)(data->data);
2492 : 0 : return PyBytes_FromStringAndSize(shared->bytes, shared->len);
2493 : : }
2494 : :
2495 : : static int
2496 : 0 : _bytes_shared(PyThreadState *tstate, PyObject *obj,
2497 : : _PyCrossInterpreterData *data)
2498 : : {
2499 [ # # ]: 0 : if (_PyCrossInterpreterData_InitWithSize(
2500 : : data, tstate->interp, sizeof(struct _shared_bytes_data), obj,
2501 : : _new_bytes_object
2502 : : ) < 0)
2503 : : {
2504 : 0 : return -1;
2505 : : }
2506 : 0 : struct _shared_bytes_data *shared = (struct _shared_bytes_data *)data->data;
2507 [ # # ]: 0 : if (PyBytes_AsStringAndSize(obj, &shared->bytes, &shared->len) < 0) {
2508 : 0 : _PyCrossInterpreterData_Clear(tstate->interp, data);
2509 : 0 : return -1;
2510 : : }
2511 : 0 : return 0;
2512 : : }
2513 : :
2514 : : struct _shared_str_data {
2515 : : int kind;
2516 : : const void *buffer;
2517 : : Py_ssize_t len;
2518 : : };
2519 : :
2520 : : static PyObject *
2521 : 0 : _new_str_object(_PyCrossInterpreterData *data)
2522 : : {
2523 : 0 : struct _shared_str_data *shared = (struct _shared_str_data *)(data->data);
2524 : 0 : return PyUnicode_FromKindAndData(shared->kind, shared->buffer, shared->len);
2525 : : }
2526 : :
2527 : : static int
2528 : 0 : _str_shared(PyThreadState *tstate, PyObject *obj,
2529 : : _PyCrossInterpreterData *data)
2530 : : {
2531 [ # # ]: 0 : if (_PyCrossInterpreterData_InitWithSize(
2532 : : data, tstate->interp, sizeof(struct _shared_str_data), obj,
2533 : : _new_str_object
2534 : : ) < 0)
2535 : : {
2536 : 0 : return -1;
2537 : : }
2538 : 0 : struct _shared_str_data *shared = (struct _shared_str_data *)data->data;
2539 : 0 : shared->kind = PyUnicode_KIND(obj);
2540 : 0 : shared->buffer = PyUnicode_DATA(obj);
2541 : 0 : shared->len = PyUnicode_GET_LENGTH(obj);
2542 : 0 : return 0;
2543 : : }
2544 : :
2545 : : static PyObject *
2546 : 0 : _new_long_object(_PyCrossInterpreterData *data)
2547 : : {
2548 : 0 : return PyLong_FromSsize_t((Py_ssize_t)(data->data));
2549 : : }
2550 : :
2551 : : static int
2552 : 0 : _long_shared(PyThreadState *tstate, PyObject *obj,
2553 : : _PyCrossInterpreterData *data)
2554 : : {
2555 : : /* Note that this means the size of shareable ints is bounded by
2556 : : * sys.maxsize. Hence on 32-bit architectures that is half the
2557 : : * size of maximum shareable ints on 64-bit.
2558 : : */
2559 : 0 : Py_ssize_t value = PyLong_AsSsize_t(obj);
2560 [ # # # # ]: 0 : if (value == -1 && PyErr_Occurred()) {
2561 [ # # ]: 0 : if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
2562 : 0 : PyErr_SetString(PyExc_OverflowError, "try sending as bytes");
2563 : : }
2564 : 0 : return -1;
2565 : : }
2566 : 0 : _PyCrossInterpreterData_Init(data, tstate->interp, (void *)value, NULL,
2567 : : _new_long_object);
2568 : : // data->obj and data->free remain NULL
2569 : 0 : return 0;
2570 : : }
2571 : :
2572 : : static PyObject *
2573 : 0 : _new_none_object(_PyCrossInterpreterData *data)
2574 : : {
2575 : : // XXX Singleton refcounts are problematic across interpreters...
2576 : 0 : return Py_NewRef(Py_None);
2577 : : }
2578 : :
2579 : : static int
2580 : 0 : _none_shared(PyThreadState *tstate, PyObject *obj,
2581 : : _PyCrossInterpreterData *data)
2582 : : {
2583 : 0 : _PyCrossInterpreterData_Init(data, tstate->interp, NULL, NULL,
2584 : : _new_none_object);
2585 : : // data->data, data->obj and data->free remain NULL
2586 : 0 : return 0;
2587 : : }
2588 : :
2589 : : static void
2590 : 1 : _register_builtins_for_crossinterpreter_data(struct _xidregistry *xidregistry)
2591 : : {
2592 : : // None
2593 [ - + ]: 1 : if (_xidregistry_add_type(xidregistry, (PyTypeObject *)PyObject_Type(Py_None), _none_shared) != 0) {
2594 : 0 : Py_FatalError("could not register None for cross-interpreter sharing");
2595 : : }
2596 : :
2597 : : // int
2598 [ - + ]: 1 : if (_xidregistry_add_type(xidregistry, &PyLong_Type, _long_shared) != 0) {
2599 : 0 : Py_FatalError("could not register int for cross-interpreter sharing");
2600 : : }
2601 : :
2602 : : // bytes
2603 [ - + ]: 1 : if (_xidregistry_add_type(xidregistry, &PyBytes_Type, _bytes_shared) != 0) {
2604 : 0 : Py_FatalError("could not register bytes for cross-interpreter sharing");
2605 : : }
2606 : :
2607 : : // str
2608 [ - + ]: 1 : if (_xidregistry_add_type(xidregistry, &PyUnicode_Type, _str_shared) != 0) {
2609 : 0 : Py_FatalError("could not register str for cross-interpreter sharing");
2610 : : }
2611 : 1 : }
2612 : :
2613 : :
2614 : : _PyFrameEvalFunction
2615 : 0 : _PyInterpreterState_GetEvalFrameFunc(PyInterpreterState *interp)
2616 : : {
2617 [ # # ]: 0 : if (interp->eval_frame == NULL) {
2618 : 0 : return _PyEval_EvalFrameDefault;
2619 : : }
2620 : 0 : return interp->eval_frame;
2621 : : }
2622 : :
2623 : :
2624 : : void
2625 : 0 : _PyInterpreterState_SetEvalFrameFunc(PyInterpreterState *interp,
2626 : : _PyFrameEvalFunction eval_frame)
2627 : : {
2628 [ # # ]: 0 : if (eval_frame == _PyEval_EvalFrameDefault) {
2629 : 0 : interp->eval_frame = NULL;
2630 : : }
2631 : : else {
2632 : 0 : interp->eval_frame = eval_frame;
2633 : : }
2634 : 0 : }
2635 : :
2636 : :
2637 : : const PyConfig*
2638 : 57673 : _PyInterpreterState_GetConfig(PyInterpreterState *interp)
2639 : : {
2640 : 57673 : return &interp->config;
2641 : : }
2642 : :
2643 : :
2644 : : int
2645 : 0 : _PyInterpreterState_GetConfigCopy(PyConfig *config)
2646 : : {
2647 : 0 : PyInterpreterState *interp = PyInterpreterState_Get();
2648 : :
2649 : 0 : PyStatus status = _PyConfig_Copy(config, &interp->config);
2650 [ # # ]: 0 : if (PyStatus_Exception(status)) {
2651 : 0 : _PyErr_SetFromPyStatus(status);
2652 : 0 : return -1;
2653 : : }
2654 : 0 : return 0;
2655 : : }
2656 : :
2657 : :
2658 : : const PyConfig*
2659 : 31240 : _Py_GetConfig(void)
2660 : : {
2661 : 31240 : _PyRuntimeState *runtime = &_PyRuntime;
2662 : : assert(PyGILState_Check());
2663 : 31240 : PyThreadState *tstate = current_fast_get(runtime);
2664 : 31240 : _Py_EnsureTstateNotNULL(tstate);
2665 : 31240 : return _PyInterpreterState_GetConfig(tstate->interp);
2666 : : }
2667 : :
2668 : :
2669 : : int
2670 : 20 : _PyInterpreterState_HasFeature(PyInterpreterState *interp, unsigned long feature)
2671 : : {
2672 : 20 : return ((interp->feature_flags & feature) != 0);
2673 : : }
2674 : :
2675 : :
2676 : : #define MINIMUM_OVERHEAD 1000
2677 : :
2678 : : static PyObject **
2679 : 25 : push_chunk(PyThreadState *tstate, int size)
2680 : : {
2681 : 25 : int allocate_size = DATA_STACK_CHUNK_SIZE;
2682 [ - + ]: 25 : while (allocate_size < (int)sizeof(PyObject*)*(size + MINIMUM_OVERHEAD)) {
2683 : 0 : allocate_size *= 2;
2684 : : }
2685 : 25 : _PyStackChunk *new = allocate_chunk(allocate_size, tstate->datastack_chunk);
2686 [ - + ]: 25 : if (new == NULL) {
2687 : 0 : return NULL;
2688 : : }
2689 [ - + ]: 25 : if (tstate->datastack_chunk) {
2690 : 0 : tstate->datastack_chunk->top = tstate->datastack_top -
2691 : 0 : &tstate->datastack_chunk->data[0];
2692 : : }
2693 : 25 : tstate->datastack_chunk = new;
2694 : 25 : tstate->datastack_limit = (PyObject **)(((char *)new) + allocate_size);
2695 : : // When new is the "root" chunk (i.e. new->previous == NULL), we can keep
2696 : : // _PyThreadState_PopFrame from freeing it later by "skipping" over the
2697 : : // first element:
2698 : 25 : PyObject **res = &new->data[new->previous == NULL];
2699 : 25 : tstate->datastack_top = res + size;
2700 : 25 : return res;
2701 : : }
2702 : :
2703 : : _PyInterpreterFrame *
2704 : 1424205 : _PyThreadState_PushFrame(PyThreadState *tstate, size_t size)
2705 : : {
2706 : : assert(size < INT_MAX/sizeof(PyObject *));
2707 [ + + ]: 1424205 : if (_PyThreadState_HasStackSpace(tstate, (int)size)) {
2708 : 1424180 : _PyInterpreterFrame *res = (_PyInterpreterFrame *)tstate->datastack_top;
2709 : 1424180 : tstate->datastack_top += size;
2710 : 1424180 : return res;
2711 : : }
2712 : 25 : return (_PyInterpreterFrame *)push_chunk(tstate, (int)size);
2713 : : }
2714 : :
2715 : : void
2716 : 3608148 : _PyThreadState_PopFrame(PyThreadState *tstate, _PyInterpreterFrame * frame)
2717 : : {
2718 : : assert(tstate->datastack_chunk);
2719 : 3608148 : PyObject **base = (PyObject **)frame;
2720 [ - + ]: 3608148 : if (base == &tstate->datastack_chunk->data[0]) {
2721 : 0 : _PyStackChunk *chunk = tstate->datastack_chunk;
2722 : 0 : _PyStackChunk *previous = chunk->previous;
2723 : : // push_chunk ensures that the root chunk is never popped:
2724 : : assert(previous);
2725 : 0 : tstate->datastack_top = &previous->data[previous->top];
2726 : 0 : tstate->datastack_chunk = previous;
2727 : 0 : _PyObject_VirtualFree(chunk, chunk->size);
2728 : 0 : tstate->datastack_limit = (PyObject **)(((char *)previous) + previous->size);
2729 : : }
2730 : : else {
2731 : : assert(tstate->datastack_top);
2732 : : assert(tstate->datastack_top >= base);
2733 : 3608148 : tstate->datastack_top = base;
2734 : : }
2735 : 3608148 : }
2736 : :
2737 : :
2738 : : #ifdef __cplusplus
2739 : : }
2740 : : #endif
|