Fix some other missing cases.

Author: ZeroIntensity

Include/internal/pycore_interp_structs.h

@@ -968,7 +968,7 @@ struct _is {
     struct {
         _PyRWMutex lock;
         Py_ssize_t countdown;
-    } finalization_locks;
+    } finalization_guards;
 
     /* the initial PyInterpreterState.threads.head */
     _PyThreadStateImpl _initial_thread;

Python/pylifecycle.c

@@ -2130,22 +2130,23 @@ make_pre_finalization_calls(PyThreadState *tstate, int subinterpreters)
         // XXX Why does _PyThreadState_DeleteList() rely on all interpreters
         // being stopped?
         _PyEval_StopTheWorldAll(interp->runtime);
-        _PyRWMutex_Lock(&interp->finalization_locks.lock);
+        _PyRWMutex_Lock(&interp->finalization_guards.lock);
         int has_subinterpreters = subinterpreters
                                     ? runtime_has_subinterpreters(interp->runtime)
                                     : 0;
-        // TODO: The interpreter reference countdown probably isn't very efficient.
+        // TODO: The interpreter guard countdown isn't very efficient. We should
+        // wait on an event or something like that.
         int should_continue = (interp_has_threads(interp)
                               || interp_has_atexit_callbacks(interp)
                               || interp_has_pending_calls(interp)
                               || has_subinterpreters
-                              || interp->finalization_locks.countdown > 0);
+                              || interp->finalization_guards.countdown > 0);
         if (!should_continue) {
             break;
         }
         // Temporarily let other threads execute
         _PyThreadState_Detach(tstate);
-        _PyRWMutex_Unlock(&interp->finalization_locks.lock);
+        _PyRWMutex_Unlock(&interp->finalization_guards.lock);
         _PyEval_StartTheWorldAll(interp->runtime);
         PyMutex_Unlock(&interp->ceval.pending.mutex);
         _PyThreadState_Attach(tstate);
@@ -2209,7 +2210,7 @@ _Py_Finalize(_PyRuntimeState *runtime)
     for (PyThreadState *p = list; p != NULL; p = p->next) {
         _PyThreadState_SetShuttingDown(p);
     }
-    _PyRWMutex_Unlock(&tstate->interp->finalization_locks.lock);
+    _PyRWMutex_Unlock(&tstate->interp->finalization_guards.lock);
     _PyEval_StartTheWorldAll(runtime);
     PyMutex_Unlock(&tstate->interp->ceval.pending.mutex);
 
@@ -2579,7 +2580,7 @@ Py_EndInterpreter(PyThreadState *tstate)
         _PyThreadState_SetShuttingDown(p);
     }
 
-    _PyRWMutex_Unlock(&interp->finalization_locks.lock);
+    _PyRWMutex_Unlock(&interp->finalization_guards.lock);
     _PyEval_StartTheWorldAll(interp->runtime);
     PyMutex_Unlock(&interp->ceval.pending.mutex);
     _PyThreadState_DeleteList(list, /*is_after_fork=*/0);

Python/pystate.c

@@ -3147,19 +3147,19 @@ Py_ssize_t
 _PyInterpreterState_LockCountdown(PyInterpreterState *interp)
 {
     assert(interp != NULL);
-    return _Py_atomic_load_ssize_relaxed(&interp->finalization_locks.countdown);
+    return _Py_atomic_load_ssize_relaxed(&interp->finalization_guards.countdown);
 }
 
 static PyInterpreterGuard
 try_acquire_interp_guard(PyInterpreterState *interp)
 {
-    _PyRWMutex_RLock(&interp->finalization_locks.lock);
+    _PyRWMutex_RLock(&interp->finalization_guards.lock);
     if (_PyInterpreterState_GetFinalizing(interp) != NULL) {
-        _PyRWMutex_RUnlock(&interp->finalization_locks.lock);
+        _PyRWMutex_RUnlock(&interp->finalization_guards.lock);
         return (PyInterpreterGuard)interp;
     }
-    _Py_atomic_add_ssize(&interp->finalization_locks.countdown, 1);
-    _PyRWMutex_RUnlock(&interp->finalization_locks.lock);
+    _Py_atomic_add_ssize(&interp->finalization_guards.countdown, 1);
+    _PyRWMutex_RUnlock(&interp->finalization_guards.lock);
     return (PyInterpreterGuard)interp;
 }
 
@@ -3204,9 +3204,9 @@ PyInterpreterGuard_Release(PyInterpreterGuard guard)
 {
     PyInterpreterState *interp = guard_as_interp(guard);
     assert(interp != NULL);
-    _PyRWMutex_RLock(&interp->finalization_locks.lock);
-    Py_ssize_t old = _Py_atomic_add_ssize(&interp->finalization_locks.countdown, -1);
-    _PyRWMutex_RUnlock(&interp->finalization_locks.lock);
+    _PyRWMutex_RLock(&interp->finalization_guards.lock);
+    Py_ssize_t old = _Py_atomic_add_ssize(&interp->finalization_guards.countdown, -1);
+    _PyRWMutex_RUnlock(&interp->finalization_guards.lock);
     if (old <= 0) {
         Py_FatalError("interpreter has negative guard count, likely due"
                       " to an extra PyInterpreterGuard_Release() call");