cef1e07cc6
When LLDB receives a SIGINT while running the embedded Python REPL it currently
just crashes in `ScriptInterpreterPythonImpl::Interrupt` with an error such as
the one below:
```
Fatal Python error: PyThreadState_Get: the function must be called with the GIL
held, but the GIL is released (the current Python thread state is NULL)
```
The faulty code that causes this error is this part of `ScriptInterpreterPythonImpl::Interrupt`:
```
PyThreadState *state = PyThreadState_GET();
if (!state)
state = GetThreadState();
if (state) {
long tid = state->thread_id;
PyThreadState_Swap(state);
int num_threads = PyThreadState_SetAsyncExc(tid, PyExc_KeyboardInterrupt);
```
The obvious fix I tried is to just acquire the GIL before this code is running
which fixes the crash but the `KeyboardInterrupt` we want to raise immediately
is actually just queued and would only be raised once the next line of input has
been parsed (which e.g. won't interrupt Python code that is currently waiting on
a timer or IO from what I can see). Also none of the functions we call here is
marked as safe to be called from a signal handler from what I can see, so we
might still end up crashing here with some bad timing.
Python 3.2 introduced `PyErr_SetInterrupt` to solve this and the function takes
care of all the details and avoids doing anything that isn't safe to do inside a
signal handler. The only thing we need to do is to manually setup our own fake
SIGINT handler that behaves the same way as the standalone Python REPL signal
handler (which raises a KeyboardInterrupt).
From what I understand the old code used to work with Python 2 so I kept the old
code around until we officially drop support for Python 2.
There is a small gap here with Python 3.0->3.1 where we might still be crashing,
but those versions have reached their EOL more than a decade ago so I think we
don't need to bother about them.
Reviewed By: JDevlieghere
Differential Revision: https://reviews.llvm.org/D104886
74 lines
2.6 KiB
Python
74 lines
2.6 KiB
Python
"""
|
|
Test sending SIGINT to the embedded Python REPL.
|
|
"""
|
|
|
|
import os
|
|
|
|
import lldb
|
|
from lldbsuite.test.decorators import *
|
|
from lldbsuite.test.lldbtest import *
|
|
from lldbsuite.test.lldbpexpect import PExpectTest
|
|
|
|
class TestCase(PExpectTest):
|
|
|
|
mydir = TestBase.compute_mydir(__file__)
|
|
|
|
def start_python_repl(self):
|
|
""" Starts up the embedded Python REPL."""
|
|
self.launch()
|
|
# Start the embedded Python REPL via the 'script' command.
|
|
self.child.send("script -l python --\n")
|
|
# Wait for the Python REPL prompt.
|
|
self.child.expect(">>>")
|
|
|
|
# PExpect uses many timeouts internally and doesn't play well
|
|
# under ASAN on a loaded machine..
|
|
@skipIfAsan
|
|
def test_while_evaluating_code(self):
|
|
""" Tests SIGINT handling while Python code is being evaluated."""
|
|
self.start_python_repl()
|
|
|
|
# Start a long-running command that we try to abort with SIGINT.
|
|
# Note that we dont actually wait 10000s in this code as pexpect or
|
|
# lit will kill the test way before that.
|
|
self.child.send("import time; print('running' + 'now'); time.sleep(10000);\n")
|
|
|
|
# Make sure the command is actually being evaluated at the moment by
|
|
# looking at the string that the command is printing.
|
|
# Don't check for a needle that also occurs in the program itself to
|
|
# prevent that echoing will make this check pass unintentionally.
|
|
self.child.expect("runningnow")
|
|
|
|
# Send SIGINT to the LLDB process.
|
|
self.child.sendintr()
|
|
|
|
# This should get transformed to a KeyboardInterrupt which is the same
|
|
# behaviour as the standalone Python REPL. It should also interrupt
|
|
# the evaluation of our sleep statement.
|
|
self.child.expect("KeyboardInterrupt")
|
|
# Send EOF to quit the Python REPL.
|
|
self.child.sendeof()
|
|
|
|
self.quit()
|
|
|
|
# PExpect uses many timeouts internally and doesn't play well
|
|
# under ASAN on a loaded machine..
|
|
@skipIfAsan
|
|
# FIXME: On Linux the Python code that reads from stdin seems to block until
|
|
# it has finished reading a line before handling any queued signals.
|
|
@skipIfLinux
|
|
def test_while_waiting_on_input(self):
|
|
""" Tests SIGINT handling while the REPL is waiting on input from
|
|
stdin."""
|
|
self.start_python_repl()
|
|
|
|
# Send SIGINT to the LLDB process.
|
|
self.child.sendintr()
|
|
# This should get transformed to a KeyboardInterrupt which is the same
|
|
# behaviour as the standalone Python REPL.
|
|
self.child.expect("KeyboardInterrupt")
|
|
# Send EOF to quit the Python REPL.
|
|
self.child.sendeof()
|
|
|
|
self.quit()
|