[NativeProcessLinux] Remove double thread state accounting

[labath]

Summary

Now that all thread events are processed synchronously, there is no need to have separate records
of whether a thread is running. This changes the (ever-dwindling) remains of the TSC to use
NativeThreadLinux as the authoritative source of the state of threads. The rest of the
ThreadContext we need has been moved to a member of NTL.

[chaoren]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

4495

s/Stopped/Running/?

source/Plugins/Process/Linux/NativeThreadLinux.h

101

Why did you get rid of the m_ prefix?

[ovyalov]

Please see my comments.

source/Plugins/Process/Linux/NativeProcessLinux.cpp

2450

Could you add check for thread_sp != nullptr?

4414

Potentially, we may add NativeThreadProtocol::RequestStop() to implement this logic as a part of NativeThreadLinux.

4495

Previous version of code requested stop if thread's running (state == ThreadState::Running) - s/StateIsStoppedState/StateIsRunningState ?

4587

Do we still need this lock?

[labath]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

2450

I added a break two lines above. The fact that thread_sp is null is logged at the start if the function.

4414

I would add this signature to the base class only if/when we have a need to call it from the base NativeProcessProtocol. Right now this looks to me like a detail of this specific implementation of Native(Process/Thread)Protocol. A different implementation of these may wish to (or will need to) do this completely differently.

How about I put this to NTL::RequestStop? At some point I would like to get rid of all these NTL casts (perhaps by reimplementing NPL::GetThreadByID to cast in a single place), so this will become cleaner as well.

4495

You are right of course. I am puzzled at how this wasn't caught by the test suite though...

4587

No, but I'm saving that for another change. I will submit that shortly.

source/Plugins/Process/Linux/NativeThreadLinux.h

101

I was under the impression m_ is used for private members, or at least members of real classes (not just structs). I can put it back if you wish.

[labath]

Address review comments

[ovyalov]

Looks good.

source/Plugins/Process/Linux/NativeProcessLinux.h

 #include "lldb/Core/ArchSpec.h"
 #include "lldb/lldb-types.h"
 #include "lldb/Host/Debug.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 
 #include "lldb/Host/common/NativeProcessProtocol.h"
+#include "NativeThreadLinux.h"
 
 namespace lldb_private {
     class Error;
     class Module;
     class Scalar;
 
 namespace process_linux {
     /// @class NativeProcessLinux
#endif
         Error
         Resume(lldb::tid_t tid, uint32_t signo);
 
         /// Single steps the given thread.  If @p signo is anything but
         /// LLDB_INVALID_SIGNAL_NUMBER, deliver that signal to the thread.
         Error
         SingleStep(lldb::tid_t tid, uint32_t signo);
 
-        // ThreadStateCoordinator helper methods.
         void
         NotifyThreadDeath (lldb::tid_t tid);
 
         Error
         Detach(lldb::tid_t tid);
 
 
-    public:
         // Typedefs.
         typedef std::unordered_set<lldb::tid_t> ThreadIDSet;
 
-        // Callback/block definitions.
-        typedef std::function<Error (lldb::tid_t tid, bool supress_signal)> ResumeThreadFunction;
-
-    private:
-        enum class ThreadState
-        {
-            Running,
-            Stopped
-        };
-
-        // Notify that a thread is created and/or starting to be
-        // tracked. The state parameter should reflect whether the thread is created in a running
-        // or stopped state.
+        // Notify that a thread is created and/or starting to be tracked.
         void
-        NotifyThreadCreate(lldb::tid_t tid, ThreadState state);
+        NotifyThreadCreate(lldb::tid_t tid);
 
 
         // Notify the delegate after a given set of threads stops. The triggering_tid will be set
         // as the current thread. The error_function will be fired if either the triggering tid
         // or any of the wait_for_stop_tids are unknown.
         void
         StopThreads(lldb::tid_t triggering_tid, const ThreadIDSet &wait_for_stop_tids);
 
#endif
         Error
         NotifyThreadStop(lldb::tid_t tid, bool initiated_by_llgs);
 
         // Request that the given thread id should have the request_thread_resume_function
         // called. This call signals an error if the thread resume is for
         // a thread that is already in a running state.
         Error
         RequestThreadResume (lldb::tid_t tid,
-                             const ResumeThreadFunction &request_thread_resume_function);
+                             const NativeThreadLinux::ResumeThreadFunction &request_thread_resume_function);
 
         // Request that the given thread id should have the request_thread_resume_function
         // called. This call ignores threads that are already running and
         // does not trigger an error in that case.
         Error
         RequestThreadResumeAsNeeded (lldb::tid_t tid,
-                                     const ResumeThreadFunction &request_thread_resume_function);
+                                     const NativeThreadLinux::ResumeThreadFunction &request_thread_resume_function);
 
         // Indicate the calling process did an exec and that the thread state
         // should be 100% cleared.
         void
         ResetForExec ();
 
     private:
