[Target] Protect Processes' language runtimes map with a mutex

[xiaobai]

Summary

From what I understand, it's possible for multiple threads to request
a specific language runtime (e.g. CPPLanguageRuntime). This leads to a data
race.

[JDevlieghere]

I would use a lock_guard + lexical scope instead of locking/unlocking. Is there a reason not to here?

[xiaobai]

In D62169#1509458, @JDevlieghere wrote:

I would use a lock_guard + lexical scope instead of locking/unlocking. Is there a reason not to here?

Ah, no, just not something I thought about when I wrote this. I'll do that, thanks!

[xiaobai]

Address feedback from Jonas

[JDevlieghere]

LGTM!

include/lldb/Target/Process.h

protected:
   std::recursive_mutex m_profile_data_comm_mutex;
   std::vector<std::string> m_profile_data;
   Predicate<uint32_t> m_iohandler_sync;
   MemoryCache m_memory_cache;
   AllocatedMemoryCache m_allocated_memory_cache;
   bool m_should_detach; /// Should we detach if the process object goes away
                         /// with an explicit call to Kill or Detach?
   LanguageRuntimeCollection m_language_runtimes;
+  std::recursive_mutex m_language_runtimes_mutex;
   InstrumentationRuntimeCollection m_instrumentation_runtimes;
   std::unique_ptr<NextEventAction> m_next_event_action_up;
   std::vector<PreResumeCallbackAndBaton> m_pre_resume_actions;
   ProcessRunLock m_public_run_lock;
   ProcessRunLock m_private_run_lock;
   bool m_currently_handling_do_on_removals;
   bool m_resume_requested; // If m_currently_handling_event or
                            // m_currently_handling_do_on_removals are true,

source/Target/Process.cpp

void Process::Finalize() {
   m_extended_thread_list.Destroy();
   m_queue_list.Clear();
   m_queue_list_stop_id = 0;
   std::vector<Notifications> empty_notifications;
   m_notifications.swap(empty_notifications);
   m_image_tokens.clear();
   m_memory_cache.Clear();
   m_allocated_memory_cache.Clear();
+  m_language_runtimes_mutex.lock();
   m_language_runtimes.clear();
+  m_language_runtimes_mutex.unlock();
   m_instrumentation_runtimes.clear();
   m_next_event_action_up.reset();
   // Clear the last natural stop ID since it has a strong reference to this
   // process
   m_mod_id.SetStopEventForLastNaturalStopID(EventSP());
   //#ifdef LLDB_CONFIGURATION_DEBUG
   //    StreamFile s(stdout, false);
   //    EventSP event_sp;
const lldb::ABISP &Process::GetABI() {
   return m_abi_sp;
 }
 
 LanguageRuntime *Process::GetLanguageRuntime(lldb::LanguageType language,
                                              bool retry_if_null) {
   if (m_finalizing)
     return nullptr;
 
+  std::lock_guard<std::recursive_mutex> guard(m_language_runtimes_mutex);
   LanguageRuntimeCollection::iterator pos;
   pos = m_language_runtimes.find(language);
   if (pos == m_language_runtimes.end() || (retry_if_null && !(*pos).second)) {
     lldb::LanguageRuntimeSP runtime_sp(
         LanguageRuntime::FindPlugin(this, language));
 
     m_language_runtimes[language] = runtime_sp;
     return runtime_sp.get();
   } else
     return (*pos).second.get();
 }
 
 CPPLanguageRuntime *Process::GetCPPLanguageRuntime(bool retry_if_null) {
+  std::lock_guard<std::recursive_mutex> guard(m_language_runtimes_mutex);
   LanguageRuntime *runtime =
       GetLanguageRuntime(eLanguageTypeC_plus_plus, retry_if_null);
   if (runtime != nullptr &&
       runtime->GetLanguageType() == eLanguageTypeC_plus_plus)
     return static_cast<CPPLanguageRuntime *>(runtime);
   return nullptr;
 }
 
 ObjCLanguageRuntime *Process::GetObjCLanguageRuntime(bool retry_if_null) {
+  std::lock_guard<std::recursive_mutex> guard(m_language_runtimes_mutex);
   LanguageRuntime *runtime =
       GetLanguageRuntime(eLanguageTypeObjC, retry_if_null);
   if (runtime != nullptr && runtime->GetLanguageType() == eLanguageTypeObjC)
     return static_cast<ObjCLanguageRuntime *>(runtime);
   return nullptr;
 }
 
 bool Process::IsPossibleDynamicValue(ValueObject &in_value) {
void Process::DidExec() {
   m_dynamic_checkers_up.reset();
   m_abi_sp.reset();
   m_system_runtime_up.reset();
   m_os_up.reset();
   m_dyld_up.reset();
   m_jit_loaders_up.reset();
   m_image_tokens.clear();
   m_allocated_memory_cache.Clear();
+  m_language_runtimes_mutex.lock();
   m_language_runtimes.clear();
+  m_language_runtimes_mutex.unlock();
   m_instrumentation_runtimes.clear();
   m_thread_list.DiscardThreadPlans();
   m_memory_cache.Clear(true);
   DoDidExec();
   CompleteAttach();
   // Flush the process (threads and all stack frames) after running
   // CompleteAttach() in case the dynamic loader loaded things in new
   // locations.
void Process::ModulesDidLoad(ModuleList &module_list) {
   }
 
   // Let any language runtimes we have already created know about the modules
   // that loaded.
 
   // Iterate over a copy of this language runtime list in case the language
   // runtime ModulesDidLoad somehow causes the language runtime to be
   // unloaded.
+  m_language_runtimes_mutex.lock();
   LanguageRuntimeCollection language_runtimes(m_language_runtimes);
   for (const auto &pair : language_runtimes) {
     // We must check language_runtime_sp to make sure it is not nullptr as we
     // might cache the fact that we didn't have a language runtime for a
     // language.
     LanguageRuntimeSP language_runtime_sp = pair.second;
     if (language_runtime_sp)
       language_runtime_sp->ModulesDidLoad(module_list);
   }
+  m_language_runtimes_mutex.unlock();
 
   // If we don't have an operating system plug-in, try to load one since
   // loading shared libraries might cause a new one to try and load
   if (!m_os_up)
     LoadOperatingSystemPlugin(false);
 
   // Give structured-data plugins a chance to see the modified modules.
   for (auto pair : m_structured_data_plugin_map) {