Add a mutex to the ThreadPlanStackMap to prevent it getting corrupted

[jingham]

Summary

We were seeing very occasional crashes that looked like corrupted ThreadPlans. This happens when we go to destroy a process which is running, and the attempt to interrupt the process fails so we proceed to tear down the process anyway, but in the middle of doing that the stop event comes in and we crash trying to handle it. We fixed that by protecting the ThreadPlanStack with a mutex so that either the tear down would win, and the event would get discarded, or the event would get handled, and then we would continue with the teardown.

After that change was promulgated we didn't see any more of these crashes but last week I got one crash report that can only be explained by corruption of the ThreadPlanStackMap - which I hadn't added a mutex to. It looks like we need one there as well.

[JDevlieghere]

Jim and I discussed this offline last week. LGTM.

lldb/include/lldb/Target/ThreadPlanStack.h

public:
   ThreadPlanStackMap(Process &process) : m_process(process) {}
   ~ThreadPlanStackMap() = default;
 
   // Prune the map using the current_threads list.
   void Update(ThreadList &current_threads, bool delete_missing,
               bool check_for_new = true);
 
   void AddThread(Thread &thread) {
+    std::lock_guard<std::recursive_mutex> guard(m_stack_map_mutex);
     lldb::tid_t tid = thread.GetID();
     m_plans_list.emplace(tid, thread);
   }
 
   bool RemoveTID(lldb::tid_t tid) {
+    std::lock_guard<std::recursive_mutex> guard(m_stack_map_mutex);
     auto result = m_plans_list.find(tid);
     if (result == m_plans_list.end())
       return false;
     result->second.ThreadDestroyed(nullptr);
     m_plans_list.erase(result);
     return true;
   }
 
   ThreadPlanStack *Find(lldb::tid_t tid) {
+    std::lock_guard<std::recursive_mutex> guard(m_stack_map_mutex);
     auto result = m_plans_list.find(tid);
     if (result == m_plans_list.end())
       return nullptr;
     else
       return &result->second;
   }
 
   /// Clear the Thread* cache that each ThreadPlan contains.
   ///
   /// This is useful in situations like when a new Thread list is being
   /// generated.
   void ClearThreadCache() {
     for (auto &plan_list : m_plans_list)
       plan_list.second.ClearThreadCache();
   }
 
   void Clear() {
+    std::lock_guard<std::recursive_mutex> guard(m_stack_map_mutex);
     for (auto &plan : m_plans_list)
       plan.second.ThreadDestroyed(nullptr);
     m_plans_list.clear();
   }
 
   // Implements Process::DumpThreadPlans
   void DumpPlans(Stream &strm, lldb::DescriptionLevel desc_level, bool internal,
                  bool ignore_boring, bool skip_unreported);
 
   // Implements Process::DumpThreadPlansForTID
   bool DumpPlansForTID(Stream &strm, lldb::tid_t tid,
                        lldb::DescriptionLevel desc_level, bool internal,
                        bool ignore_boring, bool skip_unreported);
                        
   bool PrunePlansForTID(lldb::tid_t tid);
 
 private:
   Process &m_process;
+  mutable std::recursive_mutex m_stack_map_mutex;
   using PlansList = std::unordered_map<lldb::tid_t, ThreadPlanStack>;
   PlansList m_plans_list;
+  
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_THREADPLANSTACK_H

lldb/source/Target/ThreadPlanStack.cpp

void ThreadPlanStack::WillResume() {
   m_completed_plans.clear();
   m_discarded_plans.clear();
 }
 
 void ThreadPlanStackMap::Update(ThreadList &current_threads,
                                 bool delete_missing,
                                 bool check_for_new) {
 
+  std::lock_guard<std::recursive_mutex> guard(m_stack_map_mutex);
   // Now find all the new threads and add them to the map:
   if (check_for_new) {
     for (auto thread : current_threads.Threads()) {
       lldb::tid_t cur_tid = thread->GetID();
       if (!Find(cur_tid)) {
         AddThread(*thread.get());
         thread->QueueBasePlan(true);
       }
for (lldb::tid_t tid : missing_threads) {
     RemoveTID(tid);
   }
 }
 
 void ThreadPlanStackMap::DumpPlans(Stream &strm,
                                    lldb::DescriptionLevel desc_level,
                                    bool internal, bool condense_if_trivial,
                                    bool skip_unreported) {
+  std::lock_guard<std::recursive_mutex> guard(m_stack_map_mutex);
   for (auto &elem : m_plans_list) {
     lldb::tid_t tid = elem.first;
     uint32_t index_id = 0;
     ThreadSP thread_sp = m_process.GetThreadList().FindThreadByID(tid);
 
     if (skip_unreported) {
       if (!thread_sp)
         continue;
void ThreadPlanStackMap::DumpPlans(Stream &strm,
   }
 }
 
 bool ThreadPlanStackMap::DumpPlansForTID(Stream &strm, lldb::tid_t tid,
                                          lldb::DescriptionLevel desc_level,
                                          bool internal,
                                          bool condense_if_trivial,
                                          bool skip_unreported) {
+  std::lock_guard<std::recursive_mutex> guard(m_stack_map_mutex);
   uint32_t index_id = 0;
   ThreadSP thread_sp = m_process.GetThreadList().FindThreadByID(tid);
 
   if (skip_unreported) {
     if (!thread_sp) {
       strm.Format("Unknown TID: {0}", tid);
       return false;
     }
bool ThreadPlanStackMap::DumpPlansForTID(Stream &strm, lldb::tid_t tid,
   strm.Printf("thread #%u: tid = 0x%4.4" PRIx64 ":\n", index_id, tid);
 
   stack->DumpThreadPlans(strm, desc_level, internal);
   return true;
 }
 
 bool ThreadPlanStackMap::PrunePlansForTID(lldb::tid_t tid) {
   // We only remove the plans for unreported TID's.
+  std::lock_guard<std::recursive_mutex> guard(m_stack_map_mutex);
   ThreadSP thread_sp = m_process.GetThreadList().FindThreadByID(tid);
   if (thread_sp)
     return false;
 
   return RemoveTID(tid);
 }