-
-        struct ThreadContext
-        {
-            ThreadState m_state;
-            bool m_stop_requested = false;
-            ResumeThreadFunction m_request_resume_function;
-
-            explicit ThreadContext(ThreadState state)
-                : m_state(state)
-            {}
-        };
-        typedef std::unordered_map<lldb::tid_t, ThreadContext> TIDContextMap;
-
         struct PendingNotification
         {
             PendingNotification (lldb::tid_t triggering_tid,
                                  const ThreadIDSet &wait_for_stop_tids,
                                  const ThreadIDSet &skip_stop_request_tids):
                 triggering_tid (triggering_tid),
                 wait_for_stop_tids (wait_for_stop_tids),
                 original_wait_for_stop_tids (wait_for_stop_tids),
private:
         void SignalIfRequirementsSatisfied();
 
         bool
         RequestStopOnAllSpecifiedThreads();
 
         void
         RequestStopOnAllRunningThreads();
 
-        Error
-        RequestThreadStop (lldb::tid_t tid, ThreadContext& context);
-
         std::mutex m_event_mutex; // Serializes execution of ProcessEvent. XXX
 
         Error
         ThreadDidStop(lldb::tid_t tid, bool initiated_by_llgs);
 
         Error
-        DoResume(lldb::tid_t tid, ResumeThreadFunction request_thread_resume_function,
+        DoResume(lldb::tid_t tid, NativeThreadLinux::ResumeThreadFunction request_thread_resume_function,
                 bool error_when_already_running);
 
         void
         DoStopThreads(PendingNotificationUP &&notification_up);
 
         void
-        ThreadWasCreated (lldb::tid_t tid, ThreadState state);
+        ThreadWasCreated (lldb::tid_t tid);
 
         void
         ThreadDidDie (lldb::tid_t tid);
 
-        bool
-        IsKnownThread(lldb::tid_t tid) const;
-
         // Member variables.
         PendingNotificationUP m_pending_notification_up;
-
-        // Maps known TIDs to ThreadContext.
-        TIDContextMap m_tid_map;
     };
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeProcessLinux_H_

source/Plugins/Process/Linux/NativeProcessLinux.cpp

 
 // System includes - They have to be included after framework includes because they define some
 // macros which collide with variable names in other modules
 #include <linux/unistd.h>
 #include <sys/personality.h>
 #include <sys/ptrace.h>
 #include <sys/socket.h>
 #include <sys/signalfd.h>
-#include <sys/syscall.h>
 #include <sys/types.h>
 #include <sys/uio.h>
 #include <sys/user.h>
 #include <sys/wait.h>
 
 #if defined (__arm64__) || defined (__aarch64__)
 // NT_PRSTATUS and NT_FPREGSET definition
 #include <elf.h>

 
 #define LLDB_PERSONALITY_GET_CURRENT_SETTINGS  0xffffffff
 
 // Support hardware breakpoints in case it has not been defined
 #ifndef TRAP_HWBKPT
   #define TRAP_HWBKPT 4
 #endif
 
-// Try to define a macro to encapsulate the tgkill syscall
-// fall back on kill() if tgkill isn't available
-#define tgkill(pid, tid, sig) \
-    syscall(SYS_tgkill, static_cast<::pid_t>(pid), static_cast<::pid_t>(tid), sig)
-
 // We disable the tracing of ptrace calls for integration builds to
 // avoid the additional indirection and checks.
 #ifndef LLDB_CONFIGURATION_BUILDANDINTEGRATION
 #define PTRACE(req, pid, addr, data, data_size, error) \
     PtraceWrapper((req), (pid), (addr), (data), (data_size), (error), #req, __FILE__, __LINE__)
 #else
 #define PTRACE(req, pid, addr, data, data_size, error) \
     PtraceWrapper((req), (pid), (addr), (data), (data_size), (error))

 // Public Instance Methods
 // -----------------------------------------------------------------------------
 
 NativeProcessLinux::NativeProcessLinux () :
     NativeProcessProtocol (LLDB_INVALID_PROCESS_ID),
     m_arch (),
     m_supports_mem_region (eLazyBoolCalculate),
     m_mem_region_cache (),
-    m_mem_region_cache_mutex (),
-    m_tid_map ()
+    m_mem_region_cache_mutex ()
 {
 }
 
 //------------------------------------------------------------------------------
 // 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
if (error.Fail())
         return -1;
     }
 
     if (log)
         log->Printf ("NativeProcessLinux::%s() adding pid = %" PRIu64, __FUNCTION__, pid);
 
     thread_sp = AddThread (pid);
     assert (thread_sp && "AddThread() returned a nullptr thread");
-    NotifyThreadCreate (pid, ThreadState::Stopped);
     std::static_pointer_cast<NativeThreadLinux> (thread_sp)->SetStoppedBySignal (SIGSTOP);
+    NotifyThreadCreate(pid);
 
     // Let our process instance know the thread has stopped.
     SetCurrentThreadID (thread_sp->GetID ());
     SetState (StateType::eStateStopped);
 
     if (log)
     {
         if (error.Success ())
while (Host::FindProcessThreads(pid, tids_to_attach))
 
                 it->second = true;
 
                 // Create the thread, mark it as stopped.
                 NativeThreadProtocolSP thread_sp (AddThread (static_cast<lldb::tid_t> (tid)));
                 assert (thread_sp && "AddThread() returned a nullptr");
 
                 // This will notify this is a new thread and tell the system it is stopped.
-                NotifyThreadCreate (tid, ThreadState::Stopped);
                 std::static_pointer_cast<NativeThreadLinux> (thread_sp)->SetStoppedBySignal (SIGSTOP);
+                NotifyThreadCreate(tid);
                 SetCurrentThreadID (thread_sp->GetID ());
             }
 
             // move the loop forward
             ++it;
         }
     }
 
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, ThreadState::Running);
+    NotifyThreadCreate(tid);
 }
 
 void
 NativeProcessLinux::MonitorSIGTRAP(const siginfo_t *info, lldb::pid_t pid)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
     const bool is_main_thread = (pid == GetID ());
 
