[NativeProcessLinux] Remove logging and error callbacks

[labath]

Summary

These are remnants of the thread state coordinator, which are now unnecessary. I have basically
inlined the callbacks. No functional change.

PS: This is logically independent on D9321, but should be applied on top of it. Otherwise,
trivial but annoing merge errors may occur.

[vharron]

I have ran dosep.py (-A i386 -A x86_64 -C gcc -C clang-3.5 -C clang-tot) about 20 times. The results improved. I'm running another 80 times to get more resolution.

[chaoren]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

4265

I know it's probably going to be a pain in the ass, but could you make all of these return Error (and propagate them?) since you're getting rid of the error_function?

4274–4275

Please use lldb_assert (#include "lldb/Utility/LLDBAssert.h") instead. Stack traces! This specific case would probably go back to returning Error though.

[labath]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

4265

I've propagated these errors up to the Monitor*** functions and similar. There, they get ignored. I'm not really sure what we can do with these (hypthetical?) errors. Right now, the only thing that can generate an Error here is if the PTRACE_CONT call fails. If this happens, then we either have a kernel bug or lldb bug. In any case, the best we can do is log it (which was already done in ResumeOperation) and cross our fingers.

4274–4275

Changed to lldb_assert. I think this condition is serious enough to warrant a hard failure. This signifies a discrepancy between the thread list maintained by NPL and the one by the (almost-dead) TSC. It is definitely a programming error, and an attempt to continue beyond this will very likely fail at a later point, where it could be more difficult to diagnose the problem (or worse, we could actually continue, but introduce subtle errors). Asserts like these (the original error function also asserted) have helped me find the original waitpid<->ptrace race.

In any case, I am already preparing a change to remove this double accounting of threads, so these asserts will go away then.

[labath]

Address review comments. Please take another look.

[chaoren]

LGTM.

source/Plugins/Process/Linux/NativeProcessLinux.h

#endif
 
         void
         NotifyThreadCreateRunning (lldb::tid_t tid);
 
         void
         NotifyThreadDeath (lldb::tid_t tid);
 
         void
-        NotifyThreadStop (lldb::tid_t tid);
-
-        void
         StopRunningThreads (lldb::tid_t triggering_tid);
 
         void
         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 (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);
+        NotifyThreadCreate(lldb::tid_t tid, bool is_stopped);
 
 
         // 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,
-                              const StopThreadFunction &request_thread_stop_function,
-                              const ErrorFunction &error_function);
+                              const StopThreadFunction &request_thread_stop_function);
 
         // 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
         StopRunningThreads(lldb::tid_t triggering_tid,
-                                     const StopThreadFunction &request_thread_stop_function,
-                                     const ErrorFunction &error_function);
+                                     const StopThreadFunction &request_thread_stop_function);
 
         // 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
         StopRunningThreadsWithSkipTID(lldb::tid_t triggering_tid,
                                                  const ThreadIDSet &skip_stop_request_tids,
-                                                 const StopThreadFunction &request_thread_stop_function,
-                                                 const ErrorFunction &error_function);
+                                                 const StopThreadFunction &request_thread_stop_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);
+        Error
+        NotifyThreadStop(lldb::tid_t tid, bool initiated_by_llgs);
 
         // Request that the given thread id should have the request_thread_resume_function
-        // called.  Will trigger the error_function if the thread is thought to be running
-        // already at that point.  This call signals an error if the thread resume is for
+        // called. This call signals an error if the thread resume is for
         // a thread that is already in a running state.
-        void
+        Error
         RequestThreadResume (lldb::tid_t tid,
-                             const ResumeThreadFunction &request_thread_resume_function,
-                             const ErrorFunction &error_function);
+                             const ResumeThreadFunction &request_thread_resume_function);
 
         // Request that the given thread id should have the request_thread_resume_function
-        // called.  Will trigger the error_function if the thread is thought to be running
-        // already at that point.  This call ignores threads that are already running and
+        // called. This call ignores threads that are already running and
         // does not trigger an error in that case.
-        void
+        Error
         RequestThreadResumeAsNeeded (lldb::tid_t tid,
-                                     const ResumeThreadFunction &request_thread_resume_function,
-                                     const ErrorFunction &error_function);
+                                     const ResumeThreadFunction &request_thread_resume_function);
 
         // Indicate the calling process did an exec and that the thread state
         // should be 100% cleared.
         void
         ResetForExec ();
 
