"""
Test that single thread step over deadlock issue can be resolved
after timeout.
"""
import lldb
from lldbsuite.test.decorators import *
from lldbsuite.test.lldbtest import *
from lldbsuite.test import lldbutil
class SingleThreadStepTimeoutTestCase(TestBase):
NO_DEBUG_INFO_TESTCASE = True
def setUp(self):
TestBase.setUp(self)
self.main_source = "main.cpp"
self.build()
def verify_hit_correct_line(self, pattern):
target_line = line_number(self.main_source, pattern)
self.assertNotEqual(target_line, 0, "Could not find source pattern " + pattern)
cur_line = self.thread.frames[0].GetLineEntry().GetLine()
self.assertEqual(
cur_line,
target_line,
"Stepped to line %d instead of expected %d with pattern '%s'."
% (cur_line, target_line, pattern),
)
def step_over_deadlock_helper(self):
(target, _, self.thread, _) = lldbutil.run_to_source_breakpoint(
self, "// Set breakpoint1 here", lldb.SBFileSpec(self.main_source)
)
signal_main_thread_value = target.FindFirstGlobalVariable("signal_main_thread")
self.assertTrue(signal_main_thread_value.IsValid())
# Change signal_main_thread global variable to 1 so that worker thread loop can
# terminate and move forward to signal main thread
signal_main_thread_value.SetValueFromCString("1")
self.thread.StepOver(lldb.eOnlyThisThread)
self.verify_hit_correct_line("// Finish step-over from breakpoint1")
@skipIfWindows
def test_step_over_deadlock_small_timeout_fast_stepping(self):
"""Test single thread step over deadlock on other threads can be resolved after timeout with small timeout and fast stepping."""
self.dbg.HandleCommand(
"settings set target.process.thread.single-thread-plan-timeout 10"
)
self.dbg.HandleCommand("settings set target.use-fast-stepping true")
self.step_over_deadlock_helper()
@skipIfWindows
def test_step_over_deadlock_small_timeout_slow_stepping(self):
"""Test single thread step over deadlock on other threads can be resolved after timeout with small timeout and slow stepping."""
self.dbg.HandleCommand(
"settings set target.process.thread.single-thread-plan-timeout 10"
)
self.dbg.HandleCommand("settings set target.use-fast-stepping false")
self.step_over_deadlock_helper()
@skipIfWindows
def test_step_over_deadlock_large_timeout_fast_stepping(self):
"""Test single thread step over deadlock on other threads can be resolved after timeout with large timeout and fast stepping."""
self.dbg.HandleCommand(
"settings set target.process.thread.single-thread-plan-timeout 2000"
)
self.dbg.HandleCommand("settings set target.use-fast-stepping true")
self.step_over_deadlock_helper()
@skipIfWindows
def test_step_over_deadlock_large_timeout_slow_stepping(self):
"""Test single thread step over deadlock on other threads can be resolved after timeout with large timeout and slow stepping."""
self.dbg.HandleCommand(
"settings set target.process.thread.single-thread-plan-timeout 2000"
)
self.dbg.HandleCommand("settings set target.use-fast-stepping false")
self.step_over_deadlock_helper()
def step_over_multi_calls_helper(self):
(target, _, self.thread, _) = lldbutil.run_to_source_breakpoint(
self, "// Set breakpoint2 here", lldb.SBFileSpec(self.main_source)
)
self.thread.StepOver(lldb.eOnlyThisThread)
self.verify_hit_correct_line("// Finish step-over from breakpoint2")
@skipIfWindows
def test_step_over_multi_calls_small_timeout_fast_stepping(self):
"""Test step over source line with multiple call instructions works fine with small timeout and fast stepping."""
self.dbg.HandleCommand(
"settings set target.process.thread.single-thread-plan-timeout 10"
)
self.dbg.HandleCommand("settings set target.use-fast-stepping true")
self.step_over_multi_calls_helper()
@skipIfWindows
def test_step_over_multi_calls_small_timeout_slow_stepping(self):
"""Test step over source line with multiple call instructions works fine with small timeout and slow stepping."""
self.dbg.HandleCommand(
"settings set target.process.thread.single-thread-plan-timeout 10"
)
self.dbg.HandleCommand("settings set target.use-fast-stepping false")
self.step_over_multi_calls_helper()
@skipIfWindows
def test_step_over_multi_calls_large_timeout_fast_stepping(self):
"""Test step over source line with multiple call instructions works fine with large timeout and fast stepping."""
self.dbg.HandleCommand(
"settings set target.process.thread.single-thread-plan-timeout 2000"
)
self.dbg.HandleCommand("settings set target.use-fast-stepping true")
self.step_over_multi_calls_helper()
@skipIfWindows
def test_step_over_multi_calls_large_timeout_slow_stepping(self):
"""Test step over source line with multiple call instructions works fine with large timeout and slow stepping."""
self.dbg.HandleCommand(
"settings set target.process.thread.single-thread-plan-timeout 2000"
)
self.dbg.HandleCommand("settings set target.use-fast-stepping false")
self.step_over_multi_calls_helper()
@skipIfWindows
def test_step_over_deadlock_with_inner_breakpoint_continue(self):
"""Test step over deadlock function with inner breakpoint will trigger the breakpoint
and later continue will finish the stepping.
"""
self.dbg.HandleCommand(
"settings set target.process.thread.single-thread-plan-timeout 2000"
)
(target, process, self.thread, _) = lldbutil.run_to_source_breakpoint(
self, "// Set breakpoint1 here", lldb.SBFileSpec(self.main_source)
)
signal_main_thread_value = target.FindFirstGlobalVariable("signal_main_thread")
self.assertTrue(signal_main_thread_value.IsValid())
# Change signal_main_thread global variable to 1 so that worker thread loop can
# terminate and move forward to signal main thread
signal_main_thread_value.SetValueFromCString("1")
# Set breakpoint on inner function call
inner_breakpoint = target.BreakpointCreateByLocation(
lldb.SBFileSpec(self.main_source),
line_number("main.cpp", "// Set interrupt breakpoint here"),
0,
0,
lldb.SBFileSpecList(),
False,
)
# Step over will hit the inner breakpoint and stop
self.thread.StepOver(lldb.eOnlyThisThread)
self.assertStopReason(self.thread.GetStopReason(), lldb.eStopReasonBreakpoint)
thread1 = lldbutil.get_one_thread_stopped_at_breakpoint(
process, inner_breakpoint
)
self.assertTrue(
thread1.IsValid(),
"We are indeed stopped at inner breakpoint inside deadlock_func",
)
# Continue the process should complete the step-over
process.Continue()
self.assertState(process.GetState(), lldb.eStateStopped)
self.assertStopReason(self.thread.GetStopReason(), lldb.eStopReasonPlanComplete)
self.verify_hit_correct_line("// Finish step-over from breakpoint1")
@skipIfWindows
def test_step_over_deadlock_with_inner_breakpoint_step(self):
"""Test step over deadlock function with inner breakpoint will trigger the breakpoint
and later step still works
"""
self.dbg.HandleCommand(
"settings set target.process.thread.single-thread-plan-timeout 2000"
)
(target, process, self.thread, _) = lldbutil.run_to_source_breakpoint(
self, "// Set breakpoint1 here", lldb.SBFileSpec(self.main_source)
)
signal_main_thread_value = target.FindFirstGlobalVariable("signal_main_thread")
self.assertTrue(signal_main_thread_value.IsValid())
# Change signal_main_thread global variable to 1 so that worker thread loop can
# terminate and move forward to signal main thread
signal_main_thread_value.SetValueFromCString("1")
# Set breakpoint on inner function call
inner_breakpoint = target.BreakpointCreateByLocation(
lldb.SBFileSpec(self.main_source),
line_number("main.cpp", "// Set interrupt breakpoint here"),
0,
0,
lldb.SBFileSpecList(),
False,
)
# Step over will hit the inner breakpoint and stop
self.thread.StepOver(lldb.eOnlyThisThread)
self.assertStopReason(self.thread.GetStopReason(), lldb.eStopReasonBreakpoint)
thread1 = lldbutil.get_one_thread_stopped_at_breakpoint(
process, inner_breakpoint
)
self.assertTrue(
thread1.IsValid(),
"We are indeed stopped at inner breakpoint inside deadlock_func",
)
# Step still works
self.thread.StepOver(lldb.eOnlyThisThread)
self.assertState(process.GetState(), lldb.eStateStopped)
self.assertStopReason(self.thread.GetStopReason(), lldb.eStopReasonPlanComplete)
self.verify_hit_correct_line("// Finish step-over from inner breakpoint")
@skipIfWindows
def test_step_over_deadlock_with_user_async_interrupt(self):
"""Test step over deadlock function with large timeout then send async interrupt
should report correct stop reason
"""
self.dbg.HandleCommand(
"settings set target.process.thread.single-thread-plan-timeout 2000000"
)
(target, process, self.thread, _) = lldbutil.run_to_source_breakpoint(
self, "// Set breakpoint1 here", lldb.SBFileSpec(self.main_source)
)
signal_main_thread_value = target.FindFirstGlobalVariable("signal_main_thread")
self.assertTrue(signal_main_thread_value.IsValid())
# Change signal_main_thread global variable to 1 so that worker thread loop can
# terminate and move forward to signal main thread
signal_main_thread_value.SetValueFromCString("1")
self.dbg.SetAsync(True)
# This stepping should block due to large timeout and should be interrupted by the
# async interrupt from the worker thread
self.thread.StepOver(lldb.eOnlyThisThread)
time.sleep(1)
listener = self.dbg.GetListener()
lldbutil.expect_state_changes(self, listener, process, [lldb.eStateRunning])
self.dbg.SetAsync(False)
process.SendAsyncInterrupt()
lldbutil.expect_state_changes(self, listener, process, [lldb.eStateStopped])
self.assertStopReason(self.thread.GetStopReason(), lldb.eStopReasonSignal)
Codebase Browser
llvm