[NativeProcessLinux] Remove event mutex and clean functions using it

[labath]

Summary

Since the former-TSC events are now processed synchronously, there is no need for to protect them
with a separate mutex - all the actions are now guarded by the big m_threads_mutex.

With the mutex gone, the following functions, no longer have any purpose and were removed:
NotifyThreadCreate: replaced by direct calls to ThreadWasCreated
NotifyThreadStop: replaced by direct calls to ThreadDidStop
NotifyThreadDeath: folded into StopTrackingThread
ResetForExec: inlined as it consisted of a single line of code
RequestThreadResume(AsNeeded): replaced by direct calls to ResumeThread
StopThreads -> removed, as it was never called

[labath]

Small cleanups...

[labath]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

2220–2221

Instead of locking m_threads_mutex at random places (here, MonitorSIGTRAP, MonitorSignal, ...) I would lock it just once, at the beginning of MonitorCallback. I think it will make more future-proof. I don't anticipate the slightly decreased concurrency will affect the performance in any way, and we may potentially increase stability, since then all MonitorCallback actions will be fully atomic.
What do you think?

[ovyalov]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

2219–2220

s/NativeThreadLinux/NativeProcessLinux

2220–2221

Why do you need to acquire m_threads_mutex here?
It seems only GetThreadByID within ThreadDidStop needs to access m_threads but GetThreadByID by itself is synchronized with m_threads_mutex.

2220–2221

m_threads_mutex is supposed to synchronize access to m_threads collections and I'm not sure about expanding its synchronization scope - I'd rather keep scope of m_threads_mutex pretty fine-grained .

[labath]

Fix typo, remove m_threads_mutex lock

source/Plugins/Process/Linux/NativeProcessLinux.cpp

2219–2220

Done.

2220–2221

I was worried about possible interactions with other functions executing concurrently and accessing other members of NPL/NTL: while the rest of ThreadDidStop does not access m_threads, it does some fairly complicated stuff with the thread that stopped and it is not immediately clear what are the possible interactions between this and any other code starting/stopping a thread (even a different thread) concurrently.

However, I have now realised that this code is already covered by Monitor::ScopedOperationLock, which makes sure monitor callbacks don't interleave with other threads. This makes the precautionary locking of m_threads unnecessary and I have removed it.

[ovyalov]

Looks good.

source/Plugins/Process/Linux/NativeProcessLinux.h

#endif
 
         Error
         Detach(lldb::tid_t tid);
 
 
         // Typedefs.
         typedef std::unordered_set<lldb::tid_t> ThreadIDSet;
 
-        // Notify that a thread is created and/or starting to be tracked.
-        void
-        NotifyThreadCreate(lldb::tid_t tid);
-
-
-        // Notify the delegate after a given set of threads stops. The triggering_tid will be set
-        // as the current thread. The error_function will be fired if either the triggering tid
-        // or any of the wait_for_stop_tids are unknown.
-        void
-        StopThreads(lldb::tid_t triggering_tid, const ThreadIDSet &wait_for_stop_tids);
-
-        // Notify the delegate after all non-stopped threads stop. The triggering_tid will be set
-        // as the current thread. The error_function will be fired if the triggering tid
-        // is unknown.
+        // This method is requests a stop on all threads which are still running. It sets up a
+        // deferred delegate notification, which will fire once threads report as stopped. The
+        // triggerring_tid will be set as the current thread (main stop reason).
         void
         StopRunningThreads(lldb::tid_t triggering_tid);
 
         // Notify the delegate after all non-stopped threads stop. The triggering_tid will be set
         // as the current thread. The error_function will be fired if either the triggering tid
         // or any of the wait_for_stop_tids are unknown.  This variant will send stop requests to
         // all non-stopped threads except skip_stop_request_tid.
         void
         StopRunningThreadsWithSkipTID(lldb::tid_t triggering_tid, lldb::tid_t skip_stop_request_tid);
 