-        // Enable/disable verbose logging of event processing.
-        void
-        LogEnableEventProcessing (bool enabled);
-
     private:
 
         enum class ThreadState
         {
             Running,
             Stopped
         };
 
         struct ThreadContext
         {
             ThreadState m_state;
             bool m_stop_requested = false;
             ResumeThreadFunction m_request_resume_function;
         };
         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 ErrorFunction &error_function):
+                                       const StopThreadFunction &request_thread_stop_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),
-            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 ErrorFunction &error_function) :
+                                       const StopThreadFunction &request_thread_stop_function):
             triggering_tid (triggering_tid),
             wait_for_stop_tids (),
             original_wait_for_stop_tids (),
             request_thread_stop_function (request_thread_stop_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 ThreadIDSet &skip_stop_request_tids,
-                                       const ErrorFunction &error_function) :
+                                       const ThreadIDSet &skip_stop_request_tids):
             triggering_tid (triggering_tid),
             wait_for_stop_tids (),
             original_wait_for_stop_tids (),
             request_thread_stop_function (request_thread_stop_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;
-            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();
 
         bool
         RequestStopOnAllSpecifiedThreads();
 
         void
         RequestStopOnAllRunningThreads();
 
         void
         RequestThreadStop (lldb::tid_t tid, ThreadContext& context);
 
         std::mutex m_event_mutex; // Serializes execution of ProcessEvent. XXX
 
-        void
-        ThreadDidStop (lldb::tid_t tid, bool initiated_by_llgs, const ErrorFunction &error_function);
+        Error
+        ThreadDidStop(lldb::tid_t tid, bool initiated_by_llgs);
 
-        void
+        Error
         DoResume(lldb::tid_t tid, ResumeThreadFunction request_thread_resume_function,
-                ErrorFunction error_function, bool error_when_already_running);
+                bool error_when_already_running);
 
         void
         DoStopThreads(PendingNotificationUP &&notification_up);
 
         void
-        ThreadWasCreated (lldb::tid_t tid, bool is_stopped, const ErrorFunction &error_function);
+        ThreadWasCreated (lldb::tid_t tid, bool is_stopped);
 
         void
-        ThreadDidDie (lldb::tid_t tid, const ErrorFunction &error_function);
+        ThreadDidDie (lldb::tid_t tid);
 
         bool
         IsKnownThread(lldb::tid_t tid) const;
 
-        void
-        TSCLog (const char *format, ...);
-
         // Member variables.
-        LogFunction m_log_function;
         PendingNotificationUP m_pending_notification_up;
 
         // Maps known TIDs to ThreadContext.
         TIDContextMap m_tid_map;
-
-        bool m_log_event_processing;
     };
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeProcessLinux_H_

source/Plugins/Process/Linux/NativeProcessLinux.cpp

 {
     const UnixSignals&
     GetUnixSignals ()
     {
         static process_linux::LinuxSignals signals;
         return signals;
     }
 
-    NativeProcessLinux::LogFunction
-    GetThreadLoggerFunction ()
-    {
-        return [](const char *format, va_list args)
-        {
-            Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
-            if (log)
-                log->VAPrintf (format, args);
-        };
-    }
-
-    void
-    CoordinatorErrorHandler (const std::string &error_message)
-    {
-        Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
-        if (log)
-            log->Printf ("NativeProcessLinux::%s %s", __FUNCTION__, error_message.c_str ());
-        assert (false && "NativeProcessLinux error reported");
-    }
-
     Error
     ResolveProcessArchitecture (lldb::pid_t pid, Platform &platform, ArchSpec &arch)
     {
         // Grab process info for the running process.
         ProcessInstanceInfo process_info;
         if (!platform.GetProcessInfo (pid, process_info))
             return Error("failed to get process info");
 

 // -----------------------------------------------------------------------------
 
 NativeProcessLinux::NativeProcessLinux () :
     NativeProcessProtocol (LLDB_INVALID_PROCESS_ID),
     m_arch (),
     m_supports_mem_region (eLazyBoolCalculate),
     m_mem_region_cache (),
     m_mem_region_cache_mutex (),
-    m_log_function (GetThreadLoggerFunction()),
-    m_tid_map (),
-    m_log_event_processing (false)
+    m_tid_map ()
 {
 }
 
 //------------------------------------------------------------------------------
 // NativeProcessLinux spawns a new thread which performs all operations on the inferior process.
 // Refer to Monitor and Operation classes to see why this is necessary.
 //------------------------------------------------------------------------------
 void
NativeProcessLinux::MonitorCallback(lldb::pid_t pid,
     }
     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);
+            NotifyThreadStop (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.
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, false, CoordinatorErrorHandler);
+    NotifyThreadCreate (tid, false);
 }
 
 void
 NativeProcessLinux::MonitorSIGTRAP(const siginfo_t *info, lldb::pid_t pid)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
     const bool is_main_thread = (pid == GetID ());
 
