diff --git a/Include/internal/pycore_signal.h b/Include/internal/pycore_signal.h index 47213a34ab77b5..8a3ccf00ae6905 100644 --- a/Include/internal/pycore_signal.h +++ b/Include/internal/pycore_signal.h @@ -42,6 +42,8 @@ struct _signals_runtime_state { int tripped; PyObject* func; } handlers[Py_NSIG]; + // Serializes taking a reference to handlers[i].func with replacing it. + PyMutex handlers_mutex; volatile struct { #ifdef MS_WINDOWS diff --git a/Lib/test/test_signal.py b/Lib/test/test_signal.py index 2cad18a69ff7c0..d02f7f27459827 100644 --- a/Lib/test/test_signal.py +++ b/Lib/test/test_signal.py @@ -12,15 +12,21 @@ 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 + force_not_colorized, is_apple, is_apple_mobile, os_helper, threading_helper, + warnings_helper, ) from test.support.script_helper import assert_python_ok, spawn_python try: import _testcapi except ImportError: _testcapi = None +try: + import _testinternalcapi +except ImportError: + _testinternalcapi = None class GenericTests(unittest.TestCase): @@ -179,6 +185,29 @@ def test_keyboard_interrupt_exit_code(self): # Writing an automation friendly test of an interactive shell # to confirm that our process died via a SIGINT proved too complex. + @support.requires_fork() + @unittest.skipIf(_testinternalcapi is None, "requires _testinternalcapi") + @warnings_helper.ignore_fork_in_thread_deprecation_warnings() + def test_fork_with_handler_lock_held(self): + # A thread holding the handler table lock when another thread forks, + # such as one in a subinterpreter with its own GIL, does not exist in + # the child, so the child must not inherit the lock held. + _testinternalcapi.lock_signal_handlers() + try: + pid = os.fork() + if pid == 0: + # In the child: hangs here if the lock was inherited held. + try: + signal.getsignal(signal.SIGINT) + except BaseException: + os._exit(1) + os._exit(0) + finally: + _testinternalcapi.unlock_signal_handlers() + + # A child stuck on the inherited lock never exits, so this times out. + support.wait_process(pid, exitcode=0) + @unittest.skipUnless(sys.platform == "win32", "Windows specific") class WindowsSignalTests(unittest.TestCase): @@ -1441,6 +1470,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/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..bb286fb4e9479f --- /dev/null +++ b/Misc/NEWS.d/next/Library/2026-11-02-22-45-00.gh-issue-161235.sGt4Hd.rst @@ -0,0 +1,4 @@ +Fix use-after-free crashes in :mod:`signal`. On all builds, a signal +handler that replaces itself is now kept alive until it returns. On the +:term:`free-threaded build`, :func:`signal.getsignal` no longer crashes +when another thread replaces the handler. diff --git a/Modules/_testinternalcapi.c b/Modules/_testinternalcapi.c index 16be593763bf66..af484e8a46c2b8 100644 --- a/Modules/_testinternalcapi.c +++ b/Modules/_testinternalcapi.c @@ -226,6 +226,20 @@ test_stop_the_world(PyObject *self, PyObject *Py_UNUSED(args)) Py_RETURN_NONE; } +static PyObject * +lock_signal_handlers(PyObject *self, PyObject *Py_UNUSED(args)) +{ + PyMutex_Lock(&_PyRuntime.signals.handlers_mutex); + Py_RETURN_NONE; +} + +static PyObject * +unlock_signal_handlers(PyObject *self, PyObject *Py_UNUSED(args)) +{ + PyMutex_Unlock(&_PyRuntime.signals.handlers_mutex); + Py_RETURN_NONE; +} + #ifdef MS_WINDOWS static const char * classify_address(uintptr_t addr, int jit_enabled, PyInterpreterState *interp) @@ -3349,6 +3363,8 @@ static PyMethodDef module_functions[] = { {"get_stack_pointer", get_stack_pointer, METH_NOARGS}, {"get_stack_margin", get_stack_margin, METH_NOARGS}, {"test_stop_the_world", test_stop_the_world, METH_NOARGS}, + {"lock_signal_handlers", lock_signal_handlers, METH_NOARGS}, + {"unlock_signal_handlers", unlock_signal_handlers, METH_NOARGS}, {"classify_stack_addresses", classify_stack_addresses, METH_VARARGS}, {"get_jit_code_ranges", get_jit_code_ranges, METH_NOARGS}, {"get_jit_backend", get_jit_backend, METH_NOARGS}, diff --git a/Modules/signalmodule.c b/Modules/signalmodule.c index bc5aef55648e07..d25ef8c74e3c8b 100644 --- a/Modules/signalmodule.c +++ b/Modules/signalmodule.c @@ -9,6 +9,7 @@ #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_pyerrors.h" // _PyErr_SetString() #include "pycore_pystate.h" // _PyThreadState_GET() @@ -135,12 +136,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); + PyMutex_LockFlags(&_PyRuntime.signals.handlers_mutex, + _Py_LOCK_DONT_DETACH); + PyObject *func = Py_XNewRef(get_handler(i)); + PyMutex_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) +{ + PyMutex_LockFlags(&_PyRuntime.signals.handlers_mutex, + _Py_LOCK_DONT_DETACH); + PyObject *old = _Py_atomic_exchange_ptr(&Handlers[i].func, + Py_XNewRef(func)); + PyMutex_Unlock(&_PyRuntime.signals.handlers_mutex); + return old; } @@ -532,9 +548,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 +583,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 +1609,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 +1621,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 +1756,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 +1856,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 +1894,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); diff --git a/Python/pystate.c b/Python/pystate.c index 81360f4999849d..2f620e93e759bc 100644 --- a/Python/pystate.c +++ b/Python/pystate.c @@ -322,6 +322,7 @@ _Py_COMP_DIAG_POP &(runtime)->_main_interpreter.types.mutex, \ &(runtime)->_main_interpreter.code_state.mutex, \ &(runtime)->_main_interpreter.dict_state.watcher_mutex, \ + &(runtime)->signals.handlers_mutex, \ } static void