-        // Notify the thread stopped.  Will trigger error at time of execution if we
-        // already think it is stopped.
-        Error
-        NotifyThreadStop(lldb::tid_t tid, bool initiated_by_llgs);
-
-        // Request that the given thread id should have the request_thread_resume_function
-        // called. This call signals an error if the thread resume is for
-        // a thread that is already in a running state.
-        Error
-        RequestThreadResume (lldb::tid_t tid,
-                             const NativeThreadLinux::ResumeThreadFunction &request_thread_resume_function);
-
-        // Request that the given thread id should have the request_thread_resume_function
-        // called. This call ignores threads that are already running and
-        // does not trigger an error in that case.
-        Error
-        RequestThreadResumeAsNeeded (lldb::tid_t tid,
-                                     const NativeThreadLinux::ResumeThreadFunction &request_thread_resume_function);
-
-        // Indicate the calling process did an exec and that the thread state
-        // should be 100% cleared.
-        void
-        ResetForExec ();
-
     private:
         struct PendingNotification
         {
             PendingNotification (lldb::tid_t triggering_tid,
                                  const ThreadIDSet &wait_for_stop_tids,
                                  const ThreadIDSet &skip_stop_request_tids):
                 triggering_tid (triggering_tid),
                 wait_for_stop_tids (wait_for_stop_tids),
private:
         void SignalIfRequirementsSatisfied();
 
         bool
         RequestStopOnAllSpecifiedThreads();
 
         void
         RequestStopOnAllRunningThreads();
 
-        std::mutex m_event_mutex; // Serializes execution of ProcessEvent. XXX
-
         Error
         ThreadDidStop(lldb::tid_t tid, bool initiated_by_llgs);
 
+        // Resume the thread with the given thread id using the request_thread_resume_function
+        // called. If error_when_already_running is then then an error is raised if we think this
+        // thread is already running.
         Error
-        DoResume(lldb::tid_t tid, NativeThreadLinux::ResumeThreadFunction request_thread_resume_function,
+        ResumeThread(lldb::tid_t tid, NativeThreadLinux::ResumeThreadFunction request_thread_resume_function,
                 bool error_when_already_running);
 
         void
         DoStopThreads(PendingNotificationUP &&notification_up);
 
         void
         ThreadWasCreated (lldb::tid_t tid);
 
-        void
-        ThreadDidDie (lldb::tid_t tid);
-
         // Member variables.
         PendingNotificationUP m_pending_notification_up;
     };
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeProcessLinux_H_

source/Plugins/Process/Linux/NativeProcessLinux.cpp

NativeProcessLinux::Launch(LaunchArgs *args, Error &error)
     }
 
     if (log)
         log->Printf ("NativeProcessLinux::%s() adding pid = %" PRIu64, __FUNCTION__, pid);
 
     thread_sp = AddThread (pid);
     assert (thread_sp && "AddThread() returned a nullptr thread");
     std::static_pointer_cast<NativeThreadLinux> (thread_sp)->SetStoppedBySignal (SIGSTOP);
-    NotifyThreadCreate(pid);
+    ThreadWasCreated(pid);
 
     // Let our process instance know the thread has stopped.
     SetCurrentThreadID (thread_sp->GetID ());
     SetState (StateType::eStateStopped);
 
     if (log)
     {
         if (error.Success ())
while (Host::FindProcessThreads(pid, tids_to_attach))
                 it->second = true;
 
                 // Create the thread, mark it as stopped.
                 NativeThreadProtocolSP thread_sp (AddThread (static_cast<lldb::tid_t> (tid)));
                 assert (thread_sp && "AddThread() returned a nullptr");
 
                 // This will notify this is a new thread and tell the system it is stopped.
                 std::static_pointer_cast<NativeThreadLinux> (thread_sp)->SetStoppedBySignal (SIGSTOP);
-                NotifyThreadCreate(tid);
+                ThreadWasCreated(tid);
                 SetCurrentThreadID (thread_sp->GetID ());
             }
 
             // move the loop forward
             ++it;
         }
     }
 
