Convert = operators that take object mutexes to the multi-lock version of std::lock

[jingham]

Summary

I made a copy-paste error copying the ModuleList trick for avoiding priority inversion in taking the lhs & rhs mutexes. Pavel pointed out you can use the std::lock(lock1, lock2) form to do this more cleanly. I fixed the one I got wrong and I think I found all the other places doing this (or just locking both mutexes) and replaced them with this form.

[davide]

This looks correct to me, but I'm not extremely familiar either, so I'd wait for @labath to sign off.

[labath]

This looks great. Thank you.

As of c++17 there will be an RAII way to do this https://en.cppreference.com/w/cpp/thread/scoped_lock. Theoretically we could jump ahead, and implement something like that ourselves, but there aren't too many uses of this pattern now, so it's not really necessary at this point.

lldb/trunk/include/lldb/Core/ModuleSpec.h

ModuleSpecList(const ModuleSpecList &rhs) : m_specs(), m_mutex() {
     std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_mutex);
     m_specs = rhs.m_specs;
   }
 
   ~ModuleSpecList() = default;
 
   ModuleSpecList &operator=(const ModuleSpecList &rhs) {
     if (this != &rhs) {
-      std::lock_guard<std::recursive_mutex> lhs_guard(m_mutex);
-      std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_mutex);
+      std::lock(m_mutex, rhs.m_mutex);
+      std::lock_guard<std::recursive_mutex> lhs_guard(m_mutex, std::adopt_lock);
+      std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_mutex, 
+                                                      std::adopt_lock);
       m_specs = rhs.m_specs;
     }
     return *this;
   }
 
   size_t GetSize() const {
     std::lock_guard<std::recursive_mutex> guard(m_mutex);
     return m_specs.size();

lldb/trunk/include/lldb/Utility/StreamTee.h

StreamTee(const StreamTee &rhs)
     m_streams = rhs.m_streams;
   }
 
   ~StreamTee() override {}
 
   StreamTee &operator=(const StreamTee &rhs) {
     if (this != &rhs) {
       Stream::operator=(rhs);
-      std::lock_guard<std::recursive_mutex> lhs_locker(m_streams_mutex);
-      std::lock_guard<std::recursive_mutex> rhs_locker(rhs.m_streams_mutex);
+      std::lock(m_streams_mutex, rhs.m_streams_mutex);
+      std::lock_guard<std::recursive_mutex> lhs_locker(m_streams_mutex,
+                                                       std::adopt_lock);
+      std::lock_guard<std::recursive_mutex> rhs_locker(rhs.m_streams_mutex,
+                                                       std::adopt_lock);
       m_streams = rhs.m_streams;
     }
     return *this;
   }
 
   void Flush() override {
     std::lock_guard<std::recursive_mutex> guard(m_streams_mutex);
     collection::iterator pos, end;

lldb/trunk/source/Breakpoint/BreakpointLocationCollection.cpp

for (pos = begin; pos != end; ++pos) {
     if (pos != begin)
       s->PutChar(' ');
     (*pos)->GetDescription(s, level);
   }
 }
 
 BreakpointLocationCollection &BreakpointLocationCollection::operator=(
     const BreakpointLocationCollection &rhs) {
-  // Same trick as in ModuleList to avoid lock inversion.
   if (this != &rhs) {
-    if (uintptr_t(this) > uintptr_t(&rhs)) {
-      std::lock_guard<std::mutex> lhs_guard(m_collection_mutex);
-      std::lock_guard<std::mutex> rhs_guard(rhs.m_collection_mutex);
+      std::lock(m_collection_mutex, rhs.m_collection_mutex);
+      std::lock_guard<std::mutex> lhs_guard(m_collection_mutex, std::adopt_lock);
+      std::lock_guard<std::mutex> rhs_guard(rhs.m_collection_mutex, std::adopt_lock);
       m_break_loc_collection = rhs.m_break_loc_collection;
-    } else {
-      std::lock_guard<std::mutex> lhs_guard(m_collection_mutex);
-      std::lock_guard<std::mutex> rhs_guard(rhs.m_collection_mutex);
-      m_break_loc_collection = rhs.m_break_loc_collection;
-    }
   }
   return *this;
 }

