fix deadlock in RCU retire when rcu_reader active

Summary:
Every 3.2 seconds RCU retire tries to opportunistically
drain the queue of pending work.  If this happens while
the current thread is holding an rcu_reader and another
thread is currently running synchronize(), a deadlock will
occur.  This diff adds a unit test for the behavior and
fixes the problem.

Test Plan:
* unit test that reproduces the problem
* unit test passes with the fix

Author: nbronson

CMakeLists.txt

@@ -1038,6 +1038,7 @@ if (BUILD_TESTS OR BUILD_BENCHMARKS)
         SOURCES LifoSemTests.cpp
       TEST synchronization_relaxed_atomic_test WINDOWS_DISABLED
         SOURCES RelaxedAtomicTest.cpp
+      TEST synchronization_rcu_test SOURCES RcuTest.cpp
       TEST synchronization_rw_spin_lock_test SOURCES RWSpinLockTest.cpp
       TEST synchronization_semaphore_test WINDOWS_DISABLED
         SOURCES SemaphoreTest.cpp

folly/synchronization/Rcu.h

@@ -384,8 +384,12 @@ class rcu_domain {
             syncTime, time, std::memory_order_relaxed)) {
       list_head finished;
       {
-        std::lock_guard<std::mutex> g(syncMutex_);
-        half_sync(false, finished);
+        // synchronize() blocks while holding syncMutex_,
+        // so we must not wait for syncMutex_
+        std::unique_lock<std::mutex> g(syncMutex_, std::try_to_lock);
+        if (g) {
+          half_sync(false, finished);
+        }
       }
       // callbacks are called outside of syncMutex_
       finished.forEach([&](list_node* item) {

folly/synchronization/test/RcuTest.cpp

@@ -330,3 +330,26 @@ TEST(RcuTest, DeeplyNestedReaders) {
   rcu_synchronize();
   delete int_ptr.exchange(nullptr, std::memory_order_acq_rel);
 }
+
+TEST(RcuTest, RetireUnderLock) {
+  using namespace std::chrono;
+
+  // syncTimePeriod is 3.2s
+  auto deadline = steady_clock::now() + seconds(4);
+
+  std::thread t1([&] {
+    while (steady_clock::now() < deadline) {
+      rcu_synchronize();
+    }
+  });
+
+  std::thread t2([&] {
+    while (steady_clock::now() < deadline) {
+      std::scoped_lock<rcu_domain> g(rcu_default_domain());
+      rcu_default_domain().call([] {});
+    }
+  });
+
+  t1.join();
+  t2.join();
+}