NativeProcessLinux::MonitorCallback(lldb::pid_t pid,
     if (exited)
     {
         if (log)
             log->Printf ("NativeProcessLinux::%s() got exit signal(%d) , tid = %"  PRIu64 " (%s main thread)", __FUNCTION__, signal, pid, is_main_thread ? "is" : "is not");
 
         // This is a thread that exited.  Ensure we're not tracking it anymore.
         const bool thread_found = StopTrackingThread (pid);
 
-        // Make sure the thread state coordinator knows about this.
-        NotifyThreadDeath (pid);
-
         if (is_main_thread)
         {
             // We only set the exit status and notify the delegate if we haven't already set the process
             // state to an exited state.  We normally should have received a SIGTRAP | (PTRACE_EVENT_EXIT << 8)
             // for the main thread.
             const bool already_notified = (GetState() == StateType::eStateExited) || (GetState () == StateType::eStateCrashed);
             if (!already_notified)
             {
if (err.Success())
         else
             MonitorSignal(&info, pid, exited);
     }
     else
     {
         if (err.GetError() == EINVAL)
         {
             // This is a group stop reception for this tid.
             if (log)
-                log->Printf ("NativeThreadLinux::%s received a group stop for pid %" PRIu64 " tid %" PRIu64, __FUNCTION__, GetID (), pid);
-            NotifyThreadStop (pid, false);
+                log->Printf ("NativeProcessLinux::%s received a group stop for pid %" PRIu64 " tid %" PRIu64, __FUNCTION__, GetID (), pid);
+            ThreadDidStop(pid, false);
         }
         else
         {
             // ptrace(GETSIGINFO) failed (but not due to group-stop).
 
             // A return value of ESRCH means the thread/process is no longer on the system,
             // so it was killed somehow outside of our control.  Either way, we can't do anything
             // with it anymore.
 
             // Stop tracking the metadata for the thread since it's entirely off the system now.
             const bool thread_found = StopTrackingThread (pid);
 
-            // Make sure the thread state coordinator knows about this.
-            NotifyThreadDeath (pid);
-
             if (log)
                 log->Printf ("NativeProcessLinux::%s GetSignalInfo failed: %s, tid = %" PRIu64 ", signal = %d, status = %d (%s, %s, %s)",
                              __FUNCTION__, err.AsCString(), pid, signal, status, err.GetError() == ESRCH ? "thread/process killed" : "unknown reason", is_main_thread ? "is main thread" : "is not main thread", thread_found ? "thread metadata removed" : "thread metadata not found");
 
             if (is_main_thread)
             {
                 // Notify the delegate - our process is not available but appears to have been killed outside
                 // our control.  Is eStateExited the right exit state in this case?
NativeProcessLinux::WaitForNewThread(::pid_t tid)
 
     if (log)
         log->Printf ("NativeProcessLinux::%s() pid = %" PRIu64 ": tracking new thread tid %" PRIu32,
                  __FUNCTION__, GetID (), tid);
 
     new_thread_sp = AddThread(tid);
     std::static_pointer_cast<NativeThreadLinux> (new_thread_sp)->SetRunning ();
     Resume (tid, LLDB_INVALID_SIGNAL_NUMBER);
-    NotifyThreadCreate(tid);
+    ThreadWasCreated(tid);
 }
 
 void
 NativeProcessLinux::MonitorSIGTRAP(const siginfo_t *info, lldb::pid_t pid)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
     const bool is_main_thread = (pid == GetID ());
 
NativeProcessLinux::MonitorSIGTRAP(const siginfo_t *info, lldb::pid_t pid)
     }
 
     case (SIGTRAP | (PTRACE_EVENT_EXEC << 8)):
     {
         NativeThreadProtocolSP main_thread_sp;
         if (log)
             log->Printf ("NativeProcessLinux::%s() received exec event, code = %d", __FUNCTION__, info->si_code ^ SIGTRAP);
 
-        // The thread state coordinator needs to reset due to the exec.
-        ResetForExec ();
+        // Exec clears any pending notifications.
+        m_pending_notification_up.reset ();
 
         // Remove all but the main thread here.  Linux fork creates a new process which only copies the main thread.  Mutexes are in undefined state.
         if (log)
             log->Printf ("NativeProcessLinux::%s exec received, stop tracking all but main thread", __FUNCTION__);
 
         for (auto thread_sp : m_threads)
         {
             const bool is_main_thread = thread_sp && thread_sp->GetID () == GetID ();
case (SIGTRAP | (PTRACE_EVENT_EXEC << 8)):
         {
             SetCurrentThreadID (LLDB_INVALID_THREAD_ID);
             if (log)
                 log->Printf ("NativeProcessLinux::%s pid %" PRIu64 "no main thread found, discarded all threads, we're in a no-thread state!", __FUNCTION__, GetID ());
         }
 
         // Tell coordinator about about the "new" (since exec) stopped main thread.
         const lldb::tid_t main_thread_tid = GetID ();
-        NotifyThreadCreate(main_thread_tid);
+        ThreadWasCreated(main_thread_tid);
 
         // NOTE: ideally these next statements would execute at the same time as the coordinator thread create was executed.
         // Consider a handler that can execute when that happens.
         // Let our delegate know we have just exec'd.
         NotifyDidExec ();
 
         // If we have a main thread, indicate we are stopped.
         assert (main_thread_sp && "exec called during ptraced process but no main thread metadata tracked");
 
         // Let the process know we're stopped.
         StopRunningThreads (pid);
 
         break;
     }
 
     case (SIGTRAP | (PTRACE_EVENT_EXIT << 8)):
     {
         // The inferior process or one of its threads is about to exit.
         if (! thread_sp)
             break;
 
         // This thread is currently stopped.  It's not actually dead yet, just about to be.
-        NotifyThreadStop (pid, false);
+        ThreadDidStop (pid, false);
         // The actual stop reason does not matter much, as we are going to resume the thread a
         // few lines down. If we ever want to report this state to the debugger, then we should
         // invent a new stop reason.
         std::static_pointer_cast<NativeThreadLinux>(thread_sp)->SetStoppedBySignal(LLDB_INVALID_SIGNAL_NUMBER);
 
         unsigned long data = 0;
         if (GetEventMessage(pid, &data).Fail())
             data = -1;
 
         if (log)
         {
             log->Printf ("NativeProcessLinux::%s() received PTRACE_EVENT_EXIT, data = %lx (WIFEXITED=%s,WIFSIGNALED=%s), pid = %" PRIu64 " (%s)",
                          __FUNCTION__,
                          data, WIFEXITED (data) ? "true" : "false", WIFSIGNALED (data) ? "true" : "false",
                          pid,
                     is_main_thread ? "is main thread" : "not main thread");
         }
 
         if (is_main_thread)
         {
             SetExitStatus (convert_pid_status_to_exit_type (data), convert_pid_status_to_return_code (data), nullptr, true);
         }
 
         const int signo = static_cast<int> (data);
-        RequestThreadResume (pid,
+        ResumeThread(pid,
                 [=](lldb::tid_t tid_to_resume, bool supress_signal)
                 {
                     std::static_pointer_cast<NativeThreadLinux> (thread_sp)->SetRunning ();
                     return Resume (tid_to_resume, (supress_signal) ? LLDB_INVALID_SIGNAL_NUMBER : signo);
-                });
+                },
+                true);
 
         break;
     }
 
     case 0:
     case TRAP_TRACE:  // We receive this on single stepping.
     case TRAP_HWBKPT: // We receive this on watchpoint hit
         if (thread_sp)
case TRAP_BRKPT:
         break;
 
     case SIGTRAP:
     case (SIGTRAP | 0x80):
         if (log)
             log->Printf ("NativeProcessLinux::%s() received unknown SIGTRAP system call stop event, pid %" PRIu64 "tid %" PRIu64 ", resuming", __FUNCTION__, GetID (), pid);
 
         // This thread is currently stopped.
-        NotifyThreadStop (pid, false);
+        ThreadDidStop (pid, false);
         if (thread_sp)
             std::static_pointer_cast<NativeThreadLinux> (thread_sp)->SetStoppedBySignal (SIGTRAP);
 
             
         // Ignore these signals until we know more about them.
-        RequestThreadResume (pid,
+        ResumeThread(pid,
                 [=](lldb::tid_t tid_to_resume, bool supress_signal)
                 {
                     std::static_pointer_cast<NativeThreadLinux> (thread_sp)->SetRunning ();
                     return Resume (tid_to_resume, LLDB_INVALID_SIGNAL_NUMBER);
-                });
+                },
+                true);
         break;
 
     default:
         assert(false && "Unexpected SIGTRAP code!");
         if (log)
             log->Printf ("NativeProcessLinux::%s() pid %" PRIu64 "tid %" PRIu64 " received unhandled SIGTRAP code: 0x%" PRIx64, __FUNCTION__, GetID (), pid, static_cast<uint64_t> (SIGTRAP | (PTRACE_EVENT_CLONE << 8)));
         break;
         
     }
 }
 
 void
 NativeProcessLinux::MonitorTrace(lldb::pid_t pid, NativeThreadProtocolSP thread_sp)
 {
     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
     if (log)
         log->Printf("NativeProcessLinux::%s() received trace event, pid = %" PRIu64 " (single stepping)",
                 __FUNCTION__, pid);
 
     if (thread_sp)
         std::static_pointer_cast<NativeThreadLinux>(thread_sp)->SetStoppedByTrace();
 
     // This thread is currently stopped.
-    NotifyThreadStop(pid, false);
+    ThreadDidStop(pid, false);
 
     // Here we don't have to request the rest of the threads to stop or request a deferred stop.
     // This would have already happened at the time the Resume() with step operation was signaled.
     // At this point, we just need to say we stopped, and the deferred notifcation will fire off
     // once all running threads have checked in as stopped.
     SetCurrentThreadID(pid);
     // Tell the process we have a stop (from software breakpoint).
     StopRunningThreads(pid);
 }
 
 void
 NativeProcessLinux::MonitorBreakpoint(lldb::pid_t pid, NativeThreadProtocolSP thread_sp)
 {
     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_BREAKPOINTS));
     if (log)
         log->Printf("NativeProcessLinux::%s() received breakpoint event, pid = %" PRIu64,
                 __FUNCTION__, pid);
 
     // This thread is currently stopped.
