[NativeProcessLinux] Remove the post-stop lambda

[labath]

Summary

The lambda was always calling SetState(eStateStopped) with small variations, so I have inlined
the code. Given that we don't have the TSC anymore, I believe we don't need to be so generic.

The only major change here is the way we choose a stop reason thread when we're interrupting a
program on client request. Previously, we were setting a null stop reason for all threads and
then fixing up the reason for one victim thread in the lambda. Now, I make sure the stop reason
is set for the victim thread correctly in the first place.

I also take the opportunity to rename CallAfter* functions into something more appropriate.

[vharron]

Looks good. What does this change do to flakey tests? Have you run dosep.py 100x?

[chaoren]

Some preliminary comments:

source/Plugins/Process/Linux/NativeProcessLinux.cpp

2703 ↗

(On Diff #24540)

as we they are just

Typo?

2708 ↗

(On Diff #24540)

This seems unnecessary. I think

if (...)
    linux_thread_sp->SetStoppedBySignal(SIGSTOP);
else
    linux_thread_sp->SetStoppedBySignal(0);

looks more obvious, and saves a variable (and an assignment).

source/Plugins/Process/Linux/NativeProcessLinux.h

555 ↗

(On Diff #24540)

DoStopThreads?

[labath]

• Address review comments
• Rebase on D9296

[labath]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

2708 ↗

(On Diff #24540)

Agreed.

source/Plugins/Process/Linux/NativeProcessLinux.h

555 ↗

(On Diff #24540)

Changed. In the long run, I plan to get rid of this function anyway.

[labath]

Rebasing...

[vharron]

I ran 50 iterations of "dosep.py -A i386 -A x86_64 -C gcc -C clang-3.5 -C clang-tot" before and after this patch sequence.

before patches

old3 KBDownload

with patches

new3 KBDownload

This has disappeared completely:

ExpectedFailure-i386-gcc-TestExitDuringStep.ExitDuringStepTestCase.test_thread_state_is_stopped_with_dwarf.log

These tests began failing on i386 gcc/clang-tot but were hidden by XFAIL

ThreadStates.ThreadStateTestCase.test_process_interrupt_with_dwarf
ThreadStates.ThreadStateTestCase.test_process_state_with_dwarf
ThreadStates.ThreadStateTestCase.test_state_after_breakpoint_with_dwarf

Please fix these tests and then you're good to submit.

Congratulations.

[vharron]

Some more interesting results when I look at UnexpectedSuccess

ExitDuringStep improved significantly (i386-gcc was the only one with failures and now it's passing 100%. You should remote the XFAILs from all configs)

6/50 failures->0/50 failures ExitDuringStep.ExitDuringStepTestCase.test_step_in_with_dwarf i386-gcc
19/50 failures -> 0/50 failures ExitDuringStep.ExitDuringStepTestCase.test_step_over_with_dwarf i386-gcc

PrintStackTraces.ThreadsStackTracesTestCase.test_stack_traces is only ever failing on i386 about 50% of the time, never on x86_64. Consider removing x86_64 XFAIL again.

This test went from 1/300 failures to 0/300 failures: (not significant)

CallWithTimeout.ExprCommandWithTimeoutsTestCase.test_with_dwarf
CreateAfterAttachTestCase.test_create_after_attach_with_dwarf_and_fork

This test increased from 0/300 failures to 1/300 failures: (not significant)

GdbRemoteAuxvSupport.TestGdbRemoteAuxvSupport.test_auxv_chunked_reads_work_llgs_dwarf

[chaoren]

LGTM. Some typos:

source/Plugins/Process/Linux/NativeProcessLinux.cpp

2715 ↗

(On Diff #24629)

// we they are

The typo is still here.

source/Plugins/Process/Linux/NativeProcessLinux.h

412 ↗

(On Diff #24734)

Remove "either".

lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.h

#endif
 
         void
         NotifyThreadDeath (lldb::tid_t tid);
 
         void
         NotifyThreadStop (lldb::tid_t tid);
 
         void
-        CallAfterRunningThreadsStop (lldb::tid_t tid,
-                                     const std::function<void (lldb::tid_t tid)> &call_after_function);
+        StopRunningThreads (lldb::tid_t triggering_tid);
 
         void
-        CallAfterRunningThreadsStopWithSkipTID (lldb::tid_t deferred_signal_tid,
-                                                lldb::tid_t skip_stop_request_tid,
-                                                const std::function<void (lldb::tid_t tid)> &call_after_function);
+        StopRunningThreadsWithSkipTID (lldb::tid_t deferred_signal_tid,
+                                                lldb::tid_t skip_stop_request_tid);
 
         Error
         Detach(lldb::tid_t tid);
 
         Error
         RequestThreadStop (const lldb::pid_t pid, const lldb::tid_t tid);
 
 
     public:
         // Typedefs.
         typedef std::unordered_set<lldb::tid_t> ThreadIDSet;
 
         // Callback/block definitions.
-        typedef std::function<void (lldb::tid_t tid)> ThreadIDFunction;
         typedef std::function<void (const char *format, va_list args)> LogFunction;
         typedef std::function<void (const std::string &error_message)> ErrorFunction;
         typedef std::function<Error (lldb::tid_t tid)> StopThreadFunction;
         typedef std::function<Error (lldb::tid_t tid, bool supress_signal)> ResumeThreadFunction;
 
     private:
         // Notify the coordinator when a thread is created and/or starting to be
         // tracked.  is_stopped should be true if the thread is currently stopped;
         // otherwise, it should be set false if it is already running.  Will
         // call the error function if the thread id is already tracked.
         void
         NotifyThreadCreate (lldb::tid_t tid,
                             bool is_stopped,
                             const ErrorFunction &error_function);
 
         // Notify the coordinator when a previously-existing thread should no
         // longer be tracked.  The error_function will trigger if the thread
         // is not being tracked.
         void
         NotifyThreadDeath (lldb::tid_t tid,
                            const ErrorFunction &error_function);
 
 
-        // This method is the main purpose of the class: triggering a deferred
-        // action after a given set of threads stop.  The triggering_tid is the
-        // thread id passed to the call_after_function.  The error_function will
-        // be fired if either the triggering tid or any of the wait_for_stop_tids
-        // are unknown at the time the method is processed.
+        // 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
-        CallAfterThreadsStop (lldb::tid_t triggering_tid,
+        StopThreads(lldb::tid_t triggering_tid,
                               const ThreadIDSet &wait_for_stop_tids,
                               const StopThreadFunction &request_thread_stop_function,
-                              const ThreadIDFunction &call_after_function,
                               const ErrorFunction &error_function);
 
-        // This method is the main purpose of the class: triggering a deferred
-        // action after all non-stopped threads stop.  The triggering_tid is the
-        // thread id passed to the call_after_function.  The error_function will
-        // be fired if the triggering tid is unknown at the time of execution.
+        // 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.
         void
-        CallAfterRunningThreadsStop (lldb::tid_t triggering_tid,
+        StopRunningThreads(lldb::tid_t triggering_tid,
                                      const StopThreadFunction &request_thread_stop_function,
-                                     const ThreadIDFunction &call_after_function,
                                      const ErrorFunction &error_function);
 
-        // This method is the main purpose of the class: triggering a deferred
-        // action after all non-stopped threads stop.  The triggering_tid is the
-        // thread id passed to the call_after_function.  The error_function will
-        // be fired if the triggering tid is unknown at the time of execution.
-        // This variant will send stop requests to all non-stopped threads except
-        // for any contained in skip_stop_request_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 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 for any contained in skip_stop_request_tids.
         void
-        CallAfterRunningThreadsStopWithSkipTIDs (lldb::tid_t triggering_tid,
+        StopRunningThreadsWithSkipTID(lldb::tid_t triggering_tid,
                                                  const ThreadIDSet &skip_stop_request_tids,
                                                  const StopThreadFunction &request_thread_stop_function,
-                                                 const ThreadIDFunction &call_after_function,
                                                  const ErrorFunction &error_function);
 
         // Notify the thread stopped.  Will trigger error at time of execution if we
         // already think it is stopped.
         void
         NotifyThreadStop (lldb::tid_t tid,
                           bool initiated_by_llgs,
                           const ErrorFunction &error_function);
private:
         };
         typedef std::unordered_map<lldb::tid_t, ThreadContext> TIDContextMap;
 
         struct PendingNotification
         {
             PendingNotification (lldb::tid_t triggering_tid,
                                        const ThreadIDSet &wait_for_stop_tids,
                                        const StopThreadFunction &request_thread_stop_function,
-                                       const ThreadIDFunction &call_after_function,
                                        const ErrorFunction &error_function):
             triggering_tid (triggering_tid),
             wait_for_stop_tids (wait_for_stop_tids),
             original_wait_for_stop_tids (wait_for_stop_tids),
             request_thread_stop_function (request_thread_stop_function),
-            call_after_function (call_after_function),
             error_function (error_function),
             request_stop_on_all_unstopped_threads (false),
             skip_stop_request_tids ()
             {
             }
 
             PendingNotification (lldb::tid_t triggering_tid,
                                        const StopThreadFunction &request_thread_stop_function,
-                                       const ThreadIDFunction &call_after_function,
                                        const ErrorFunction &error_function) :
             triggering_tid (triggering_tid),
             wait_for_stop_tids (),
             original_wait_for_stop_tids (),
             request_thread_stop_function (request_thread_stop_function),
-            call_after_function (call_after_function),
             error_function (error_function),
             request_stop_on_all_unstopped_threads (true),
             skip_stop_request_tids ()
             {
             }
 
             PendingNotification (lldb::tid_t triggering_tid,
                                        const StopThreadFunction &request_thread_stop_function,
-                                       const ThreadIDFunction &call_after_function,
                                        const ThreadIDSet &skip_stop_request_tids,
                                        const ErrorFunction &error_function) :
             triggering_tid (triggering_tid),
             wait_for_stop_tids (),
             original_wait_for_stop_tids (),
             request_thread_stop_function (request_thread_stop_function),
-            call_after_function (call_after_function),
             error_function (error_function),
             request_stop_on_all_unstopped_threads (true),
             skip_stop_request_tids (skip_stop_request_tids)
             {
             }
 
             const lldb::tid_t  triggering_tid;
             ThreadIDSet        wait_for_stop_tids;
             const ThreadIDSet  original_wait_for_stop_tids;
             StopThreadFunction request_thread_stop_function;
-            ThreadIDFunction   call_after_function;
             ErrorFunction      error_function;
             const bool         request_stop_on_all_unstopped_threads;
             ThreadIDSet        skip_stop_request_tids;
         };
         typedef std::unique_ptr<PendingNotification> PendingNotificationUP;
 
         // Fire pending notification if no pending thread stops remain.
         void SignalIfRequirementsSatisfied();
private:
         void
         ThreadDidStop (lldb::tid_t tid, bool initiated_by_llgs, const ErrorFunction &error_function);
 
         void
         DoResume(lldb::tid_t tid, ResumeThreadFunction request_thread_resume_function,
                 ErrorFunction error_function, bool error_when_already_running);
 
         void
-        DoCallAfterThreadsStop(PendingNotificationUP &&notification_up);
+        DoStopThreads(PendingNotificationUP &&notification_up);
 
         void
         ThreadWasCreated (lldb::tid_t tid, bool is_stopped, const ErrorFunction &error_function);
 
         void
         ThreadDidDie (lldb::tid_t tid, const ErrorFunction &error_function);
 
         bool

lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.cpp

case (SIGTRAP | (PTRACE_EVENT_EXEC << 8)):
         // 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.
-        CallAfterRunningThreadsStop (pid,
-                                     [=] (lldb::tid_t signaling_tid)
-                                     {
-                                         SetState (StateType::eStateStopped, true);
-                                     });
+        StopRunningThreads (pid);
 
         break;
     }
 
     case (SIGTRAP | (PTRACE_EVENT_EXIT << 8)):
     {
         // The inferior process or one of its threads is about to exit.
 
NativeProcessLinux::MonitorTrace(lldb::pid_t pid, NativeThreadProtocolSP thread_sp)
     NotifyThreadStop(pid);
 
     // 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).
-    CallAfterRunningThreadsStop(pid,
-                                [=](lldb::tid_t signaling_tid)
-                                {
-                                   SetState(StateType::eStateStopped, true);
-                                });
+    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,
NativeProcessLinux::MonitorBreakpoint(lldb::pid_t pid, NativeThreadProtocolSP thread_sp)
     else
         if (log)
             log->Printf("NativeProcessLinux::%s()  pid = %" PRIu64 ": "
                     "warning, cannot process software breakpoint since no thread metadata",
                     __FUNCTION__, pid);
 
 
     // We need to tell all other running threads before we notify the delegate about this stop.
-    CallAfterRunningThreadsStop(pid,
-                                [=](lldb::tid_t deferred_notification_tid)
-                                {
-                                    SetCurrentThreadID(deferred_notification_tid);
-                                    // Tell the process we have a stop (from software breakpoint).
-                                    SetState(StateType::eStateStopped, true);
-                                });
+    StopRunningThreads(pid);
 }
 
 void
 NativeProcessLinux::MonitorWatchpoint(lldb::pid_t pid, NativeThreadProtocolSP thread_sp, uint32_t wp_index)
 {
     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);
 
     // 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.
-    CallAfterRunningThreadsStop(pid,
-                                [=](lldb::tid_t deferred_notification_tid)
-                                {
-                                    SetCurrentThreadID(deferred_notification_tid);
-                                    // Tell the process we have a stop (from watchpoint).
-                                    SetState(StateType::eStateStopped, true);
-                                });
+    StopRunningThreads(pid);
 }
 
 void
 NativeProcessLinux::MonitorSignal(const siginfo_t *info, lldb::pid_t pid, bool exited)
 {
     assert (info && "null info");
     if (!info)
         return;
if (is_from_llgs && (info->si_code == SI_TKILL) && (signo == SIGSTOP))
             // that we are missing the marking of a run state somewhere if we find that the thread was
             // marked as stopped.
             std::shared_ptr<NativeThreadLinux> linux_thread_sp = std::static_pointer_cast<NativeThreadLinux> (thread_sp);
             assert (linux_thread_sp && "linux_thread_sp is null!");
 
             const StateType thread_state = linux_thread_sp->GetState ();
             if (!StateIsStoppedState (thread_state, false))
             {
-                // An inferior thread just stopped, but was not the primary cause of the process stop.
-                // Instead, something else (like a breakpoint or step) caused the stop.  Mark the
-                // stop signal as 0 to let lldb know this isn't the important stop.
-                linux_thread_sp->SetStoppedBySignal (0);
+                // An inferior thread has stopped because of a SIGSTOP we have sent it.
+                // Generally, these are not important stops and we don't want to report them as
+                // they are just used to stop other threads when one thread (the one with the
+                // *real* stop reason) hits a breakpoint (watchpoint, etc...). However, in the
+                // case of an asynchronous Interrupt(), this *is* the real stop reason, so we
+                // 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, CoordinatorErrorHandler);
             }
             else
             {
                 if (log)
                 {
                     // Retrieve the signal name if the thread was stopped by a signal.
default:
         // This is just a pre-signal-delivery notification of the incoming signal.
         if (thread_sp)
             std::static_pointer_cast<NativeThreadLinux> (thread_sp)->SetStoppedBySignal (signo);
 
         break;
     }
 
     // Send a stop to the debugger after we get all other threads to stop.
-    CallAfterRunningThreadsStop (pid,
-                                 [=] (lldb::tid_t signaling_tid)
-                                 {
-                                     SetCurrentThreadID (signaling_tid);
-                                     SetState (StateType::eStateStopped, true);
-                                 });
+    StopRunningThreads (pid);
 }
 
 namespace {
 
 struct EmulatorBaton
 {
     NativeProcessLinux* m_process;
     NativeRegisterContext* m_reg_context;
for (auto thread_sp : m_threads)
                     __FUNCTION__, StateAsCString (action->state), GetID (), thread_sp->GetID ());
         }
     }
 
     // If we had any thread stopping, then do a deferred notification of the chosen stop thread id and signal
     // after all other running threads have stopped.
     // If there is a stepping thread involved we'll be eventually stopped by SIGTRAP trace signal.
     if (deferred_signal_tid != LLDB_INVALID_THREAD_ID && !stepping)
-    {
-        CallAfterRunningThreadsStopWithSkipTID (deferred_signal_tid,
-                                                deferred_signal_skip_tid,
-                                     [=](lldb::tid_t deferred_notification_tid)
-                                     {
-                                         // Set the signal thread to the current thread.
-                                         SetCurrentThreadID (deferred_notification_tid);
-
-                                         // Set the thread state as stopped by the deferred signo.
-                                         std::static_pointer_cast<NativeThreadLinux> (deferred_signal_thread_sp)->SetStoppedBySignal (deferred_signo);
-
-                                         // Tell the process delegate that the process is in a stopped state.
-                                         SetState (StateType::eStateStopped, true);
-                                     });
-    }
+        StopRunningThreadsWithSkipTID(deferred_signal_tid, deferred_signal_skip_tid);
 
     return Error();
 }
 
 Error
 NativeProcessLinux::Halt ()
 {
     Error error;
NativeProcessLinux::Interrupt ()
 
     if (log)
         log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " %s tid %" PRIu64 " chosen for interrupt target",
                      __FUNCTION__,
                      GetID (),
                      running_thread_sp ? "running" : "stopped",
                      deferred_signal_thread_sp->GetID ());
 
-    CallAfterRunningThreadsStop (deferred_signal_thread_sp->GetID (),
-                                 [=](lldb::tid_t deferred_notification_tid)
-                                 {
-                                     // Set the signal thread to the current thread.
-                                     SetCurrentThreadID (deferred_notification_tid);
-
-                                     // Set the thread state as stopped by the deferred signo.
-                                     std::static_pointer_cast<NativeThreadLinux> (deferred_signal_thread_sp)->SetStoppedBySignal (SIGSTOP);
-
-                                     // Tell the process delegate that the process is in a stopped state.
-                                     SetState (StateType::eStateStopped, true);
-                                 });
+    StopRunningThreads(deferred_signal_thread_sp->GetID());
 
     return Error();
 }
 
 Error
 NativeProcessLinux::Kill ()
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));

 
 void
 NativeProcessLinux::NotifyThreadStop (lldb::tid_t tid)
 {
     NotifyThreadStop (tid, false, CoordinatorErrorHandler);
 }
 
 void
-NativeProcessLinux::CallAfterRunningThreadsStop (lldb::tid_t tid,
-                                                 const std::function<void (lldb::tid_t tid)> &call_after_function)
+NativeProcessLinux::StopRunningThreads(lldb::tid_t trigerring_tid)
 {
     Log *const log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD));
     if (log)
-        log->Printf("NativeProcessLinux::%s tid %" PRIu64, __FUNCTION__, tid);
+        log->Printf("NativeProcessLinux::%s tid %" PRIu64, __FUNCTION__, trigerring_tid);
 
     const lldb::pid_t pid = GetID ();
-    CallAfterRunningThreadsStop (tid,
-                                                   [=](lldb::tid_t request_stop_tid)
-                                                   {
-                                                       return RequestThreadStop(pid, request_stop_tid);
-                                                   },
-                                                   call_after_function,
-                                                   CoordinatorErrorHandler);
+    StopRunningThreads(trigerring_tid,
+            [=](lldb::tid_t request_stop_tid) { return RequestThreadStop(pid, request_stop_tid); },
 }
 
 void
-NativeProcessLinux::CallAfterRunningThreadsStopWithSkipTID (lldb::tid_t deferred_signal_tid,
-                                                            lldb::tid_t skip_stop_request_tid,
-                                                            const std::function<void (lldb::tid_t tid)> &call_after_function)
+NativeProcessLinux::StopRunningThreadsWithSkipTID(lldb::tid_t deferred_signal_tid,
+                                                  lldb::tid_t skip_stop_request_tid)
 {
     Log *const log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD));
     if (log)
         log->Printf("NativeProcessLinux::%s deferred_signal_tid %" PRIu64 ", skip_stop_request_tid %" PRIu64, __FUNCTION__, deferred_signal_tid, skip_stop_request_tid);
 
     const lldb::pid_t pid = GetID ();
-    CallAfterRunningThreadsStopWithSkipTIDs (deferred_signal_tid,
+    StopRunningThreadsWithSkipTID(deferred_signal_tid,
             skip_stop_request_tid != LLDB_INVALID_THREAD_ID ? NativeProcessLinux::ThreadIDSet {skip_stop_request_tid} : NativeProcessLinux::ThreadIDSet (),
             [=](lldb::tid_t request_stop_tid) { return RequestThreadStop(pid, request_stop_tid); },
-            call_after_function,
             CoordinatorErrorHandler);
 }
 
 Error
 NativeProcessLinux::RequestThreadStop (const lldb::pid_t pid, const lldb::tid_t tid)
 {
     Log* log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD));
     if (log)
NativeProcessLinux::DoResume(
     }
 
     return;
 }
 
 //===----------------------------------------------------------------------===//
 
 void
