CDRIVER-4185 log and do not update state when creating thread fails (#1315)

* log and do not update state when creating thread fails

add `errno_out` arg to mcommon_thread_create

* return error code

Author: kevinAlbs

src/common/common-thread-private.h

@@ -119,6 +119,9 @@ typedef struct {
  * libbson and libmongoc statically. */
 int
 mcommon_thread_join (bson_thread_t thread);
+// mcommon_thread_create returns 0 on success. Returns a non-zero error code on
+// error. Callers may use `bson_strerror_r` to get an error message from the
+// returned error code.
 int
 mcommon_thread_create (bson_thread_t *thread,
                        BSON_THREAD_FUN_TYPE (func),

src/common/common-thread.c

@@ -16,12 +16,17 @@
 
 #include "common-thread-private.h"
 
+#include <errno.h>
+
 #if defined(BSON_OS_UNIX)
 int
 mcommon_thread_create (bson_thread_t *thread,
                        BSON_THREAD_FUN_TYPE (func),
                        void *arg)
 {
+   BSON_ASSERT_PARAM (thread);
+   BSON_ASSERT_PARAM (func);
+   BSON_ASSERT (arg || true); // optional.
    return pthread_create (thread, NULL, func, arg);
 }
 int
@@ -45,9 +50,13 @@ mcommon_thread_create (bson_thread_t *thread,
                        BSON_THREAD_FUN_TYPE (func),
                        void *arg)
 {
+   BSON_ASSERT_PARAM (thread);
+   BSON_ASSERT_PARAM (func);
+   BSON_ASSERT (arg || true); // optional.
+
    *thread = (HANDLE) _beginthreadex (NULL, 0, func, arg, 0, NULL);
    if (0 == *thread) {
-      return 1;
+      return errno;
    }
    return 0;
 }

src/libmongoc/src/mongoc/mongoc-server-monitor.c

@@ -1402,9 +1402,19 @@ mongoc_server_monitor_run (mongoc_server_monitor_t *server_monitor)
    bson_mutex_lock (&server_monitor->shared.mutex);
    if (server_monitor->shared.state == MONGOC_THREAD_OFF) {
       server_monitor->is_rtt = false;
-      server_monitor->shared.state = MONGOC_THREAD_RUNNING;
-      mcommon_thread_create (
+      int ret = mcommon_thread_create (
          &server_monitor->thread, _server_monitor_thread, server_monitor);
+      if (ret == 0) {
+         server_monitor->shared.state = MONGOC_THREAD_RUNNING;
+      } else {
+         char errmsg_buf[BSON_ERROR_BUFFER_SIZE];
+         char *errmsg = bson_strerror_r (ret, errmsg_buf, sizeof errmsg_buf);
+         _server_monitor_log (server_monitor,
+                              MONGOC_LOG_LEVEL_ERROR,
+                              "Failed to start monitoring thread. This server "
+                              "may not be selectable. Error: %s",
+                              errmsg);
+      }
    }
    bson_mutex_unlock (&server_monitor->shared.mutex);
 }
@@ -1415,9 +1425,19 @@ mongoc_server_monitor_run_as_rtt (mongoc_server_monitor_t *server_monitor)
    bson_mutex_lock (&server_monitor->shared.mutex);
    if (server_monitor->shared.state == MONGOC_THREAD_OFF) {
       server_monitor->is_rtt = true;
-      server_monitor->shared.state = MONGOC_THREAD_RUNNING;
-      mcommon_thread_create (
+      int ret = mcommon_thread_create (
          &server_monitor->thread, _server_monitor_rtt_thread, server_monitor);
+      if (ret == 0) {
+         server_monitor->shared.state = MONGOC_THREAD_RUNNING;
+      } else {
+         char errmsg_buf[BSON_ERROR_BUFFER_SIZE];
+         char *errmsg = bson_strerror_r (ret, errmsg_buf, sizeof errmsg_buf);
+         _server_monitor_log (
+            server_monitor,
+            MONGOC_LOG_LEVEL_ERROR,
+            "Failed to start Round-Trip Time monitoring thread. Error: %s",
+            errmsg);
+      }
    }
    bson_mutex_unlock (&server_monitor->shared.mutex);
 }

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

@@ -162,9 +162,17 @@ _mongoc_topology_background_monitoring_start (mongoc_topology_t *topology)
       _mongoc_topology_background_monitoring_reconcile (topology, tdmod.new_td);
       /* Start SRV polling thread. */
       if (mongoc_topology_should_rescan_srv (topology)) {
-         topology->is_srv_polling = true;
-         mcommon_thread_create (
+         int ret = mcommon_thread_create (
             &topology->srv_polling_thread, srv_polling_run, topology);
+         if (ret == 0) {
+            topology->is_srv_polling = true;
+         } else {
+            char errmsg_buf[BSON_ERROR_BUFFER_SIZE];
+            char *errmsg = bson_strerror_r (ret, errmsg_buf, sizeof errmsg_buf);
+            MONGOC_ERROR ("Failed to start SRV polling thread. SRV records "
+                          "will not be polled. Error: %s",
+                          errmsg);
+         }
       }
    }
 

src/libmongoc/tests/json-test-operations.c

@@ -140,7 +140,9 @@ static void
 start_thread (json_test_worker_thread_t *wt)
 {
    wt->shutdown_requested = false;
-   mcommon_thread_create (&wt->thread, json_test_worker_thread_run, wt);
+   int ret =
+      mcommon_thread_create (&wt->thread, json_test_worker_thread_run, wt);
+   ASSERT_CMPINT (0, ==, ret);
 }
 
 static void

src/libmongoc/tests/test-mongoc-client-pool.c

@@ -451,8 +451,8 @@ test_client_pool_max_pool_size_exceeded (void)
    bson_mutex_init (&args->mutex);
    mongoc_cond_init (&args->cond);
 
-   mcommon_thread_create (&thread1, worker, args);
-   mcommon_thread_create (&thread2, worker, args);
+   ASSERT_CMPINT (0, ==, mcommon_thread_create (&thread1, worker, args));
+   ASSERT_CMPINT (0, ==, mcommon_thread_create (&thread2, worker, args));
 
    bson_mutex_lock (&args->mutex);
    while (args->nleft > 0) {

src/libmongoc/tests/test-mongoc-client-side-encryption.c

@@ -6793,7 +6793,8 @@ test_bypass_mongocryptd_shared_library (void *unused)
    listen_socket_args_t *args = bson_malloc0 (sizeof (listen_socket_args_t));
    bson_mutex_init (&args->mutex);
    mongoc_cond_init (&args->cond);
-   mcommon_thread_create (&socket_thread, listen_socket, args);
+   ASSERT_CMPINT (
+      0, ==, mcommon_thread_create (&socket_thread, listen_socket, args));
 
    // configure mongoclient with auto encryption
    char *env_cryptSharedLibPath =

src/libmongoc/tests/test-mongoc-handshake.c

@@ -925,7 +925,7 @@ test_mongoc_handshake_race_condition (void)
 
       for (j = 0; j < 4; ++j) {
          BSON_ASSERT (!mcommon_thread_create (
-            &threads[j], &handshake_append_worker, NULL));
+            &threads[j], &handshake_append_worker, NULL /* args */));
       }
       for (j = 0; j < 4; ++j) {
          mcommon_thread_join (threads[j]);