-    NotifyThreadStop(pid, false);
+    ThreadDidStop(pid, false);
 
     // Mark the thread as stopped at breakpoint.
     if (thread_sp)
     {
         std::static_pointer_cast<NativeThreadLinux>(thread_sp)->SetStoppedByBreakpoint();
         Error error = FixupBreakpointPCAsNeeded(thread_sp);
         if (error.Fail())
             if (log)

 {
     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_WATCHPOINTS));
     if (log)
         log->Printf("NativeProcessLinux::%s() received watchpoint event, "
                     "pid = %" PRIu64 ", wp_index = %" PRIu32,
                     __FUNCTION__, pid, wp_index);
 
     // This thread is currently stopped.
-    NotifyThreadStop(pid, false);
+    ThreadDidStop(pid, false);
 
     // Mark the thread as stopped at watchpoint.
     // The address is at (lldb::addr_t)info->si_addr if we need it.
     lldbassert(thread_sp && "thread_sp cannot be NULL");
     std::static_pointer_cast<NativeThreadLinux>(thread_sp)->SetStoppedByWatchpoint(wp_index);
 
     // We need to tell all other running threads before we notify the delegate about this stop.
     StopRunningThreads(pid);
if ((info->si_pid == 0) && (info->si_code == SI_USER))
             log->Printf ("NativeProcessLinux::%s() pid = %" PRIu64 " tid %" PRIu64 ": new thread notification",
                      __FUNCTION__, GetID (), pid);
 
         thread_sp = AddThread(pid);
         assert (thread_sp.get() && "failed to create the tracking data for newly created inferior thread");
         // We can now resume the newly created thread.
         std::static_pointer_cast<NativeThreadLinux> (thread_sp)->SetRunning ();
         Resume (pid, LLDB_INVALID_SIGNAL_NUMBER);