case (SIGTRAP | (PTRACE_EVENT_EXEC << 8)):
         break;
     }
 
     case (SIGTRAP | (PTRACE_EVENT_EXIT << 8)):
     {
         // The inferior process or one of its threads is about to exit.
 
         // This thread is currently stopped.  It's not actually dead yet, just about to be.
-        NotifyThreadStop (pid);
+        NotifyThreadStop (pid, false);
 
         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)",
case (SIGTRAP | (PTRACE_EVENT_EXIT << 8)):
         }
 
         const int signo = static_cast<int> (data);
         RequestThreadResume (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);
-                },
-                CoordinatorErrorHandler);
+                });
 
         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);
+        NotifyThreadStop (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,
                 [=](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);
-                },
-                CoordinatorErrorHandler);
+                });
         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);
+    NotifyThreadStop(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);
+    NotifyThreadStop(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);
+    NotifyThreadStop(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, false, CoordinatorErrorHandler);
+        NotifyThreadCreate (pid, false);
         // 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, CoordinatorErrorHandler);
+                NotifyThreadStop (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 ());
+                NotifyThreadStop (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);
+    NotifyThreadStop (pid, false);
 
     switch (signo)
     {
     case SIGSTOP:
         {
             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,
                     [=](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);
-                    },
-                    CoordinatorErrorHandler);
+                    });
         }
         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)
                     [=](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;
-                    },
-                    CoordinatorErrorHandler);
+                    });
             break;
         }
 
         case eStateStepping:
         {
             // Request the step.
             const int signo = action->signal;
             RequestThreadResume (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;
-                    },
-                    CoordinatorErrorHandler);
+                    });
             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::FixupBreakpointPCAsNeeded (NativeThreadProtocolSP &thread_sp)
 
     return error;
 }
 
 void
 NativeProcessLinux::NotifyThreadCreateStopped (lldb::tid_t tid)
 {
     const bool is_stopped = true;
-    NotifyThreadCreate (tid, is_stopped, CoordinatorErrorHandler);
-}
-
-void
-NativeProcessLinux::NotifyThreadDeath (lldb::tid_t tid)
-{
-    NotifyThreadDeath (tid, CoordinatorErrorHandler);
-}
-
-void
-NativeProcessLinux::NotifyThreadStop (lldb::tid_t tid)
-{
-    NotifyThreadStop (tid, false, CoordinatorErrorHandler);
+    NotifyThreadCreate (tid, is_stopped);
 }
 
 void
 NativeProcessLinux::StopRunningThreads(lldb::tid_t trigerring_tid)
 {
     Log *const log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD));
     if (log)
         log->Printf("NativeProcessLinux::%s tid %" PRIu64, __FUNCTION__, trigerring_tid);
 
     const lldb::pid_t pid = GetID ();
     StopRunningThreads(trigerring_tid,
-            [=](lldb::tid_t request_stop_tid) { return RequestThreadStop(pid, request_stop_tid); },
-            CoordinatorErrorHandler);
+            [=](lldb::tid_t request_stop_tid) { return RequestThreadStop(pid, request_stop_tid); });
 }
 
 void
 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 ();
     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); },
-            CoordinatorErrorHandler);
+            [=](lldb::tid_t request_stop_tid) { return RequestThreadStop(pid, request_stop_tid); });
 }
 
 Error
 NativeProcessLinux::RequestThreadStop (const lldb::pid_t pid, const lldb::tid_t tid)
 {
     Log* log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD));
     if (log)
         log->Printf ("NativeProcessLinux::%s requesting thread stop(pid: %" PRIu64 ", tid: %" PRIu64 ")", __FUNCTION__, pid, tid);
while (!maps_data.empty())
         }
     }
 
     file_spec.Clear();
     return Error("Module file (%s) not found in /proc/%" PRIu64 "/maps file!",
                  module_file_spec.GetFilename().AsCString(), GetID());
 }
 
