Prefer libc++ when running sanitizers

Ideally we would have matrix with both standard libraries, but it looks
like Vagrind does not like implementation of the std::future in
libstdc++, while libc++ passes without false positives

Author: avsej

.github/workflows/sanitizers.yml

@@ -31,7 +31,7 @@ jobs:
       - name: Install dependencies
         run: |
           sudo apt-get update -y
-          sudo apt-get install -y libssl-dev cmake curl wget gnupg2 gdb clang clang-tools valgrind
+          sudo apt-get install -y libssl-dev cmake curl wget gnupg2 gdb clang clang-tools valgrind libc++-dev libc++abi-dev
       - uses: actions/checkout@v4
         with:
           submodules: recursive
@@ -69,7 +69,7 @@ jobs:
       - name: Install dependencies
         run: |
           sudo apt-get update -y
-          sudo apt-get install -y libssl-dev cmake curl wget gnupg2 gdb clang clang-tools valgrind
+          sudo apt-get install -y libssl-dev cmake curl wget gnupg2 gdb clang clang-tools valgrind libc++-dev libc++abi-dev
       - uses: actions/checkout@v4
         with:
           submodules: recursive
@@ -114,7 +114,7 @@ jobs:
       - name: Install dependencies
         run: |
           sudo apt-get update -y
-          sudo apt-get install -y libssl-dev cmake curl wget gnupg2 gdb clang clang-tools valgrind
+          sudo apt-get install -y libssl-dev cmake curl wget gnupg2 gdb clang clang-tools valgrind libc++-dev libc++abi-dev
       - uses: actions/checkout@v4
         with:
           submodules: recursive

bin/build-tests

@@ -50,38 +50,38 @@ echo "CB_CMAKE_BUILD_TYPE=${CB_CMAKE_BUILD_TYPE}"
 echo "CB_CACHE_OPTION=${CB_CACHE_OPTION}"
 echo "CB_TEST_SUITE=${CB_TEST_SUITE}"
 echo "CB_BORINGSSL=${CB_BORINGSSL}"
+echo "CB_SANITIZER=${CB_SANITIZER}"
+
+CB_CMAKE_EXTRAS=()
+
+if [ "x${CB_SANITIZER}" != "x" ]; then
+    CB_CMAKE_EXTRAS+=(-DCMAKE_CXX_FLAGS="-stdlib=libc++" -DCMAKE_EXE_LINKER_FLAGS="-stdlib=libc++ -lc++abi")
+fi
 
-CB_CMAKE_EXTRAS=
 case "${CB_SANITIZER}" in
     asan | address)
-        CB_CMAKE_EXTRAS="-DENABLE_SANITIZER_ADDRESS=ON"
+        CB_CMAKE_EXTRAS+=(-DENABLE_SANITIZER_ADDRESS=ON)
         ;;
-
     lsan | leak)
-        CB_CMAKE_EXTRAS="-DENABLE_SANITIZER_LEAK=ON"
+        CB_CMAKE_EXTRAS+=(-DENABLE_SANITIZER_LEAK=ON)
         ;;
-
     ubsan | undefined_behaviour)
-        CB_CMAKE_EXTRAS="-DENABLE_SANITIZER_UNDEFINED_BEHAVIOUR=ON"
+        CB_CMAKE_EXTRAS+=(-DENABLE_SANITIZER_UNDEFINED_BEHAVIOUR=ON)
         ;;
-
     tsan | thread)
-        CB_CMAKE_EXTRAS="-DENABLE_SANITIZER_THREAD=ON"
-        export TSAN_OPTIONS="second_deadlock_stack=1"
+        CB_CMAKE_EXTRAS+=(-DENABLE_SANITIZER_THREAD=ON)
         ;;
-
     msan | memory)
-        CB_CMAKE_EXTRAS="-DENABLE_SANITIZER_MEMORY=ON"
+        CB_CMAKE_EXTRAS+=(-DENABLE_SANITIZER_MEMORY=ON)
         ;;
-
     valgrind)
-        CB_CMAKE_EXTRAS="-DCOUCHBASE_CXX_CLIENT_ENABLE_VALGRIND=ON"
+        CB_CMAKE_EXTRAS+=(-DCOUCHBASE_CXX_CLIENT_ENABLE_VALGRIND=ON)
         ;;
 esac
 
 CB_COLUMNAR=${CB_COLUMNAR:-""}
-if [ ! -z "$CB_COLUMNAR" ] ; then
-    CB_CMAKE_EXTRAS="${CB_CMAKE_EXTRAS} -DCOUCHBASE_CXX_CLIENT_COLUMNAR=ON"
+if [ ! -z "${CB_COLUMNAR}" ]; then
+    CB_CMAKE_EXTRAS+=(-DCOUCHBASE_CXX_CLIENT_COLUMNAR=ON)
 fi
 echo "CB_COLUMNAR=${CB_COLUMNAR}"
 
@@ -101,6 +101,8 @@ if [ "x${CB_TEST_SUITE}" != "x" ] ; then
     CB_CMAKE_BUILD_EXTRAS="--target build_${CB_TEST_SUITE}_tests"
 fi
 