-        NotifyThreadCreate(pid);
+        ThreadWasCreated(pid);
         // Done handling.
         return;
     }
 
     // Check for thread stop notification.
     if (is_from_llgs && (info->si_code == SI_TKILL) && (signo == SIGSTOP))
     {
         // This is a tgkill()-based stop.
if (is_from_llgs && (info->si_code == SI_TKILL) && (signo == SIGSTOP))
                 // leave the signal intact if this is the thread that was chosen as the
                 // triggering thread.
                 if (m_pending_notification_up && m_pending_notification_up->triggering_tid == pid)
                     linux_thread_sp->SetStoppedBySignal(SIGSTOP);
                 else
                     linux_thread_sp->SetStoppedBySignal(0);
 
                 SetCurrentThreadID (thread_sp->GetID ());
-                NotifyThreadStop (thread_sp->GetID (), true);
+                ThreadDidStop (thread_sp->GetID (), true);
             }
             else
             {
                 if (log)
                 {
                     // Retrieve the signal name if the thread was stopped by a signal.
                     int stop_signo = 0;
                     const bool stopped_by_signal = linux_thread_sp->IsStopped (&stop_signo);
                     const char *signal_name = stopped_by_signal ? GetUnixSignals ().GetSignalAsCString (stop_signo) : "<not stopped by signal>";
                     if (!signal_name)
                         signal_name = "<no-signal-name>";
 
                     log->Printf ("NativeProcessLinux::%s() pid %" PRIu64 " tid %" PRIu64 ", thread was already marked as a stopped state (state=%s, signal=%d (%s)), leaving stop signal as is",
                                  __FUNCTION__,
                                  GetID (),
                                  linux_thread_sp->GetID (),
                                  StateAsCString (thread_state),
                                  stop_signo,
                                  signal_name);
                 }
-                // Tell the thread state coordinator about the stop.
-                NotifyThreadStop (thread_sp->GetID (), false);
+                ThreadDidStop (thread_sp->GetID (), false);
             }
         }
 
         // Done handling.
         return;
     }
 
     if (log)
         log->Printf ("NativeProcessLinux::%s() received signal %s", __FUNCTION__, GetUnixSignals ().GetSignalAsCString (signo));
 
     // This thread is stopped.
-    NotifyThreadStop (pid, false);
+    ThreadDidStop (pid, false);
 
     switch (signo)
     {
     case SIGSTOP:
         {
             std::static_pointer_cast<NativeThreadLinux> (thread_sp)->SetStoppedBySignal (signo);
             if (log)
             {
                 if (is_from_llgs)
                     log->Printf ("NativeProcessLinux::%s pid = %" PRIu64 " tid %" PRIu64 " received SIGSTOP from llgs, most likely an interrupt", __FUNCTION__, GetID (), pid);
                 else
                     log->Printf ("NativeProcessLinux::%s pid = %" PRIu64 " tid %" PRIu64 " received SIGSTOP from outside of debugger", __FUNCTION__, GetID (), pid);
             }
 
             // Resume this thread to get the group-stop mechanism to fire off the true group stops.
             // This thread will get stopped again as part of the group-stop completion.
-            RequestThreadResume (pid,
+            ResumeThread(pid,
                     [=](lldb::tid_t tid_to_resume, bool supress_signal)
                     {
                         std::static_pointer_cast<NativeThreadLinux> (thread_sp)->SetRunning ();
                         // Pass this signal number on to the inferior to handle.
                         return Resume (tid_to_resume, (supress_signal) ? LLDB_INVALID_SIGNAL_NUMBER : signo);
-                    });
+                    },
+                    true);
         }
         break;
     case SIGSEGV:
     case SIGILL:
     case SIGFPE:
     case SIGBUS:
         if (thread_sp)
             std::static_pointer_cast<NativeThreadLinux> (thread_sp)->SetCrashedWithException (*info);