-void
+Error
 NativeProcessLinux::DoResume(
         lldb::tid_t tid,
         ResumeThreadFunction request_thread_resume_function,
-        ErrorFunction error_function,
         bool error_when_already_running)
 {
-    // Ensure we know about the thread.
+    Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
+    
     auto find_it = m_tid_map.find (tid);
-    if (find_it == m_tid_map.end ())
-    {
-        // We don't know about this thread.  This is an error condition.
-        std::ostringstream error_message;
-        error_message << "error: tid " << tid << " asked to resume but tid is unknown";
-        error_function (error_message.str ());
-        return;
-    }
+    lldbassert(find_it != m_tid_map.end ()); // Ensure we know about the thread.
+
     auto& context = find_it->second;
     // Tell the thread to resume if we don't already think it is running.
     const bool is_stopped = context.m_state == ThreadState::Stopped;
+
+    lldbassert(!(error_when_already_running && !is_stopped));
+
     if (!is_stopped)
     {
         // It's not an error, just a log, if the error_when_already_running flag is not set.
         // This covers cases where, for instance, we're just trying to resume all threads
         // from the user side.
-        if (!error_when_already_running)
-        {
-            TSCLog ("NativeProcessLinux::%s tid %" PRIu64 " optional resume skipped since it is already running",
-                             __FUNCTION__,
-                             tid);
-        }
-        else
-        {
-            // Skip the resume call - we have tracked it to be running.  And we unconditionally
-            // expected to resume this thread.  Flag this as an error.
-            std::ostringstream error_message;
-            error_message << "error: tid " << tid << " asked to resume but we think it is already running";
-            error_function (error_message.str ());
-        }
-
-        // Error or not, we're done.
-        return;
+        if (log)
+            log->Printf("NativeProcessLinux::%s tid %" PRIu64 " optional resume skipped since it is already running",
+        return Error();
     }
 
     // Before we do the resume below, first check if we have a pending
     // stop notification this is currently or was previously waiting for
     // this thread to stop.  This is potentially a buggy situation since
     // we're ostensibly waiting for threads to stop before we send out the
     // pending notification, and here we are resuming one before we send
     // out the pending stop notification.
-    if (m_pending_notification_up)
+    if (m_pending_notification_up && log)
     {
         if (m_pending_notification_up->wait_for_stop_tids.count (tid) > 0)
         {
-            TSCLog ("NativeProcessLinux::%s about to resume tid %" PRIu64 " per explicit request but we have a pending stop notification (tid %" PRIu64 ") that is actively waiting for this thread to stop. Valid sequence of events?", __FUNCTION__, tid, m_pending_notification_up->triggering_tid);
+            log->Printf("NativeProcessLinux::%s about to resume tid %" PRIu64 " per explicit request but we have a pending stop notification (tid %" PRIu64 ") that is actively waiting for this thread to stop. Valid sequence of events?", __FUNCTION__, tid, m_pending_notification_up->triggering_tid);
         }
         else if (m_pending_notification_up->original_wait_for_stop_tids.count (tid) > 0)
         {
-            TSCLog ("NativeProcessLinux::%s about to resume tid %" PRIu64 " per explicit request but we have a pending stop notification (tid %" PRIu64 ") that hasn't fired yet and this is one of the threads we had been waiting on (and already marked satisfied for this tid). Valid sequence of events?", __FUNCTION__, tid, m_pending_notification_up->triggering_tid);
+            log->Printf("NativeProcessLinux::%s about to resume tid %" PRIu64 " per explicit request but we have a pending stop notification (tid %" PRIu64 ") that hasn't fired yet and this is one of the threads we had been waiting on (and already marked satisfied for this tid). Valid sequence of events?", __FUNCTION__, tid, m_pending_notification_up->triggering_tid);
             for (auto tid : m_pending_notification_up->wait_for_stop_tids)
             {
-                TSCLog ("NativeProcessLinux::%s tid %" PRIu64 " deferred stop notification still waiting on tid  %" PRIu64,
+                log->Printf("NativeProcessLinux::%s tid %" PRIu64 " deferred stop notification still waiting on tid  %" PRIu64,
                                  __FUNCTION__,
                                  m_pending_notification_up->triggering_tid,
                                  tid);
             }
         }
     }
 
     // Request a resume.  We expect this to be synchronous and the system
     // to reflect it is running after this completes.
     const auto error = request_thread_resume_function (tid, false);
     if (error.Success ())
     {
         // Now mark it is running.
         context.m_state = ThreadState::Running;
         context.m_request_resume_function = request_thread_resume_function;
     }
-    else
+    else if (log)
     {
-        TSCLog ("NativeProcessLinux::%s failed to resume thread tid  %" PRIu64 ": %s",
+        log->Printf("NativeProcessLinux::%s failed to resume thread tid  %" PRIu64 ": %s",
                          __FUNCTION__, tid, error.AsCString ());
     }
 
-    return;
+    return error;
 }
 
 //===----------------------------------------------------------------------===//
 
 void
 NativeProcessLinux::StopThreads(const lldb::tid_t triggering_tid,
                                               const ThreadIDSet &wait_for_stop_tids,
-                                              const StopThreadFunction &request_thread_stop_function,
-                                              const ErrorFunction &error_function)
+                                              const StopThreadFunction &request_thread_stop_function)
 {
+    Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
     std::lock_guard<std::mutex> lock(m_event_mutex);
 
-    if (m_log_event_processing)
+    if (log)
     {
-        TSCLog ("NativeProcessLinux::%s about to process event: (triggering_tid: %" PRIu64 ", wait_for_stop_tids.size(): %zd)",
+        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, request_thread_stop_function, error_function)));
+                triggering_tid, wait_for_stop_tids, request_thread_stop_function)));
 
