[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

4256

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?

4265

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

4256

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.

4265

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
         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;
 
         // 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 either 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);
+        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
         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
         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
         {
         public:
             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;
         };
 
         // 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);
+        ThreadDidStop(lldb::tid_t tid, bool initiated_by_llgs);
 
         void
         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(std::unique_ptr<PendingNotification> &&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;
         std::unique_ptr<PendingNotification> 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::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_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 (SIGTRAP | 0x80):
 
             
         // 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;
         
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);
case SIGSTOP:
             // 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);
+    NotifyThreadCreate (tid, is_stopped);
 }
 
 void
 NativeProcessLinux::NotifyThreadStop (lldb::tid_t tid)
 {
-    NotifyThreadStop (tid, false, CoordinatorErrorHandler);
+    NotifyThreadStop (tid, false);
 }
 
 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
 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;
-    }
+    assert(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;
+
+    assert(!(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.
+        if (log)
+            log->Printf("NativeProcessLinux::%s tid %" PRIu64 " optional resume skipped since it is already running",
         return;
     }
 
     // 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;
 }
 
 //===----------------------------------------------------------------------===//
 
 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(std::unique_ptr<PendingNotification>(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(std::unique_ptr<PendingNotification>(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(std::unique_ptr<PendingNotification>(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;
-        }
+        assert(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)
+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;
-    }
+    assert(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
+        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 ());
         }
     }
 }
 
 void
 NativeProcessLinux::DoStopThreads(std::unique_ptr<PendingNotification> &&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;
-    }
+    assert(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;
-    }
+    assert(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;
-    }
+    assert(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)
+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);
+    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__);
     }
 }
 
 void
 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);
+    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__);
     }
 }
 
 void
 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);
+    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__);
     }
 }
 
 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 ();
 }