for (auto thread_sp : m_threads)
         }
 
         switch (action->state)
         {
         case eStateRunning:
         {
             // Run the thread, possibly feeding it the signal.
             const int signo = action->signal;
-            RequestThreadResumeAsNeeded (thread_sp->GetID (),
+            ResumeThread(thread_sp->GetID (),
                     [=](lldb::tid_t tid_to_resume, bool supress_signal)
                     {
                         std::static_pointer_cast<NativeThreadLinux> (thread_sp)->SetRunning ();
                         // Pass this signal number on to the inferior to handle.
                         const auto resume_result = Resume (tid_to_resume, (signo > 0 && !supress_signal) ? signo : LLDB_INVALID_SIGNAL_NUMBER);
                         if (resume_result.Success())
                             SetState(eStateRunning, true);
                         return resume_result;
-                    });
+                    },
+                    false);
             break;
         }
 
         case eStateStepping:
         {
             // Request the step.
             const int signo = action->signal;
-            RequestThreadResume (thread_sp->GetID (),
+            ResumeThread(thread_sp->GetID (),
                     [=](lldb::tid_t tid_to_step, bool supress_signal)
                     {
                         std::static_pointer_cast<NativeThreadLinux> (thread_sp)->SetStepping ();
 
                         Error step_result;
                         if (software_single_step)
                             step_result = Resume (tid_to_step, (signo > 0 && !supress_signal) ? signo : LLDB_INVALID_SIGNAL_NUMBER);
                         else
                             step_result = SingleStep (tid_to_step,(signo > 0 && !supress_signal) ? signo : LLDB_INVALID_SIGNAL_NUMBER);
 
                         assert (step_result.Success() && "SingleStep() failed");
                         if (step_result.Success())
                             SetState(eStateStepping, true);
                         return step_result;
-                    });
+                    },
+                    false);
             stepping = true;
             break;
         }
 
         case eStateSuspended:
         case eStateStopped:
             // if we haven't chosen a deferred signal tid yet, use this one.
             if (deferred_signal_tid == LLDB_INVALID_THREAD_ID)
NativeProcessLinux::MaybeGetThreadNoLock (lldb::tid_t thread_id)
 
     // We don't have this thread.
     return NativeThreadProtocolSP ();
 }
 
 bool
 NativeProcessLinux::StopTrackingThread (lldb::tid_t thread_id)
 {
+    Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
+
+    if (log)
+        log->Printf("NativeProcessLinux::%s (tid: %" PRIu64 ")", __FUNCTION__, thread_id);
+
+    bool found = false;
+
     Mutex::Locker locker (m_threads_mutex);
     for (auto it = m_threads.begin (); it != m_threads.end (); ++it)
     {
         if (*it && ((*it)->GetID () == thread_id))
         {
             m_threads.erase (it);
-            return true;
+            found = true;
+            break;
         }
     }
 
-    // Didn't find it.
-    return false;
+    // If we have a pending notification, remove this from the set.
+    if (m_pending_notification_up)
+    {
+        m_pending_notification_up->wait_for_stop_tids.erase(thread_id);
+        SignalIfRequirementsSatisfied();
+    }
+
+    return found;
 }
 
 NativeThreadProtocolSP
 NativeProcessLinux::AddThread (lldb::tid_t thread_id)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD));
 
     Mutex::Locker locker (m_threads_mutex);
NativeProcessLinux::GetLoadedModuleFileSpec(const char* module_path, FileSpec& file_spec)
     }
 
     file_spec.Clear();
     return Error("Module file (%s) not found in /proc/%" PRIu64 "/maps file!",
                  module_file_spec.GetFilename().AsCString(), GetID());
 }
 
 Error
