switched to heap allocation of selected structures instead

src/realm/alloc_slab.cpp

@@ -582,8 +582,10 @@ ref_type SlabAlloc::get_top_ref(const char* buffer, size_t len)
 
 namespace {
 
-std::map<std::string, std::weak_ptr<SlabAlloc::MappedFile>> all_files;
-util::Mutex all_files_mutex;
+// prevent destruction at exit (which can lead to races if other threads are still running)
+std::map<std::string, std::weak_ptr<SlabAlloc::MappedFile>>& all_files =
+    *new std::map<std::string, std::weak_ptr<SlabAlloc::MappedFile>>;
+util::Mutex& all_files_mutex = *new util::Mutex;
 }
 
 

src/realm/util/file_mapper.cpp

@@ -92,21 +92,11 @@ struct mapping_and_addr {
     size_t size;
 };
 
-util::Mutex mapping_mutex(Mutex::no_destruction_tag());
-std::vector<mapping_and_addr> mappings_by_addr;
-std::vector<mappings_for_file> mappings_by_file;
-
-// If there's any active mappings when the program exits, deliberately leak them
-// to avoid flushing things that were in the middle of being modified on a different thrad
-struct AtExit {
-    ~AtExit()
-    {
-        if (!mappings_by_addr.empty())
-            (new std::vector<mapping_and_addr>)->swap(mappings_by_addr);
-        if (!mappings_by_file.empty())
-            (new std::vector<mappings_for_file>)->swap(mappings_by_file);
-    }
-} at_exit;
+// prevent destruction at exit (which can lead to races if other threads are still running)
+util::Mutex& mapping_mutex = *new Mutex;
+std::vector<mapping_and_addr>& mappings_by_addr = *new std::vector<mapping_and_addr>;
+std::vector<mappings_for_file>& mappings_by_file = *new std::vector<mappings_for_file>;
+
 
 mapping_and_addr* find_mapping_for_addr(void* addr, size_t size)
 {

src/realm/util/thread.hpp

@@ -101,20 +101,6 @@ class Mutex {
     Mutex();
     ~Mutex() noexcept;
 
-    struct no_destruction_tag {
-    };
-
-    // Configure this mutex to ignore destruction. This should be used
-    // ONLY for a mutex placed in a global variable. Global variables
-    // are destroyed on exit of the main thread, but some use cases
-    // indicate that background threads may still be alive and accessing
-    // the mutex after destruction. This leads to apps failing.
-    // For global variables, it is ok not to destroy the mutex properly.
-    // When the process terminates, the kernel will release the resources
-    // in any case. This facility should *never* be used for process
-    // shared mutexes.
-    Mutex(no_destruction_tag);
-
     struct process_shared_tag {
     };
     /// Initialize this mutex for use across multiple processes. When
@@ -134,7 +120,6 @@ class Mutex {
 
 protected:
     pthread_mutex_t m_impl = PTHREAD_MUTEX_INITIALIZER;
-    bool do_not_destroy = false;
 
     struct no_init_tag {
     };
@@ -403,16 +388,8 @@ inline Mutex::Mutex(process_shared_tag)
     init_as_process_shared(robust_if_available);
 }
 
-inline Mutex::Mutex(no_destruction_tag)
-{
-    do_not_destroy = true;
-}
-
 inline Mutex::~Mutex() noexcept
 {
-    if (do_not_destroy)
-        return;
-
     int r = pthread_mutex_destroy(&m_impl);
     if (REALM_UNLIKELY(r != 0))
         destroy_failed(r);