-NativeProcessLinux::CallAfterThreadsStop (const lldb::tid_t triggering_tid,
+NativeProcessLinux::StopThreads(const lldb::tid_t triggering_tid,
                                               const ThreadIDSet &wait_for_stop_tids,
                                               const StopThreadFunction &request_thread_stop_function,
-                                              const ThreadIDFunction &call_after_function,
                                               const ErrorFunction &error_function)
 {
     std::lock_guard<std::mutex> lock(m_event_mutex);
 
     if (m_log_event_processing)
     {
         TSCLog ("NativeProcessLinux::%s about to process event: (triggering_tid: %" PRIu64 ", wait_for_stop_tids.size(): %zd)",
                 __FUNCTION__, triggering_tid, wait_for_stop_tids.size());
     }
 
-    DoCallAfterThreadsStop(PendingNotificationUP(new PendingNotification(
-                triggering_tid, wait_for_stop_tids, request_thread_stop_function,
-                call_after_function, error_function)));
+    DoStopThreads(PendingNotificationUP(new PendingNotification(
+                triggering_tid, wait_for_stop_tids, request_thread_stop_function, error_function)));
 
     if (m_log_event_processing)
     {
         TSCLog ("NativeProcessLinux::%s event processing done", __FUNCTION__);
     }
 }
 
 void
-NativeProcessLinux::CallAfterRunningThreadsStop (const lldb::tid_t triggering_tid,
+NativeProcessLinux::StopRunningThreads(const lldb::tid_t triggering_tid,
                                                      const StopThreadFunction &request_thread_stop_function,
-                                                     const ThreadIDFunction &call_after_function,
                                                      const ErrorFunction &error_function)
 {
     std::lock_guard<std::mutex> lock(m_event_mutex);
 
     if (m_log_event_processing)
     {
         TSCLog ("NativeProcessLinux::%s about to process event: (triggering_tid: %" PRIu64 ")",
                 __FUNCTION__, triggering_tid);
     }
 
-    DoCallAfterThreadsStop(PendingNotificationUP(new PendingNotification(
+    DoStopThreads(PendingNotificationUP(new PendingNotification(
                 triggering_tid,
                 request_thread_stop_function,
-                call_after_function,
                 error_function)));
 
     if (m_log_event_processing)
     {
         TSCLog ("NativeProcessLinux::%s event processing done", __FUNCTION__);
     }
 }
 
 void
-NativeProcessLinux::CallAfterRunningThreadsStopWithSkipTIDs (lldb::tid_t triggering_tid,
+NativeProcessLinux::StopRunningThreadsWithSkipTID(lldb::tid_t triggering_tid,
                                                                  const ThreadIDSet &skip_stop_request_tids,
                                                                  const StopThreadFunction &request_thread_stop_function,
-                                                                 const ThreadIDFunction &call_after_function,
                                                                  const ErrorFunction &error_function)
 {
     std::lock_guard<std::mutex> lock(m_event_mutex);
 
     if (m_log_event_processing)
     {
         TSCLog ("NativeProcessLinux::%s about to process event: (triggering_tid: %" PRIu64 ", skip_stop_request_tids.size(): %zd)",
                 __FUNCTION__, triggering_tid, skip_stop_request_tids.size());
     }
 
-    DoCallAfterThreadsStop(PendingNotificationUP(new PendingNotification(
+    DoStopThreads(PendingNotificationUP(new PendingNotification(
                 triggering_tid,
                 request_thread_stop_function,
-                call_after_function,
                 skip_stop_request_tids,
                 error_function)));
 
     if (m_log_event_processing)
     {
         TSCLog ("NativeProcessLinux::%s event processing done", __FUNCTION__);
     }
 }
 
 void
 NativeProcessLinux::SignalIfRequirementsSatisfied()
 {
     if (m_pending_notification_up && m_pending_notification_up->wait_for_stop_tids.empty ())
     {
-        m_pending_notification_up->call_after_function(m_pending_notification_up->triggering_tid);
+        SetCurrentThreadID(m_pending_notification_up->triggering_tid);
+        SetState(StateType::eStateStopped, true);
         m_pending_notification_up.reset();
     }
 }
 
 bool
 NativeProcessLinux::RequestStopOnAllSpecifiedThreads()
 {
     // Request a stop for all the thread stops that need to be stopped
if (initiated_by_llgs && context.m_request_resume_function && !stop_was_requested)
         {
             TSCLog ("NativeProcessLinux::%s failed to resume thread tid  %" PRIu64 ": %s",
                  __FUNCTION__, tid, error.AsCString ());
         }
     }
 }
 
 void
-NativeProcessLinux::DoCallAfterThreadsStop(PendingNotificationUP &&notification_up)
+NativeProcessLinux::DoStopThreads(PendingNotificationUP &&notification_up)
 {
     // Validate we know about the deferred trigger thread.
     if (!IsKnownThread (notification_up->triggering_tid))
     {
         // We don't know about this thread.  This is an error condition.
         std::ostringstream error_message;
         error_message << "error: deferred notification tid " << notification_up->triggering_tid << " is unknown";
         notification_up->error_function (error_message.str ());
NativeProcessLinux::DoStopThreads(PendingNotificationUP &&notification_up)
     if (m_pending_notification_up->request_stop_on_all_unstopped_threads)
         RequestStopOnAllRunningThreads();
     else
     {
         if (!RequestStopOnAllSpecifiedThreads())
             return;
     }
 
-    if (m_pending_notification_up->wait_for_stop_tids.empty ())
-    {
-        // We're not waiting for any threads.  Fire off the deferred signal delivery event.
-        m_pending_notification_up->call_after_function(m_pending_notification_up->triggering_tid);
-        m_pending_notification_up.reset();
-    }
+    SignalIfRequirementsSatisfied();
 }
 
 void
 NativeProcessLinux::ThreadWasCreated (lldb::tid_t tid, bool is_stopped, const ErrorFunction &error_function)
 {
     // Ensure we don't already know about the thread.
     auto find_it = m_tid_map.find (tid);
     if (find_it != m_tid_map.end ())