lldb/trunk/source/Core/ModuleList.cpp

ModuleList::ModuleList(const ModuleList &rhs)
   m_modules = rhs.m_modules;
 }
 
 ModuleList::ModuleList(ModuleList::Notifier *notifier)
     : m_modules(), m_modules_mutex(), m_notifier(notifier) {}
 
 const ModuleList &ModuleList::operator=(const ModuleList &rhs) {
   if (this != &rhs) {
-    // That's probably me nit-picking, but in theoretical situation:
-    //
-    // * that two threads A B and
-    // * two ModuleList's x y do opposite assignments ie.:
-    //
-    //  in thread A: | in thread B:
-    //    x = y;     |   y = x;
-    //
-    // This establishes correct(same) lock taking order and thus avoids
-    // priority inversion.
-    if (uintptr_t(this) > uintptr_t(&rhs)) {
-      std::lock_guard<std::recursive_mutex> lhs_guard(m_modules_mutex);
-      std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_modules_mutex);
-      m_modules = rhs.m_modules;
-    } else {
-      std::lock_guard<std::recursive_mutex> lhs_guard(m_modules_mutex);
-      std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_modules_mutex);
-      m_modules = rhs.m_modules;
-    }
+    std::lock(m_modules_mutex, rhs.m_modules_mutex);
+    std::lock_guard<std::recursive_mutex> lhs_guard(m_modules_mutex, 
+                                                    std::adopt_lock);
+    std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_modules_mutex, 
+                                                    std::adopt_lock);
   }
   return *this;
 }
 
 ModuleList::~ModuleList() = default;
 
 void ModuleList::AppendImpl(const ModuleSP &module_sp, bool use_notifier) {
   if (module_sp) {

lldb/trunk/source/Target/SectionLoadList.cpp

 SectionLoadList::SectionLoadList(const SectionLoadList &rhs)
     : m_addr_to_sect(), m_sect_to_addr(), m_mutex() {
   std::lock_guard<std::recursive_mutex> guard(rhs.m_mutex);
   m_addr_to_sect = rhs.m_addr_to_sect;
   m_sect_to_addr = rhs.m_sect_to_addr;
 }
 
 void SectionLoadList::operator=(const SectionLoadList &rhs) {
-  std::lock_guard<std::recursive_mutex> lhs_guard(m_mutex);
-  std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_mutex);
+  std::lock(m_mutex, rhs.m_mutex);
+  std::lock_guard<std::recursive_mutex> lhs_guard(m_mutex, std::adopt_lock);
+  std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_mutex, std::adopt_lock);
   m_addr_to_sect = rhs.m_addr_to_sect;
   m_sect_to_addr = rhs.m_sect_to_addr;
 }
 
 bool SectionLoadList::IsEmpty() const {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   return m_addr_to_sect.empty();
 }

lldb/trunk/source/Target/ThreadList.cpp

ThreadList::ThreadList(const ThreadList &rhs)
   // Use the assignment operator since it uses the mutex
   *this = rhs;
 }
 
 const ThreadList &ThreadList::operator=(const ThreadList &rhs) {
   if (this != &rhs) {
     // Lock both mutexes to make sure neither side changes anyone on us while
     // the assignment occurs
-    std::lock_guard<std::recursive_mutex> guard(GetMutex());
-    std::lock_guard<std::recursive_mutex> rhs_guard(rhs.GetMutex());
+    std::lock(GetMutex(), rhs.GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetMutex(), std::adopt_lock);
+    std::lock_guard<std::recursive_mutex> rhs_guard(rhs.GetMutex(), 
+                                                    std::adopt_lock);
 
     m_process = rhs.m_process;
     m_stop_id = rhs.m_stop_id;
     m_threads = rhs.m_threads;
     m_selected_tid = rhs.m_selected_tid;
   }
   return *this;
 }