-    if (m_log_event_processing)
+    if (log)
     {
-        TSCLog ("NativeProcessLinux::%s event processing done", __FUNCTION__);
+        log->Printf("NativeProcessLinux::%s event processing done", __FUNCTION__);
     }
 }
 
 void
 NativeProcessLinux::StopRunningThreads(const lldb::tid_t triggering_tid,
-                                                     const StopThreadFunction &request_thread_stop_function,
-                                                     const ErrorFunction &error_function)
+                                                     const StopThreadFunction &request_thread_stop_function)
 {
+    Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
     std::lock_guard<std::mutex> lock(m_event_mutex);
 
-    if (m_log_event_processing)
+    if (log)
     {
-        TSCLog ("NativeProcessLinux::%s about to process event: (triggering_tid: %" PRIu64 ")",
+        log->Printf("NativeProcessLinux::%s about to process event: (triggering_tid: %" PRIu64 ")",
                 __FUNCTION__, triggering_tid);
     }
 
     DoStopThreads(PendingNotificationUP(new PendingNotification(
                 triggering_tid,
-                request_thread_stop_function,
-                error_function)));
+                request_thread_stop_function)));
 
-    if (m_log_event_processing)
+    if (log)
     {
-        TSCLog ("NativeProcessLinux::%s event processing done", __FUNCTION__);
+        log->Printf("NativeProcessLinux::%s event processing done", __FUNCTION__);
     }
 }
 
 void
 NativeProcessLinux::StopRunningThreadsWithSkipTID(lldb::tid_t triggering_tid,
                                                                  const ThreadIDSet &skip_stop_request_tids,
-                                                                 const StopThreadFunction &request_thread_stop_function,
-                                                                 const ErrorFunction &error_function)
+                                                                 const StopThreadFunction &request_thread_stop_function)
 {
+    Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
     std::lock_guard<std::mutex> lock(m_event_mutex);
 
-    if (m_log_event_processing)
+    if (log)
     {
-        TSCLog ("NativeProcessLinux::%s about to process event: (triggering_tid: %" PRIu64 ", skip_stop_request_tids.size(): %zd)",
+        log->Printf("NativeProcessLinux::%s about to process event: (triggering_tid: %" PRIu64 ", skip_stop_request_tids.size(): %zd)",
                 __FUNCTION__, triggering_tid, skip_stop_request_tids.size());
     }
 
     DoStopThreads(PendingNotificationUP(new PendingNotification(
                 triggering_tid,
                 request_thread_stop_function,
-                skip_stop_request_tids,
-                error_function)));
+                skip_stop_request_tids)));
 