+echo "CB_CMAKE_BUILD_EXTRAS=${CB_CMAKE_BUILD_EXTRAS}"
+
 ${CB_CMAKE}  \
     -DCMAKE_BUILD_TYPE=${CB_CMAKE_BUILD_TYPE} \
     -DCMAKE_C_COMPILER="${CB_CC}" \
@@ -110,7 +112,7 @@ ${CB_CMAKE}  \
     -DCOUCHBASE_CXX_CLIENT_BUILD_SHARED=ON \
     -DCOUCHBASE_CXX_CLIENT_STATIC_BORINGSSL=${CB_BORINGSSL} \
     -DCACHE_OPTION="${CB_CACHE_OPTION}" \
-    ${CB_CMAKE_EXTRAS} \
+    "${CB_CMAKE_EXTRAS[@]}" \
     -B "${BUILD_DIR}" \
     -S "${PROJECT_ROOT}"
 

bin/run-integration-tests

@@ -16,6 +16,8 @@
 
 PROJECT_ROOT="$( cd "$(dirname "$0")/.." >/dev/null 2>&1 ; pwd -P )"
 
+[ -f $PROJECT_ROOT/bin/sanitizer-options.sh ] && source $PROJECT_ROOT/bin/sanitizer-options.sh
+
 echo "HOSTNAME=${HOSTNAME}"
 echo "NODE_NAME=${NODE_NAME}"
 echo "CONTAINER_TAG=${CONTAINER_TAG}"
@@ -40,6 +42,9 @@ if [ "x${CB_SANITIZER}" = "xvalgrind" ]; then
     export TEST_USE_WAN_DEVELOPMENT_PROFILE=yes
 fi
 
+export ASAN_OPTIONS="$(IFS=:; echo "${asan_opts[*]}")"
+export TSAN_OPTIONS="$(IFS=:; echo "${tsan_opts[*]}")"
+
 cd "${BUILD_DIR}"
 
 CB_USE_GOCAVES=${CB_USE_GOCAVES:-""}

bin/run-transaction-tests

@@ -16,7 +16,10 @@
 
 PROJECT_ROOT="$( cd "$(dirname "$0"/..)" >/dev/null 2>&1 ; pwd -P )"
 
+[ -f $PROJECT_ROOT/bin/sanitizer-options.sh ] && source $PROJECT_ROOT/bin/sanitizer-options.sh
+
 CB_CTEST=${CB_CTEST:-$(which ctest)}
+CB_CTEST_EXTRAS=${CB_CTEST_EXTRAS:-""}
 CB_SANITIZER=${CB_SANITIZER:-""}
 
 echo "CB_CTEST=${CB_CTEST}"
@@ -27,6 +30,12 @@ BUILD_DIR="${PROJECT_ROOT}/cmake-build-tests"
 if [ "x${CB_SANITIZER}" != "x" ]; then
     BUILD_DIR="${BUILD_DIR}-${CB_SANITIZER}"
 fi
+if [ "x${CB_SANITIZER}" = "xvalgrind" ]; then
+    CB_CTEST_EXTRAS="--test-action memcheck"
+fi
+
+export ASAN_OPTIONS="$(IFS=:; echo "${asan_opts[*]}")"
+export TSAN_OPTIONS="$(IFS=:; echo "${tsan_opts[*]}")"
 
 cd "${BUILD_DIR}"
 

bin/run-unit-tests

@@ -16,6 +16,8 @@
 
 PROJECT_ROOT="$( cd "$(dirname "$0"/..)" >/dev/null 2>&1 ; pwd -P )"
 
+[ -f $PROJECT_ROOT/bin/sanitizer-options.sh ] && source $PROJECT_ROOT/bin/sanitizer-options.sh
+
 CB_CTEST=${CB_CTEST:-$(which ctest)}
 CB_CTEST_EXTRAS=${CB_CTEST_EXTRAS:-""}
 CB_SANITIZER=${CB_SANITIZER:-""}
@@ -32,6 +34,9 @@ if [ "x${CB_SANITIZER}" = "xvalgrind" ]; then
     CB_CTEST_EXTRAS="--test-action memcheck"
 fi
 
+export ASAN_OPTIONS="$(IFS=:; echo "${asan_opts[*]}")"
+export TSAN_OPTIONS="$(IFS=:; echo "${tsan_opts[*]}")"
+
 cd "${BUILD_DIR}"
 
 ${CB_CTEST} --output-on-failure --label-regex 'unit' --output-junit results.xml

bin/sanitizer-options.sh

@@ -0,0 +1,16 @@
+asan_opts=(
+    "print_cmdline=1"
+    "print_stats=1"
+    "use_odr_indicator=1"
+    "dump_instruction_bytes=1"
+    "check_initialization_order=1"
+    "alloc_dealloc_mismatch=1"
+    "detect_odr_violation=1"
+    "detect_stack_use_after_return=1"
+)
+tsan_opts=(
+    "print_cmdline=1"
+    "detect_deadlocks=1"
+    "second_deadlock_stack=1"
+    "halt_on_error=1"
+)

