Guard against a deadlock with an assertion

Author: vector-of-bool

src/common/common-thread-private.h

@@ -37,7 +37,6 @@ BSON_BEGIN_DECLS
 #define BSON_ONCE_INIT PTHREAD_ONCE_INIT
 #define bson_once pthread_once
 #define bson_once_t pthread_once_t
-#define bson_thread_t pthread_t
 #define BSON_THREAD_FUN(_function_name, _arg_name) \
    void *(_function_name) (void *(_arg_name))
 #define BSON_THREAD_FUN_TYPE(_function_name) void *(*(_function_name)) (void *)
@@ -57,6 +56,24 @@ BSON_BEGIN_DECLS
 #define bson_mutex_t pthread_mutex_t
 #define bson_mutex_unlock pthread_mutex_unlock
 
+#ifdef _WIN32
+typedef DWORD bson_thread_t;
+#elif defined(BSON_OS_UNIX)
+typedef pthread_t bson_thread_t;
+#else
+typedef void bson_thread_t;
+#endif
+
+/**
+ * @brief Get the numeric ID of the calling thread
+ */
+static BSON_INLINE bson_thread_t
+bson_current_thread_id ()
+{
+   BSON_IF_POSIX (return pthread_self ();)
+   BSON_IF_WINDOWS (return GetCurrentThreadId ();)
+}
+
 #else
 typedef struct {
    pthread_t lock_owner;
@@ -105,9 +122,9 @@ typedef struct {
 #define bson_once_t INIT_ONCE
 #define bson_thread_t HANDLE
 #define BSON_THREAD_FUN(_function_name, _arg_name) \
-   unsigned(__stdcall _function_name) (void *(_arg_name))
+   unsigned (__stdcall _function_name) (void *(_arg_name))
 #define BSON_THREAD_FUN_TYPE(_function_name) \
-   unsigned(__stdcall * _function_name) (void *)
+   unsigned (__stdcall * _function_name) (void *)
 #define BSON_THREAD_RETURN return
 #endif
 

src/libmongoc/src/mongoc/mongoc-topology-private.h

@@ -180,6 +180,9 @@ typedef struct _mongoc_topology_t {
     * topology. This could occur if the URI is invalid.
     * An invalid topology does not monitor servers. */
    bool valid;
+
+   /* Track the thread with a pending topology description modification */
+   int _current_modifying_thread;
 } mongoc_topology_t;
 
 mongoc_topology_t *

src/libmongoc/src/mongoc/mongoc-topology.c

@@ -346,6 +346,8 @@ mongoc_topology_new (const mongoc_uri_t *uri, bool single_threaded)
       topology->server_selection_try_once = false;
    }
 
+   topology->_current_modifying_thread = -1;
+
    topology->server_selection_timeout_msec = mongoc_uri_get_option_as_int32 (
       topology->uri,
       MONGOC_URI_SERVERSELECTIONTIMEOUTMS,
@@ -1969,7 +1971,19 @@ mc_tpld_modify_begin (mongoc_topology_t *tpl)
 {
    mc_shared_tpld prev_td;
    mongoc_topology_description_t *new_td;
+   int modifier_thread = bson_atomic_int_fetch (&tpl->_current_modifying_thread,
+                                                bson_memory_order_relaxed);
+   int cur_thread = (int) bson_current_thread_id ();
+   /* If the same thread attempts to perform a modification while a modification
+    * is already in progress on the same thread, that would deadlock and is an
+    * inherent bug */
+   BSON_ASSERT (
+      modifier_thread != cur_thread &&
+      "Attempted to begin recursive modification of topology description");
    bson_mutex_lock (&tpl->tpld_modification_mtx);
+   bson_atomic_int_exchange (&tpl->_current_modifying_thread,
+                             (int) bson_current_thread_id (),
+                             bson_memory_order_relaxed);
    prev_td = mc_tpld_take_ref (tpl);
    new_td = mongoc_topology_description_new_copy (prev_td.ptr),
    mc_tpld_drop_ref (&prev_td);
@@ -1986,13 +2000,17 @@ mc_tpld_modify_commit (mc_tpld_modification mod)
       mongoc_shared_ptr_create (mod.new_td, _topo_descr_destroy_and_free);
    mongoc_atomic_shared_ptr_store (&mod.topology->_shared_descr_._sptr_,
                                    new_sptr);
+   bson_atomic_int_exchange (
+      &mod.topology->_current_modifying_thread, -1, bson_memory_order_relaxed);
    bson_mutex_unlock (&mod.topology->tpld_modification_mtx);
    mongoc_shared_ptr_reset_null (&new_sptr);
 }
 
 void
 mc_tpld_modify_drop (mc_tpld_modification mod)
 {
+   bson_atomic_int_exchange (
+      &mod.topology->_current_modifying_thread, -1, bson_memory_order_relaxed);
    bson_mutex_unlock (&mod.topology->tpld_modification_mtx);
    mongoc_topology_description_destroy (mod.new_td);
 }