case (SIGTRAP | (PTRACE_EVENT_EXEC << 8)):
         {
             SetCurrentThreadID (LLDB_INVALID_THREAD_ID);
             if (log)
                 log->Printf ("NativeProcessLinux::%s pid %" PRIu64 "no main thread found, discarded all threads, we're in a no-thread state!", __FUNCTION__, GetID ());
         }
 
         // Tell coordinator about about the "new" (since exec) stopped main thread.
         const lldb::tid_t main_thread_tid = GetID ();
-        NotifyThreadCreate (main_thread_tid, ThreadState::Stopped);
+        NotifyThreadCreate(main_thread_tid);
 
         // NOTE: ideally these next statements would execute at the same time as the coordinator thread create was executed.
         // Consider a handler that can execute when that happens.
         // Let our delegate know we have just exec'd.
         NotifyDidExec ();
 
         // If we have a main thread, indicate we are stopped.
         assert (main_thread_sp && "exec called during ptraced process but no main thread metadata tracked");
 
         // Let the process know we're stopped.
         StopRunningThreads (pid);
 
         break;
     }
 
     case (SIGTRAP | (PTRACE_EVENT_EXIT << 8)):
     {
         // The inferior process or one of its threads is about to exit.
+        if (! thread_sp)
+            break;
 
         // This thread is currently stopped.  It's not actually dead yet, just about to be.
         NotifyThreadStop (pid, false);
+        // The actual stop reason does not matter much, as we are going to resume the thread a
+        // few lines down. If we ever want to report this state to the debugger, then we should
+        // invent a new stop reason.
+        std::static_pointer_cast<NativeThreadLinux>(thread_sp)->SetStoppedBySignal(LLDB_INVALID_SIGNAL_NUMBER);
 
         unsigned long data = 0;
         if (GetEventMessage(pid, &data).Fail())
             data = -1;
 
         if (log)
         {
             log->Printf ("NativeProcessLinux::%s() received PTRACE_EVENT_EXIT, data = %lx (WIFEXITED=%s,WIFSIGNALED=%s), pid = %" PRIu64 " (%s)",
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, ThreadState::Running);
+        NotifyThreadCreate(pid);
         // Done handling.
         return;
     }
 
     // Check for thread stop notification.
     if (is_from_llgs && (info->si_code == SI_TKILL) && (signo == SIGSTOP))
     {
         // This is a tgkill()-based stop.
NativeProcessLinux::MonitorSignal(const siginfo_t *info, lldb::pid_t pid, bool exited)
 
     // This thread is stopped.
     NotifyThreadStop (pid, false);
 
     switch (signo)
     {
     case SIGSTOP:
         {
+            std::static_pointer_cast<NativeThreadLinux> (thread_sp)->SetStoppedBySignal (signo);
             if (log)
             {
                 if (is_from_llgs)
                     log->Printf ("NativeProcessLinux::%s pid = %" PRIu64 " tid %" PRIu64 " received SIGSTOP from llgs, most likely an interrupt", __FUNCTION__, GetID (), pid);
                 else
                     log->Printf ("NativeProcessLinux::%s pid = %" PRIu64 " tid %" PRIu64 " received SIGSTOP from outside of debugger", __FUNCTION__, GetID (), pid);
             }
 
NativeProcessLinux::GetLoadedModuleFileSpec(const char* module_path, FileSpec& file_spec)
     file_spec.Clear();
     return Error("Module file (%s) not found in /proc/%" PRIu64 "/maps file!",
                  module_file_spec.GetFilename().AsCString(), GetID());
 }
 
 Error
 NativeProcessLinux::DoResume(
         lldb::tid_t tid,
-        ResumeThreadFunction request_thread_resume_function,
+        NativeThreadLinux::ResumeThreadFunction request_thread_resume_function,
         bool error_when_already_running)
 {
     Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
     
-    auto find_it = m_tid_map.find (tid);
-    lldbassert(find_it != m_tid_map.end ()); // Ensure we know about the thread.
+    auto thread_sp = std::static_pointer_cast<NativeThreadLinux>(GetThreadByID(tid));
+    lldbassert(thread_sp != nullptr);
 
-    auto& context = find_it->second;
+    auto& context = thread_sp->GetThreadContext();
     // Tell the thread to resume if we don't already think it is running.
-    const bool is_stopped = context.m_state == ThreadState::Stopped;
+    const bool is_stopped = StateIsStoppedState(thread_sp->GetState(), true);
 
     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 (m_pending_notification_up && log)
                                  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;
-    }
+    if (error.Success())
+        context.request_resume_function = request_thread_resume_function;
     else if (log)
     {
         log->Printf("NativeProcessLinux::%s failed to resume thread tid  %" PRIu64 ": %s",
                          __FUNCTION__, tid, error.AsCString ());
     }
 
     return error;
 }
NativeProcessLinux::RequestStopOnAllSpecifiedThreads()
     // and are not already known to be stopped.  Keep a list of all the
     // 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);
-        lldbassert(find_it != m_tid_map.end());
+        auto thread_sp = std::static_pointer_cast<NativeThreadLinux>(GetThreadByID(tid));
+        lldbassert(thread_sp != nullptr);
 
         // 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)
+        if (StateIsRunningState(thread_sp->GetState()))
         {
-            RequestThreadStop (tid, context);
+            thread_sp->RequestStop();
             sent_tids.insert (tid);
         }
     }
     // We only need to wait for the sent_tids - so swap our wait set
     // to the sent tids.  The rest are already stopped and we won't
     // be receiving stop notifications for them.
     m_pending_notification_up->wait_for_stop_tids.swap (sent_tids);
 
     // Succeeded, keep running.
     return true;
 }
 
 void
 NativeProcessLinux::RequestStopOnAllRunningThreads()
 {
     // Request a stop for all the thread stops that need to be stopped
     // and are not already known to be stopped.  Keep a list of all the
     // threads from which we still need to hear a stop reply.
 
     ThreadIDSet sent_tids;
-    for (auto it = m_tid_map.begin(); it != m_tid_map.end(); ++it)
-    {
-        // We only care about threads not stopped.
-        const bool running = it->second.m_state == ThreadState::Running;
-        if (running)
-        {
-            const lldb::tid_t tid = it->first;
+    for (const auto &thread_sp: m_threads)
+        // We only care about running threads
+        if (StateIsStoppedState(thread_sp->GetState(), true))
+            continue;
+
+        const lldb::tid_t tid = thread_sp->GetID();
 
-            // Request this thread stop if the tid stop request is not explicitly ignored.
-            const bool skip_stop_request = m_pending_notification_up->skip_stop_request_tids.count (tid) > 0;
-            if (!skip_stop_request)
-                RequestThreadStop (tid, it->second);
+            static_pointer_cast<NativeThreadLinux>(thread_sp)->RequestStop();
 
-            // Even if we skipped sending the stop request for other reasons (like stepping),
-            // we still need to wait for that stepping thread to notify completion/stop.
-            sent_tids.insert (tid);
-        }
-    }
 
     // Set the wait list to the set of tids for which we requested stops.
     m_pending_notification_up->wait_for_stop_tids.swap (sent_tids);
 }
 