-NativeProcessLinux::DoResume(
+NativeProcessLinux::ResumeThread(
         lldb::tid_t tid,
         NativeThreadLinux::ResumeThreadFunction request_thread_resume_function,
         bool error_when_already_running)
 {
     Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
-    
+    if (log)
+        log->Printf("NativeProcessLinux::%s (tid: %" PRIu64 ", error_when_already_running: %s)",
+                __FUNCTION__, tid, error_when_already_running?"true":"false");
+    
     auto thread_sp = std::static_pointer_cast<NativeThreadLinux>(GetThreadByID(tid));
     lldbassert(thread_sp != nullptr);
 
     auto& context = thread_sp->GetThreadContext();
     // Tell the thread to resume if we don't already think it is running.
     const bool is_stopped = StateIsStoppedState(thread_sp->GetState(), true);
 
     lldbassert(!(error_when_already_running && !is_stopped));
NativeProcessLinux::ResumeThread(
     }
 
     return error;
 }
 
 //===----------------------------------------------------------------------===//
 
 void
-NativeProcessLinux::StopThreads(const lldb::tid_t triggering_tid,
-                                          const ThreadIDSet &wait_for_stop_tids)
-{
-    Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
-    std::lock_guard<std::mutex> lock(m_event_mutex);
-
-    if (log)
-    {
-        log->Printf("NativeProcessLinux::%s about to process event: (triggering_tid: %" PRIu64 ", wait_for_stop_tids.size(): %zd)",
-                __FUNCTION__, triggering_tid, wait_for_stop_tids.size());
-    }
-
-    DoStopThreads(PendingNotificationUP(new PendingNotification(
-                triggering_tid, wait_for_stop_tids, ThreadIDSet())));
-
-    if (log)
-    {
-        log->Printf("NativeProcessLinux::%s event processing done", __FUNCTION__);
-    }
-}
-
-void
 NativeProcessLinux::StopRunningThreads(const lldb::tid_t triggering_tid)
 {
     Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
-    std::lock_guard<std::mutex> lock(m_event_mutex);
 
     if (log)
     {
         log->Printf("NativeProcessLinux::%s about to process event: (triggering_tid: %" PRIu64 ")",
                 __FUNCTION__, triggering_tid);
     }
 
     DoStopThreads(PendingNotificationUP(new PendingNotification(triggering_tid)));
 
     if (log)
     {
         log->Printf("NativeProcessLinux::%s event processing done", __FUNCTION__);
     }
 }
 
 void
 NativeProcessLinux::StopRunningThreadsWithSkipTID(lldb::tid_t triggering_tid,
                                                   lldb::tid_t skip_stop_request_tid)
 {
     Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
-    std::lock_guard<std::mutex> lock(m_event_mutex);
 
     if (log)
     {
         log->Printf("NativeProcessLinux::%s about to process event: (triggering_tid: %" PRIu64 ", skip_stop_request_tid: %" PRIu64 ")",
                 __FUNCTION__, triggering_tid, skip_stop_request_tid);
     }
 
     DoStopThreads(PendingNotificationUP(new PendingNotification(
NativeProcessLinux::RequestStopOnAllRunningThreads()
     // Set the wait list to the set of tids for which we requested stops.
     m_pending_notification_up->wait_for_stop_tids.swap (sent_tids);
 }
 
 
 Error
 NativeProcessLinux::ThreadDidStop (lldb::tid_t tid, bool initiated_by_llgs)
 {
+    Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
+
+    if (log)
+        log->Printf("NativeProcessLinux::%s (tid: %" PRIu64 ", %sinitiated by llgs)",
+                __FUNCTION__, tid, initiated_by_llgs?"":"not ");
+
     // Ensure we know about the thread.
     auto thread_sp = std::static_pointer_cast<NativeThreadLinux>(GetThreadByID(tid));
     lldbassert(thread_sp != nullptr);
 
     // Update the global list of known thread states.  This one is definitely stopped.
     auto& context = thread_sp->GetThreadContext();
     const auto stop_was_requested = context.stop_requested;
     context.stop_requested = false;
 
     // If we have a pending notification, remove this from the set.
     if (m_pending_notification_up)
     {
         m_pending_notification_up->wait_for_stop_tids.erase(tid);
         SignalIfRequirementsSatisfied();
     }
 
     Error error;
     if (initiated_by_llgs && context.request_resume_function && !stop_was_requested)
     {
-        Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
         // We can end up here if stop was initiated by LLGS but by this time a
         // thread stop has occurred - maybe initiated by another event.
         if (log)
             log->Printf("Resuming thread %"  PRIu64 " since stop wasn't requested", tid);
         error = context.request_resume_function (tid, true);
         if (error.Fail() && log)
         {
                 log->Printf("NativeProcessLinux::%s failed to resume thread tid  %" PRIu64 ": %s",
NativeProcessLinux::DoStopThreads(PendingNotificationUP &&notification_up)
     }
 
     SignalIfRequirementsSatisfied();
 }
 
 void
 NativeProcessLinux::ThreadWasCreated (lldb::tid_t tid)
 {
+    Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
+
+    if (log)
+        log->Printf("NativeProcessLinux::%s (tid: %" PRIu64 ")", __FUNCTION__, tid);
+
     auto thread_sp = std::static_pointer_cast<NativeThreadLinux>(GetThreadByID(tid));
     lldbassert(thread_sp != nullptr);
 
     if (m_pending_notification_up && StateIsRunningState(thread_sp->GetState()))
     {
         // We will need to wait for this new thread to stop as well before firing the
         // notification.
         m_pending_notification_up->wait_for_stop_tids.insert(tid);
         thread_sp->RequestStop();
     }
 }
-
-void
-NativeProcessLinux::ThreadDidDie (lldb::tid_t tid)
-{
-    // If we have a pending notification, remove this from the set.
-    if (m_pending_notification_up)
-    {
-        m_pending_notification_up->wait_for_stop_tids.erase(tid);
-        SignalIfRequirementsSatisfied();
-    }
-}
-
-Error
-NativeProcessLinux::NotifyThreadStop (lldb::tid_t tid, bool initiated_by_llgs)
-{
-    Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
-    std::lock_guard<std::mutex> lock(m_event_mutex);
-
-    if (log)
-    {
-        log->Printf("NativeProcessLinux::%s about to process event: (tid: %" PRIu64 ", %sinitiated by llgs)",
-                __FUNCTION__, tid, initiated_by_llgs?"":"not ");
-    }
-
-    Error error = ThreadDidStop (tid, initiated_by_llgs);
-
-    if (log)
-    {
-        log->Printf("NativeProcessLinux::%s event processing done", __FUNCTION__);
-    }
-
-    return error;
-}
-
-Error
-NativeProcessLinux::RequestThreadResume (lldb::tid_t tid,
-                                         const NativeThreadLinux::ResumeThreadFunction &request_thread_resume_function)
-{
-    Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
-    std::lock_guard<std::mutex> lock(m_event_mutex);
-
-    if (log)
-    {
-        log->Printf("NativeProcessLinux::%s about to process event: (tid: %" PRIu64 ")",
-                __FUNCTION__, tid);
-    }
-
-    Error error = DoResume(tid, request_thread_resume_function, true);
-
-    if (log)
-    {
-        log->Printf("NativeProcessLinux::%s event processing done", __FUNCTION__);
-    }
-
-    return error;
-}
-
-Error
-NativeProcessLinux::RequestThreadResumeAsNeeded (lldb::tid_t tid,
-        const NativeThreadLinux::ResumeThreadFunction &request_thread_resume_function)
-{
-    Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
-    std::lock_guard<std::mutex> lock(m_event_mutex);
-
-    if (log)
-    {
-        log->Printf("NativeProcessLinux::%s about to process event: (tid: %" PRIu64 ")",
-                __FUNCTION__, tid);
-    }
-
-    Error error = DoResume (tid, request_thread_resume_function, false);
-
-    if (log)
-    {
-        log->Printf("NativeProcessLinux::%s event processing done", __FUNCTION__);
-    }
-
-    return error;
-}
-
-void
-NativeProcessLinux::NotifyThreadCreate(lldb::tid_t tid)
-{
-    Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
-    std::lock_guard<std::mutex> lock(m_event_mutex);
-
-    if (log)
-        log->Printf("NativeProcessLinux::%s about to process event: (tid: %" PRIu64 ")", __FUNCTION__, tid);
-
-    ThreadWasCreated(tid);
-
-    if (log)
-    {
-        log->Printf("NativeProcessLinux::%s event processing done", __FUNCTION__);
-    }
-}
-
-void
-NativeProcessLinux::NotifyThreadDeath (lldb::tid_t tid)
-{
-    Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
-    std::lock_guard<std::mutex> lock(m_event_mutex);
-
-    if (log)
-    {
-        log->Printf("NativeProcessLinux::%s about to process event: (tid: %" PRIu64 ")", __FUNCTION__, tid);
-    }
-
-    ThreadDidDie(tid);
-
-    if (log)
-    {
-        log->Printf("NativeProcessLinux::%s event processing done", __FUNCTION__);
-    }
-}
-
-void
-NativeProcessLinux::ResetForExec ()
-{
-    Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
-    std::lock_guard<std::mutex> lock(m_event_mutex);
-
-    if (log)
-    {
-        log->Printf("NativeProcessLinux::%s about to process event", __FUNCTION__);
-    }
-
-    // Clear the pending notification if there was one.
-    m_pending_notification_up.reset ();
-
-    if (log)
-    {
-        log->Printf("NativeProcessLinux::%s event processing done", __FUNCTION__);
-    }
-}