diff options
6 files changed, 105 insertions, 7 deletions
diff --git a/lldb/include/lldb/Target/StopInfo.h b/lldb/include/lldb/Target/StopInfo.h index e0d029bcc95..61bc084f1bd 100644 --- a/lldb/include/lldb/Target/StopInfo.h +++ b/lldb/include/lldb/Target/StopInfo.h @@ -116,6 +116,12 @@ public: else m_description.clear(); } + + virtual bool + IsValidForOperatingSystemThread (Thread &thread) + { + return true; + } // Sometimes the thread plan logic will know that it wants a given stop to stop or not, // regardless of what the ordinary logic for that StopInfo would dictate. The main example diff --git a/lldb/source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp b/lldb/source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp index e85020a965c..df847dbb9ce 100644 --- a/lldb/source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp +++ b/lldb/source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp @@ -178,11 +178,18 @@ OperatingSystemPython::UpdateThreadList (ThreadList &old_thread_list, Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OS)); - // First thing we have to do is get the API lock, and the run lock. We're going to change the thread - // content of the process, and we're going to use python, which requires the API lock to do it. - // So get & hold that. This is a recursive lock so we can grant it to any Python code called on the stack below us. + // First thing we have to do is to try to get the API lock, and the run lock. + // We're going to change the thread content of the process, and we're going + // to use python, which requires the API lock to do it. + // + // If someone already has the API lock, that is ok, we just want to avoid + // external code from making new API calls while this call is happening. + // + // This is a recursive lock so we can grant it to any Python code called on + // the stack below us. Target &target = m_process->GetTarget(); - Mutex::Locker api_locker (target.GetAPIMutex()); + Mutex::Locker api_locker; + api_locker.TryLock(target.GetAPIMutex()); if (log) log->Printf ("OperatingSystemPython::UpdateThreadList() fetching thread data from python for pid %" PRIu64, m_process->GetID()); diff --git a/lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp b/lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp index a69b38b6c93..7c68d0d0782 100644 --- a/lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp +++ b/lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp @@ -498,12 +498,15 @@ StopInfoMachException::CreateStopReasonWithMachException // If the breakpoint is for this thread, then we'll report the hit, but if it is for another thread, // we can just report no reason. We don't need to worry about stepping over the breakpoint here, that // will be taken care of when the thread resumes and notices that there's a breakpoint under the pc. - if (bp_site_sp->ValidForThisThread (&thread)) + // If we have an operating system plug-in, we might have set a thread specific breakpoint using the + // operating system thread ID, so we can't make any assumptions about the thread ID so we must always + // report the breakpoint regardless of the thread. + if (bp_site_sp->ValidForThisThread (&thread) || thread.GetProcess()->GetOperatingSystem () != NULL) return StopInfo::CreateStopReasonWithBreakpointSiteID (thread, bp_site_sp->GetID()); else return StopInfoSP(); } - + // Don't call this a trace if we weren't single stepping this thread. if (is_trace_if_actual_breakpoint_missing && thread.GetTemporaryResumeState() == eStateStepping) { diff --git a/lldb/source/Plugins/Process/Utility/ThreadMemory.cpp b/lldb/source/Plugins/Process/Utility/ThreadMemory.cpp index 56e5a9a59fa..6a7aa626baf 100644 --- a/lldb/source/Plugins/Process/Utility/ThreadMemory.cpp +++ b/lldb/source/Plugins/Process/Utility/ThreadMemory.cpp @@ -105,7 +105,7 @@ ThreadMemory::CalculateStopInfo () if (m_backing_thread_sp) { lldb::StopInfoSP backing_stop_info_sp (m_backing_thread_sp->GetPrivateStopInfo()); - if (backing_stop_info_sp) + if (backing_stop_info_sp && backing_stop_info_sp->IsValidForOperatingSystemThread(*this)) { backing_stop_info_sp->SetThread (shared_from_this()); SetStopInfo (backing_stop_info_sp); diff --git a/lldb/source/Target/StopInfo.cpp b/lldb/source/Target/StopInfo.cpp index 72d474c81f8..bf81c0f316a 100644 --- a/lldb/source/Target/StopInfo.cpp +++ b/lldb/source/Target/StopInfo.cpp @@ -163,6 +163,19 @@ public: { } + virtual bool + IsValidForOperatingSystemThread (Thread &thread) + { + ProcessSP process_sp (thread.GetProcess()); + if (process_sp) + { + BreakpointSiteSP bp_site_sp (process_sp->GetBreakpointSiteList().FindByID (m_value)); + if (bp_site_sp) + return bp_site_sp->ValidForThisThread (&thread); + } + return false; + } + virtual StopReason GetStopReason () const { diff --git a/lldb/test/functionalities/plugins/python_os_plugin/TestPythonOSPlugin.py b/lldb/test/functionalities/plugins/python_os_plugin/TestPythonOSPlugin.py index fe0b4a21bf3..16feb5f85a2 100644 --- a/lldb/test/functionalities/plugins/python_os_plugin/TestPythonOSPlugin.py +++ b/lldb/test/functionalities/plugins/python_os_plugin/TestPythonOSPlugin.py @@ -26,6 +26,19 @@ class PluginPythonOSPlugin(TestBase): self.buildDwarf() self.run_python_os_funcionality() + @skipUnlessDarwin + @dsym_test + def test_python_os_step_dsym(self): + """Test that the Python operating system plugin works correctly when single stepping a virtual thread""" + self.buildDsym() + self.run_python_os_step() + + @dwarf_test + def run_python_os_step_dwarf(self): + """Test that the Python operating system plugin works correctly when single stepping a virtual thread""" + self.buildDwarf() + self.run_python_os_step() + def verify_os_thread_registers(self, thread): frame = thread.GetFrameAtIndex(0) registers = frame.GetRegisters().GetValueAtIndex(0) @@ -94,6 +107,62 @@ class PluginPythonOSPlugin(TestBase): thread = process.GetThreadByID(0x333333333); self.assertFalse (thread.IsValid(), "Make sure there is no thread 0x333333333 after we unload the python OS plug-in"); + def run_python_os_step(self): + """Test that the Python operating system plugin works correctly and allows single stepping of a virtual thread that is backed by a real thread""" + + # Set debugger into synchronous mode + self.dbg.SetAsync(False) + + # Create a target by the debugger. + cwd = os.getcwd() + exe = os.path.join(cwd, "a.out") + python_os_plugin_path = os.path.join(cwd, "operating_system2.py") + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + # Set breakpoints inside and outside methods that take pointers to the containing struct. + lldbutil.run_break_set_by_source_regexp (self, "// Set breakpoint here") + + # Register our shared libraries for remote targets so they get automatically uploaded + arguments = None + environment = None + + # Now launch the process, and do not stop at entry point. + process = target.LaunchSimple (arguments, environment, self.get_process_working_directory()) + self.assertTrue(process, PROCESS_IS_VALID) + + # Make sure there are no OS plug-in created thread when we first stop at our breakpoint in main + thread = process.GetThreadByID(0x111111111); + self.assertFalse (thread.IsValid(), "Make sure there is no thread 0x111111111 before we load the python OS plug-in"); + + + # Now load the python OS plug-in which should update the thread list and we should have + # OS plug-in created threads with the IDs: 0x111111111, 0x222222222, 0x333333333 + command = "settings set target.process.python-os-plugin-path '%s'" % python_os_plugin_path + self.dbg.HandleCommand(command) + + # Verify our OS plug-in threads showed up + thread = process.GetThreadByID(0x111111111); + self.assertTrue (thread.IsValid(), "Make sure there is a thread 0x111111111 after we load the python OS plug-in"); + + frame = thread.GetFrameAtIndex(0) + self.assertTrue(frame.IsValid(), "Make sure we get a frame from thread 0x111111111") + line_entry = frame.GetLineEntry() + + self.assertTrue(line_entry.GetFileSpec().GetFilename() == 'main.c', "Make sure we stopped on line 5 in main.c") + self.assertTrue(line_entry.GetLine() == 5, "Make sure we stopped on line 5 in main.c") + + # Now single step thread 0x111111111 and make sure it does what we need it to + thread.StepOver() + + frame = thread.GetFrameAtIndex(0) + self.assertTrue(frame.IsValid(), "Make sure we get a frame from thread 0x111111111") + line_entry = frame.GetLineEntry() + + self.assertTrue(line_entry.GetFileSpec().GetFilename() == 'main.c', "Make sure we stepped from line 5 to line 6 in main.c") + self.assertTrue(line_entry.GetLine() == 6, "Make sure we stepped from line 5 to line 6 in main.c") + + if __name__ == '__main__': import atexit lldb.SBDebugger.Initialize() |