-Error
-NativeProcessLinux::RequestThreadStop (lldb::tid_t tid, ThreadContext& context)
-{
-    Log* log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD));
-
-    lldb::pid_t pid = GetID();
-
-    if (log)
-        log->Printf ("NativeProcessLinux::%s requesting thread stop(pid: %" PRIu64 ", tid: %" PRIu64 ")", __FUNCTION__, pid, tid);
-
-    Error err;
-    errno = 0;
-    if (::tgkill (pid, tid, SIGSTOP) != 0)
-    {
-        err.SetErrorToErrno ();
-        if (log)
-            log->Printf ("NativeProcessLinux::%s tgkill(%" PRIu64 ", %" PRIu64 ", SIGSTOP) failed: %s", __FUNCTION__, pid, tid, err.AsCString ());
-    }
-    else
-        context.m_stop_requested = true;
-
-    return err;
-}
-
 
 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);
-    lldbassert(find_it != m_tid_map.end());
+    auto thread_sp = std::static_pointer_cast<NativeThreadLinux>(GetThreadByID(tid));
+    lldbassert(thread_sp != nullptr);
 
     // Update the global list of known thread states.  This one is definitely stopped.
-    auto& context = find_it->second;
-    const auto stop_was_requested = context.m_stop_requested;
-    context.m_state = ThreadState::Stopped;
-    context.m_stop_requested = false;
+    auto& context = thread_sp->GetThreadContext();
+    const auto stop_was_requested = context.stop_requested;
+    context.stop_requested = false;
 
     // If we have a pending notification, remove this from the set.
     if (m_pending_notification_up)
     {
         m_pending_notification_up->wait_for_stop_tids.erase(tid);
         SignalIfRequirementsSatisfied();
     }
 
