Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 2 additions & 0 deletions Include/internal/pycore_signal.h
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down
67 changes: 66 additions & 1 deletion Lib/test/test_signal.py
Original file line number Diff line number Diff line change
Expand Up @@ -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):
Expand Down Expand Up @@ -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):

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

A bit on the fence about this test since it mutates the internal state setting a lock before fork. Believe this is the only approach to reliably test that we don't hold the mutex on fork

# 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):
Expand Down Expand Up @@ -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:
Expand Down
Original file line number Diff line number Diff line change
@@ -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.
16 changes: 16 additions & 0 deletions Modules/_testinternalcapi.c
Original file line number Diff line number Diff line change
Expand Up @@ -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)
Expand Down Expand Up @@ -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},
Expand Down
49 changes: 31 additions & 18 deletions Modules/signalmodule.c
Original file line number Diff line number Diff line change
Expand Up @@ -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()
Expand Down Expand Up @@ -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;
}


Expand Down Expand Up @@ -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;
}
Expand Down Expand Up @@ -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;
Expand Down Expand Up @@ -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
Expand All @@ -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;
Expand Down Expand Up @@ -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)
Expand Down Expand Up @@ -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
Expand Down Expand Up @@ -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);
Expand Down
1 change: 1 addition & 0 deletions Python/pystate.c
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down
Loading