-    if (m_log_event_processing)
+    if (log)
     {
-        TSCLog ("NativeProcessLinux::%s event processing done", __FUNCTION__);
+        log->Printf("NativeProcessLinux::%s event processing done", __FUNCTION__);
     }
 }
 
 void
 NativeProcessLinux::SignalIfRequirementsSatisfied()
 {
     if (m_pending_notification_up && m_pending_notification_up->wait_for_stop_tids.empty ())
     {
NativeProcessLinux::RequestStopOnAllSpecifiedThreads()
     // threads from which we still need to hear a stop reply.
 
     ThreadIDSet sent_tids;
     for (auto tid : m_pending_notification_up->wait_for_stop_tids)
     {
         // Validate we know about all tids for which we must first receive a stop before
         // triggering the deferred stop notification.
         auto find_it = m_tid_map.find (tid);
-        if (find_it == m_tid_map.end ())
-        {
-            // This is an error.  We shouldn't be asking for waiting pids that aren't known.
-            // NOTE: we may be stripping out the specification of wait tids and handle this
-            // automatically, in which case this state can never occur.
-            std::ostringstream error_message;
-            error_message << "error: deferred notification for tid " << m_pending_notification_up->triggering_tid << " specified an unknown/untracked pending stop tid " << m_pending_notification_up->triggering_tid;
-            m_pending_notification_up->error_function (error_message.str ());
-
-            // Bail out here.
-            return false;
-        }
+        lldbassert(find_it != m_tid_map.end());
 
         // If the pending stop thread is currently running, we need to send it a stop request.
         auto& context = find_it->second;
         if (context.m_state == ThreadState::Running)
         {
             RequestThreadStop (tid, context);
             sent_tids.insert (tid);
         }

 void
 NativeProcessLinux::RequestThreadStop (lldb::tid_t tid, ThreadContext& context)
 {
     const auto error = m_pending_notification_up->request_thread_stop_function (tid);
     if (error.Success ())
         context.m_stop_requested = true;
     else
     {
-        TSCLog ("NativeProcessLinux::%s failed to request thread stop tid  %" PRIu64 ": %s",
+        Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
+        if (log)
+            log->Printf("NativeProcessLinux::%s failed to request thread stop tid  %" PRIu64 ": %s",
                          __FUNCTION__, tid, error.AsCString ());
     }
 }
 
 
-void
-NativeProcessLinux::ThreadDidStop (lldb::tid_t tid, bool initiated_by_llgs, const ErrorFunction &error_function)
+Error
+NativeProcessLinux::ThreadDidStop (lldb::tid_t tid, bool initiated_by_llgs)
 {
     // Ensure we know about the thread.
     auto find_it = m_tid_map.find (tid);
-    if (find_it == m_tid_map.end ())
-    {
-        // We don't know about this thread.  This is an error condition.
-        std::ostringstream error_message;
-        error_message << "error: tid " << tid << " asked to stop but tid is unknown";
-        error_function (error_message.str ());
-        return;
-    }
+    lldbassert(find_it != m_tid_map.end());
 
     // Update the global list of known thread states.  This one is definitely stopped.
     auto& context = find_it->second;
     const auto stop_was_requested = context.m_stop_requested;
     context.m_state = ThreadState::Stopped;
     context.m_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();
     }
 
     if (initiated_by_llgs && context.m_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.
-        TSCLog ("Resuming thread %"  PRIu64 " since stop wasn't requested", tid);
+        if (log)
+            log->Printf("Resuming thread %"  PRIu64 " since stop wasn't requested", tid);
         const auto error = context.m_request_resume_function (tid, true);
         if (error.Success ())
         {
             context.m_state = ThreadState::Running;
         }
         else
         {
-            TSCLog ("NativeProcessLinux::%s failed to resume thread tid  %" PRIu64 ": %s",
+            if (log)
+            {
+                log->Printf("NativeProcessLinux::%s failed to resume thread tid  %" PRIu64 ": %s",
                         __FUNCTION__, tid, error.AsCString ());
             }
+            return error;
+        }
     }
+    return Error();
 }
 
 void
 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 ());
-
-        // We bail out here.
-        return;
-    }
+    lldbassert(IsKnownThread (notification_up->triggering_tid));
 
-    if (m_pending_notification_up)
+    Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
+    if (m_pending_notification_up && log)
     {
         // Yikes - we've already got a pending signal notification in progress.
         // Log this info.  We lose the pending notification here.
-        TSCLog ("NativeProcessLinux::%s dropping existing pending signal notification for tid %" PRIu64 ", to be replaced with signal for tid %" PRIu64,
+        log->Printf("NativeProcessLinux::%s dropping existing pending signal notification for tid %" PRIu64 ", to be replaced with signal for tid %" PRIu64,
                    __FUNCTION__,
                    m_pending_notification_up->triggering_tid,
                    notification_up->triggering_tid);
     }
     m_pending_notification_up = std::move(notification_up);
 
     if (m_pending_notification_up->request_stop_on_all_unstopped_threads)
         RequestStopOnAllRunningThreads();
     else
     {
         if (!RequestStopOnAllSpecifiedThreads())
             return;
     }
 
     SignalIfRequirementsSatisfied();
 }
 
 void
-NativeProcessLinux::ThreadWasCreated (lldb::tid_t tid, bool is_stopped, const ErrorFunction &error_function)
+NativeProcessLinux::ThreadWasCreated (lldb::tid_t tid, bool is_stopped)
 {
     // Ensure we don't already know about the thread.
-    auto find_it = m_tid_map.find (tid);
-    if (find_it != m_tid_map.end ())
-    {
-        // We already know about this thread.  This is an error condition.
-        std::ostringstream error_message;
-        error_message << "error: notified tid " << tid << " created but we already know about this thread";
-        error_function (error_message.str ());
-        return;
-    }
+    lldbassert(m_tid_map.find(tid) == m_tid_map.end());
 
     // Add the new thread to the stop map.
     ThreadContext ctx;
     ctx.m_state = (is_stopped) ? ThreadState::Stopped : ThreadState::Running;
     m_tid_map[tid] = std::move(ctx);
 
     if (m_pending_notification_up && !is_stopped)
     {
         // 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);
         m_pending_notification_up->request_thread_stop_function(tid);
     }
 }
 
 void
-NativeProcessLinux::ThreadDidDie (lldb::tid_t tid, const ErrorFunction &error_function)
+NativeProcessLinux::ThreadDidDie (lldb::tid_t tid)
 {
     // Ensure we know about the thread.
     auto find_it = m_tid_map.find (tid);
-    if (find_it == m_tid_map.end ())
-    {
-        // We don't know about this thread.  This is an error condition.
-        std::ostringstream error_message;
-        error_message << "error: notified tid " << tid << " died but tid is unknown";
-        error_function (error_message.str ());
-        return;
-    }
+    lldbassert(find_it != m_tid_map.end());
 
     // Update the global list of known thread states.  While this one is stopped, it is also dead.
     // So stop tracking it.  We assume the user of this coordinator will not keep trying to add
     // dependencies on a thread after it is known to be dead.
     m_tid_map.erase (find_it);
 
     // 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();
     }
 }
 
-void
-NativeProcessLinux::TSCLog (const char *format, ...)
-{
-    va_list args;
-    va_start (args, format);
-
-    m_log_function (format, args);
-
-    va_end (args);
-}
-
-void
-NativeProcessLinux::NotifyThreadStop (lldb::tid_t tid,
-                                          bool initiated_by_llgs,
-                                          const ErrorFunction &error_function)
+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 (m_log_event_processing)
+    if (log)
     {
-        TSCLog ("NativeProcessLinux::%s about to process event: (tid: %" PRIu64 ", %sinitiated by llgs)",
+        log->Printf("NativeProcessLinux::%s about to process event: (tid: %" PRIu64 ", %sinitiated by llgs)",
                 __FUNCTION__, tid, initiated_by_llgs?"":"not ");
     }
 
-    ThreadDidStop (tid, initiated_by_llgs, error_function);
+    Error error = ThreadDidStop (tid, initiated_by_llgs);
 
-    if (m_log_event_processing)
+    if (log)
     {
-        TSCLog ("NativeProcessLinux::%s event processing done", __FUNCTION__);
+        log->Printf("NativeProcessLinux::%s event processing done", __FUNCTION__);
     }
+
+    return error;
 }
 
-void
+Error
 NativeProcessLinux::RequestThreadResume (lldb::tid_t tid,
-                                             const ResumeThreadFunction &request_thread_resume_function,
-                                             const ErrorFunction &error_function)
+                                         const ResumeThreadFunction &request_thread_resume_function)
 {
+    Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
     std::lock_guard<std::mutex> lock(m_event_mutex);
 
-    if (m_log_event_processing)
+    if (log)
     {
-        TSCLog ("NativeProcessLinux::%s about to process event: (tid: %" PRIu64 ")",
+        log->Printf("NativeProcessLinux::%s about to process event: (tid: %" PRIu64 ")",
                 __FUNCTION__, tid);
     }
 
-    DoResume(tid, request_thread_resume_function, error_function, true);
+    Error error = DoResume(tid, request_thread_resume_function, true);
 
-    if (m_log_event_processing)
+    if (log)
     {
-        TSCLog ("NativeProcessLinux::%s event processing done", __FUNCTION__);
+        log->Printf("NativeProcessLinux::%s event processing done", __FUNCTION__);
     }
+
+    return error;
 }
 
-void
+Error
 NativeProcessLinux::RequestThreadResumeAsNeeded (lldb::tid_t tid,
-                                                     const ResumeThreadFunction &request_thread_resume_function,
-                                                     const ErrorFunction &error_function)
+                                                     const ResumeThreadFunction &request_thread_resume_function)
 {
+    Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
     std::lock_guard<std::mutex> lock(m_event_mutex);
 
-    if (m_log_event_processing)
+    if (log)
     {
-        TSCLog ("NativeProcessLinux::%s about to process event: (tid: %" PRIu64 ")",
+        log->Printf("NativeProcessLinux::%s about to process event: (tid: %" PRIu64 ")",
                 __FUNCTION__, tid);
     }
 
-    DoResume (tid, request_thread_resume_function, error_function, false);
+    Error error = DoResume (tid, request_thread_resume_function, false);
 
-    if (m_log_event_processing)
+    if (log)
     {
-        TSCLog ("NativeProcessLinux::%s event processing done", __FUNCTION__);
+        log->Printf("NativeProcessLinux::%s event processing done", __FUNCTION__);
     }
+
+    return error;
 }
 
 void
 NativeProcessLinux::NotifyThreadCreate (lldb::tid_t tid,
-                                            bool is_stopped,
-                                            const ErrorFunction &error_function)
+                                            bool is_stopped)
 {
+    Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
     std::lock_guard<std::mutex> lock(m_event_mutex);
 
-    if (m_log_event_processing)
+    if (log)
     {
-        TSCLog ("NativeProcessLinux::%s about to process event: (tid: %" PRIu64 ", is %sstopped)",
+        log->Printf("NativeProcessLinux::%s about to process event: (tid: %" PRIu64 ", is %sstopped)",
                 __FUNCTION__, tid, is_stopped?"":"not ");
     }
 
-    ThreadWasCreated (tid, is_stopped, error_function);
+    ThreadWasCreated (tid, is_stopped);
 
-    if (m_log_event_processing)
+    if (log)
     {
-        TSCLog ("NativeProcessLinux::%s event processing done", __FUNCTION__);
+        log->Printf("NativeProcessLinux::%s event processing done", __FUNCTION__);
     }
 }
 
 void
-NativeProcessLinux::NotifyThreadDeath (lldb::tid_t tid,
-                                           const ErrorFunction &error_function)
+NativeProcessLinux::NotifyThreadDeath (lldb::tid_t tid)
 {
+    Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
     std::lock_guard<std::mutex> lock(m_event_mutex);
 
-    if (m_log_event_processing)
+    if (log)
     {
-        TSCLog ("NativeProcessLinux::%s about to process event: (tid: %" PRIu64 ")", __FUNCTION__, tid);
+        log->Printf("NativeProcessLinux::%s about to process event: (tid: %" PRIu64 ")", __FUNCTION__, tid);
     }
 
-    ThreadDidDie(tid, error_function);
+    ThreadDidDie(tid);
 
-    if (m_log_event_processing)
+    if (log)
     {
-        TSCLog ("NativeProcessLinux::%s event processing done", __FUNCTION__);
+        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 (m_log_event_processing)
+    if (log)
     {
-        TSCLog ("NativeProcessLinux::%s about to process event", __FUNCTION__);
+        log->Printf("NativeProcessLinux::%s about to process event", __FUNCTION__);
     }
 
     // Clear the pending notification if there was one.
     m_pending_notification_up.reset ();
 
     // Clear the stop map - we no longer know anything about any thread state.
     // The caller is expected to reset thread states for all threads, and we
     // will assume anything we haven't heard about is running and requires a
     // stop.
     m_tid_map.clear ();
 
-    if (m_log_event_processing)
+    if (log)
     {
-        TSCLog ("NativeProcessLinux::%s event processing done", __FUNCTION__);
-    }
+        log->Printf("NativeProcessLinux::%s event processing done", __FUNCTION__);
     }
-void
-NativeProcessLinux::LogEnableEventProcessing (bool enabled)
-{
-    m_log_event_processing = enabled;
 }
 
 bool
 NativeProcessLinux::IsKnownThread (lldb::tid_t tid) const
 {
     return m_tid_map.find (tid) != m_tid_map.end ();
 }