-    if (initiated_by_llgs && context.m_request_resume_function && !stop_was_requested)
+    Error error;
+    if (initiated_by_llgs && context.request_resume_function && !stop_was_requested)
     {
         Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
         // We can end up here if stop was initiated by LLGS but by this time a
         // thread stop has occurred - maybe initiated by another event.
         if (log)
             log->Printf("Resuming thread %"  PRIu64 " since stop wasn't requested", tid);
-        const auto error = context.m_request_resume_function (tid, true);
-        if (error.Success ())
-        {
-            context.m_state = ThreadState::Running;
-        }
-        else
-        {
-            if (log)
-            {
+        error = context.request_resume_function (tid, true);
+        if (error.Fail() && log)
                 log->Printf("NativeProcessLinux::%s failed to resume thread tid  %" PRIu64 ": %s",
                         __FUNCTION__, tid, error.AsCString ());
-            }
-            return error;
-        }
     }
-    return Error();
+    return error;
 }
 
 void
 NativeProcessLinux::DoStopThreads(PendingNotificationUP &&notification_up)
 {
-    // Validate we know about the deferred trigger thread.
-    lldbassert(IsKnownThread (notification_up->triggering_tid));
-
     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.
         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, ThreadState state)
+NativeProcessLinux::ThreadWasCreated (lldb::tid_t tid)
 {
-    // Ensure we don't already know about the thread.
-    lldbassert(m_tid_map.find(tid) == m_tid_map.end());
+    auto thread_sp = std::static_pointer_cast<NativeThreadLinux>(GetThreadByID(tid));
+    lldbassert(thread_sp != nullptr);
 
-    // Add the new thread to the stop map.
-    auto tid_it = m_tid_map.emplace(tid, ThreadContext(state)).first;
-
-    if (m_pending_notification_up && state == ThreadState::Running)
+    if (m_pending_notification_up && StateIsRunningState(thread_sp->GetState()))
     {
         // We will need to wait for this new thread to stop as well before firing the
         // notification.
         m_pending_notification_up->wait_for_stop_tids.insert(tid);
-        RequestThreadStop(tid, tid_it->second);
+        thread_sp->RequestStop();
     }
 }
 
 void
 NativeProcessLinux::ThreadDidDie (lldb::tid_t tid)
 {
-    // Ensure we know about the thread.
-    auto find_it = m_tid_map.find (tid);
-    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();
     }
 }
 