core/io/http_session_manager.hxx

@@ -114,7 +114,7 @@ public:
   void update_config(topology::configuration config) override
   {
     {
-      std::scoped_lock config_lock(config_mutex_, sessions_mutex_, next_index_mutex_);
+      std::scoped_lock config_lock(sessions_mutex_, config_mutex_, next_index_mutex_);
       config_ = std::move(config);
       if (!config_.nodes.empty() && next_index_ >= config_.nodes.size()) {
         next_index_ = 0;

core/io/mcbp_session.cxx

@@ -1751,16 +1751,20 @@ class mcbp_session_impl
       }
     }
     state_ = diag::endpoint_state::connected;
-    const std::scoped_lock lock(pending_buffer_mutex_);
     bootstrapped_ = true;
     bootstrap_handler_->stop();
     handler_ = std::make_shared<message_handler>(shared_from_this());
     handler_->start();
-    if (!pending_buffer_.empty()) {
-      for (auto& buf : pending_buffer_) {
+
+    std::vector<std::vector<std::byte>> pending_buffer{};
+    {
+      const std::scoped_lock lock(pending_buffer_mutex_);
+      std::swap(pending_buffer, pending_buffer_);
+    }
+    if (!pending_buffer.empty()) {
+      for (auto& buf : pending_buffer) {
         write(std::move(buf));
       }
-      pending_buffer_.clear();
       flush();
     }
   }

test/test_integration_connect.cxx

@@ -156,10 +156,10 @@ TEST_CASE("integration: destroy cluster without waiting for close completion", "
          "SDK. FIXME");
   }
 
-  asio::io_context io{};
+  asio::io_context io{ ASIO_CONCURRENCY_HINT_SAFE };
 
   couchbase::core::cluster cluster(io);
-  auto io_thread = std::thread([&io]() {
+  auto io_thread = std::thread([&io]() -> void {
     io.run();
   });
 

test/utils/integration_shortcuts.cxx

@@ -27,15 +27,15 @@ namespace test::utils
 void
 open_cluster(const couchbase::core::cluster& cluster, const couchbase::core::origin& origin)
 {
-  auto barrier = std::make_shared<std::promise<std::error_code>>();
-  auto f = barrier->get_future();
+  std::promise<std::error_code> barrier;
+  auto f = barrier.get_future();
 #ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-  cluster.open_in_background(origin, [barrier](std::error_code ec) mutable {
-    barrier->set_value(ec);
+  cluster.open_in_background(origin, [barrier = std::move(barrier)](std::error_code ec) mutable {
+    barrier.set_value(ec);
   });
 #else
-  cluster.open(origin, [barrier](std::error_code ec) mutable {
-    barrier->set_value(ec);
+  cluster.open(origin, [barrier = std::move(barrier)](std::error_code ec) mutable -> void {
+    barrier.set_value(ec);
   });
 #endif
   auto rc = f.get();
@@ -49,22 +49,23 @@ open_cluster(const couchbase::core::cluster& cluster, const couchbase::core::ori
 void
 close_cluster(const couchbase::core::cluster& cluster)
 {
-  auto barrier = std::make_shared<std::promise<void>>();
-  auto f = barrier->get_future();
-  cluster.close([barrier]() {
-    barrier->set_value();
+  std::promise<void> barrier;
+  auto f = barrier.get_future();
+  cluster.close([barrier = std::move(barrier)]() mutable -> void {
+    barrier.set_value();
   });
   f.get();
 }
 
 void
 open_bucket(const couchbase::core::cluster& cluster, const std::string& bucket_name)
 {
-  auto barrier = std::make_shared<std::promise<std::error_code>>();
-  auto f = barrier->get_future();
-  cluster.open_bucket(bucket_name, [barrier](std::error_code ec) mutable {
-    barrier->set_value(ec);
-  });
+  std::promise<std::error_code> barrier;
+  auto f = barrier.get_future();
+  cluster.open_bucket(bucket_name,
+                      [barrier = std::move(barrier)](std::error_code ec) mutable -> void {
+                        barrier.set_value(ec);
+                      });
   auto rc = f.get();
   if (rc) {
     CB_LOG_CRITICAL("unable to open bucket: {}, name={}", rc.message(), bucket_name);
@@ -75,11 +76,12 @@ open_bucket(const couchbase::core::cluster& cluster, const std::string& bucket_n
 void
 close_bucket(const couchbase::core::cluster& cluster, const std::string& bucket_name)
 {
-  auto barrier = std::make_shared<std::promise<std::error_code>>();
-  auto f = barrier->get_future();
-  cluster.close_bucket(bucket_name, [barrier](std::error_code ec) mutable {
-    barrier->set_value(ec);
-  });
+  std::promise<std::error_code> barrier;
+  auto f = barrier.get_future();
+  cluster.close_bucket(bucket_name,
+                       [barrier = std::move(barrier)](std::error_code ec) mutable -> void {
+                         barrier.set_value(ec);
+                       });
   auto rc = f.get();
   if (rc) {
     CB_LOG_CRITICAL("unable to close bucket: {}, name={}", rc.message(), bucket_name);