From a955cc1e02ba0045d30e70f60e25ba3377c5c8f0 Mon Sep 17 00:00:00 2001 From: jg Date: Mon, 16 Nov 2026 19:59:11 +0000 Subject: [PATCH 1/2] Make the signal handler table partially safe thread safe with a lock Add a mutex which protects access to the handler map under normal access. We delebrately do not have a lock in PyErr_SetInterruptEx due to deadlock concerns. --- Include/internal/pycore_signal.h | 4 +++ Lib/test/test_signal.py | 37 +++++++++++++++++++++++ Modules/signalmodule.c | 50 ++++++++++++++++++++------------ 3 files changed, 73 insertions(+), 18 deletions(-) diff --git a/Include/internal/pycore_signal.h b/Include/internal/pycore_signal.h index 47213a34ab77b5..499fad074150ab 100644 --- a/Include/internal/pycore_signal.h +++ b/Include/internal/pycore_signal.h @@ -42,6 +42,10 @@ struct _signals_runtime_state { int tripped; PyObject* func; } handlers[Py_NSIG]; +#ifdef Py_GIL_DISABLED + // Serializes taking a reference to handlers[i].func with replacing it. + PyMutex handlers_mutex; +#endif volatile struct { #ifdef MS_WINDOWS diff --git a/Lib/test/test_signal.py b/Lib/test/test_signal.py index 2cad18a69ff7c0..abf1ada6044e13 100644 --- a/Lib/test/test_signal.py +++ b/Lib/test/test_signal.py @@ -12,6 +12,7 @@ import threading import time import unittest +import weakref from test import support from test.support import ( force_not_colorized, is_apple, is_apple_mobile, os_helper, threading_helper @@ -1441,6 +1442,42 @@ def handler(a, b): signal.raise_signal(signal.SIGINT) self.assertTrue(is_ok) + def test_handler_replacing_itself_stays_alive(self): + events = [] + def handler(signum, frame): + events.append("enter") + signal.signal(signum, signal.SIG_DFL) + support.gc_collect() + events.append("exit") + handler = functools.partial(handler) + wr = weakref.ref(handler, lambda ref: events.append("freed")) + old_signal = signal.signal(signal.SIGINT, handler) + self.addCleanup(signal.signal, signal.SIGINT, old_signal) + del handler + + signal.raise_signal(signal.SIGINT) + support.gc_collect() + self.assertEqual(events, ["enter", "exit", "freed"]) + + def test_handler_replacing_itself_and_raising_is_freed(self): + events = [] + def handler(signum, frame): + events.append("enter") + signal.signal(signum, signal.SIG_DFL) + support.gc_collect() + events.append("exit") + raise ZeroDivisionError + handler = functools.partial(handler) + wr = weakref.ref(handler, lambda ref: events.append("freed")) + old_signal = signal.signal(signal.SIGINT, handler) + self.addCleanup(signal.signal, signal.SIGINT, old_signal) + del handler + + with self.assertRaises(ZeroDivisionError): + signal.raise_signal(signal.SIGINT) + support.gc_collect() + self.assertEqual(events, ["enter", "exit", "freed"]) + def test__thread_interrupt_main(self): # See https://github.com/python/cpython/issues/102397 code = """if 1: diff --git a/Modules/signalmodule.c b/Modules/signalmodule.c index bc5aef55648e07..3196f51f3fc3c8 100644 --- a/Modules/signalmodule.c +++ b/Modules/signalmodule.c @@ -9,7 +9,9 @@ #include "pycore_emscripten_signal.h" // _Py_CHECK_EMSCRIPTEN_SIGNALS #include "pycore_fileutils.h" // _Py_BEGIN_SUPPRESS_IPH #include "pycore_interpframe.h" // _PyThreadState_GetFrame() +#include "pycore_lock.h" // _Py_LOCK_DONT_DETACH #include "pycore_moduleobject.h" // _PyModule_GetState() +#include "pycore_pyatomic_ft_wrappers.h" // FT_MUTEX_LOCK_FLAGS() #include "pycore_pyerrors.h" // _PyErr_SetString() #include "pycore_pystate.h" // _PyThreadState_GET() #include "pycore_signal.h" // _Py_RestoreSignals() @@ -135,12 +137,27 @@ get_handler(int i) return (PyObject *)_Py_atomic_load_ptr(&Handlers[i].func); } -Py_LOCAL_INLINE(void) -set_handler(int i, PyObject* func) +Py_LOCAL_INLINE(PyObject *) +get_handler_ref(int i) { - /* Store func with atomic operation to ensure - that PyErr_SetInterrupt is async-signal-safe. */ - _Py_atomic_store_ptr(&Handlers[i].func, func); + FT_MUTEX_LOCK_FLAGS(&_PyRuntime.signals.handlers_mutex, + _Py_LOCK_DONT_DETACH); + PyObject *func = Py_XNewRef(get_handler(i)); + FT_MUTEX_UNLOCK(&_PyRuntime.signals.handlers_mutex); + return func; +} + +/* Store a new reference to func as the Python handler of signal i and return + the reference to the previous handler, which the caller must release. */ +Py_LOCAL_INLINE(PyObject *) +swap_handler(int i, PyObject *func) +{ + FT_MUTEX_LOCK_FLAGS(&_PyRuntime.signals.handlers_mutex, + _Py_LOCK_DONT_DETACH); + PyObject *old = _Py_atomic_exchange_ptr(&Handlers[i].func, + Py_XNewRef(func)); + FT_MUTEX_UNLOCK(&_PyRuntime.signals.handlers_mutex); + return old; } @@ -532,9 +549,7 @@ signal_signal_impl(PyObject *module, int signalnum, PyObject *handler) return NULL; } - old_handler = get_handler(signalnum); - set_handler(signalnum, Py_NewRef(handler)); - + old_handler = swap_handler(signalnum, handler); if (old_handler != NULL) { return old_handler; } @@ -569,9 +584,9 @@ signal_getsignal_impl(PyObject *module, int signalnum) "signal number out of range"); return NULL; } - old_handler = get_handler(signalnum); + old_handler = get_handler_ref(signalnum); if (old_handler != NULL) { - return Py_NewRef(old_handler); + return old_handler; } else { Py_RETURN_NONE; @@ -1595,9 +1610,7 @@ signal_get_set_handlers(signal_state_t *state, PyObject *mod_dict) } // If signal_module_exec() is called more than one, we must // clear the strong reference to the previous function. - PyObject* old_func = get_handler(signum); - set_handler(signum, Py_NewRef(func)); - Py_XDECREF(old_func); + Py_XDECREF(swap_handler(signum, func)); } // Install Python SIGINT handler which raises KeyboardInterrupt @@ -1609,8 +1622,8 @@ signal_get_set_handlers(signal_state_t *state, PyObject *mod_dict) return -1; } - set_handler(SIGINT, int_handler); - Py_DECREF(sigint_func); + Py_XDECREF(swap_handler(SIGINT, int_handler)); + Py_DECREF(int_handler); PyOS_setsig(SIGINT, signal_handler); } return 0; @@ -1744,9 +1757,8 @@ _PySignal_Fini(void) // Restore default signals and clear handlers for (int signum = 1; signum < Py_NSIG; signum++) { - PyObject *func = get_handler(signum); _Py_atomic_store_int_relaxed(&Handlers[signum].tripped, 0); - set_handler(signum, NULL); + PyObject *func = swap_handler(signum, NULL); if (func != NULL && func != Py_None && !compare_handler(func, state->default_handler) @@ -1845,10 +1857,11 @@ _PyErr_CheckSignalsTstate(PyThreadState *tstate) * signal handler for it by the time PyErr_CheckSignals() is called * (see bpo-43406). */ - PyObject *func = get_handler(i); + PyObject *func = get_handler_ref(i); if (func == NULL || func == Py_None || compare_handler(func, state->ignore_handler) || compare_handler(func, state->default_handler)) { + Py_XDECREF(func); /* No Python signal handler due to aforementioned race condition. * We can't call raise() as it would break the assumption * that PyErr_SetInterrupt() only *simulates* an incoming @@ -1882,6 +1895,7 @@ _PyErr_CheckSignalsTstate(PyThreadState *tstate) else { result = NULL; } + Py_DECREF(func); if (!result) { /* On error, re-schedule a call to _PyErr_CheckSignalsTstate() */ _Py_atomic_store_int(&is_tripped, 1); From 62e816627a7af8069b0ef845354a773ada1a8541 Mon Sep 17 00:00:00 2001 From: jg Date: Mon, 16 Nov 2026 20:10:53 +0000 Subject: [PATCH 2/2] Add NEWS entry --- .../Library/2026-11-02-22-45-00.gh-issue-161235.sGt4Hd.rst | 3 +++ 1 file changed, 3 insertions(+) create mode 100644 Misc/NEWS.d/next/Library/2026-11-02-22-45-00.gh-issue-161235.sGt4Hd.rst diff --git a/Misc/NEWS.d/next/Library/2026-11-02-22-45-00.gh-issue-161235.sGt4Hd.rst b/Misc/NEWS.d/next/Library/2026-11-02-22-45-00.gh-issue-161235.sGt4Hd.rst new file mode 100644 index 00000000000000..aca0de93760e06 --- /dev/null +++ b/Misc/NEWS.d/next/Library/2026-11-02-22-45-00.gh-issue-161235.sGt4Hd.rst @@ -0,0 +1,3 @@ +Fix a crash in :func:`signal.getsignal` on the :term:`free-threaded build` +when another thread replaces the handler. A signal handler that replaces +itself now stays alive until it returns.