if (log)
         log->Printf("NativeProcessLinux::%s event processing done", __FUNCTION__);
     }
 
     return error;
 }
 
 Error
 NativeProcessLinux::RequestThreadResume (lldb::tid_t tid,
-                                         const ResumeThreadFunction &request_thread_resume_function)
+                                         const NativeThreadLinux::ResumeThreadFunction &request_thread_resume_function)
 {
     Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
     std::lock_guard<std::mutex> lock(m_event_mutex);
 
     if (log)
     {
         log->Printf("NativeProcessLinux::%s about to process event: (tid: %" PRIu64 ")",
                 __FUNCTION__, tid);
     }
 
     Error error = DoResume(tid, request_thread_resume_function, true);
 
     if (log)
     {
         log->Printf("NativeProcessLinux::%s event processing done", __FUNCTION__);
     }
 
     return error;
 }
 
 Error
 NativeProcessLinux::RequestThreadResumeAsNeeded (lldb::tid_t tid,
-                                                     const ResumeThreadFunction &request_thread_resume_function)
+        const NativeThreadLinux::ResumeThreadFunction &request_thread_resume_function)
 {
     Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
     std::lock_guard<std::mutex> lock(m_event_mutex);
 
     if (log)
     {
         log->Printf("NativeProcessLinux::%s about to process event: (tid: %" PRIu64 ")",
                 __FUNCTION__, tid);
     }
 
     Error error = DoResume (tid, request_thread_resume_function, false);
 
     if (log)
     {
         log->Printf("NativeProcessLinux::%s event processing done", __FUNCTION__);
     }
 
     return error;
 }
 
 void
-NativeProcessLinux::NotifyThreadCreate (lldb::tid_t tid, ThreadState state)
+NativeProcessLinux::NotifyThreadCreate(lldb::tid_t tid)
 {
     Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
     std::lock_guard<std::mutex> lock(m_event_mutex);
 
     if (log)
-    {
-        log->Printf("NativeProcessLinux::%s about to process event: (tid: %" PRIu64 ", is %sstopped)",
-                __FUNCTION__, tid, state==ThreadState::Stopped?"":"not ");
-    }
+        log->Printf("NativeProcessLinux::%s about to process event: (tid: %" PRIu64 ")", __FUNCTION__, tid);
 
-    ThreadWasCreated (tid, state);
+    ThreadWasCreated(tid);
 
     if (log)
     {
         log->Printf("NativeProcessLinux::%s event processing done", __FUNCTION__);
     }
 }
 
 void
NativeProcessLinux::ResetForExec ()
     if (log)
     {
         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 (log)
     {
         log->Printf("NativeProcessLinux::%s event processing done", __FUNCTION__);
     }
 }
-
-bool
-NativeProcessLinux::IsKnownThread (lldb::tid_t tid) const
-{
-    return m_tid_map.find (tid) != m_tid_map.end ();
-}

source/Plugins/Process/Linux/NativeThreadLinux.h

private:
         SetCrashedWithException (const siginfo_t& info);
 
         void
         SetSuspended ();
 
         void
         SetExited ();
 
+        Error
+        RequestStop ();
+
+        typedef std::function<Error (lldb::tid_t tid, bool supress_signal)> ResumeThreadFunction;
+        struct ThreadContext
+        {
+            bool stop_requested = false;
+            ResumeThreadFunction request_resume_function;
+        };
+
+        ThreadContext &
+        GetThreadContext() { return m_thread_context; }
+
         // ---------------------------------------------------------------------
         // Private interface
         // ---------------------------------------------------------------------
         void
         MaybeLogStateChange (lldb::StateType new_state);
 
         // ---------------------------------------------------------------------
         // Member Variables
         // ---------------------------------------------------------------------
         lldb::StateType m_state;
         ThreadStopInfo m_stop_info;
         NativeRegisterContextSP m_reg_context_sp;
         std::string m_stop_description;
         using WatchpointIndexMap = std::map<lldb::addr_t, uint32_t>;
         WatchpointIndexMap m_watchpoint_index_map;
+        ThreadContext m_thread_context;
     };
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeThreadLinux_H_

source/Plugins/Process/Linux/NativeThreadLinux.cpp

 
 #include "Plugins/Process/Utility/RegisterContextLinux_arm.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_arm64.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_i386.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_x86_64.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_mips64.h"
 #include "Plugins/Process/Utility/RegisterInfoInterface.h"
 
+#include <sys/syscall.h>
+// Try to define a macro to encapsulate the tgkill syscall
+#define tgkill(pid, tid, sig) \
+    syscall(SYS_tgkill, static_cast<::pid_t>(pid), static_cast<::pid_t>(tid), sig)
+
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_linux;
 
 namespace
 {
     void LogThreadStopInfo (Log &log, const ThreadStopInfo &stop_info, const char *const header)
     {

 {
     const StateType new_state = StateType::eStateExited;
     MaybeLogStateChange (new_state);
     m_state = new_state;
 
     m_stop_info.reason = StopReason::eStopReasonThreadExiting;
 }
 
+Error
+NativeThreadLinux::RequestStop ()
+{
+    Log* log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD));
+
+    const auto process_sp = GetProcess();
+    if (! process_sp)
+        return Error("Process is null.");
+
+    lldb::pid_t pid = process_sp->GetID();
+    lldb::tid_t tid = GetID();
+
+    if (log)
+        log->Printf ("NativeThreadLinux::%s requesting thread stop(pid: %" PRIu64 ", tid: %" PRIu64 ")", __FUNCTION__, pid, tid);
+
+    Error err;
+    errno = 0;
+    if (::tgkill (pid, tid, SIGSTOP) != 0)
+    {
+        err.SetErrorToErrno ();
+        if (log)
+            log->Printf ("NativeThreadLinux::%s tgkill(%" PRIu64 ", %" PRIu64 ", SIGSTOP) failed: %s", __FUNCTION__, pid, tid, err.AsCString ());
+    }
+    else
+        m_thread_context.stop_requested = true;
+
+    return err;
+}
+
 void
 NativeThreadLinux::MaybeLogStateChange (lldb::StateType new_state)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD));
     // If we're not logging, we're done.
     if (!log)
         return;