[XRay] Guard call to postCurrentThreadFCT()

[dberris]

Summary

Some cases where postCurrentThreadFCT() are not guarded by our
recursion guard. We've observed that sometimes these can lead to
deadlocks when some functions (like memcpy()) gets outlined and the
version of memcpy is XRay-instrumented, which can be materialised by the
compiler in the implementation of lower-level components used by the
profiling runtime.

This change ensures that all calls to postCurrentThreadFCT are guarded
by our thread-recursion guard, to prevent deadlocks.

[mboerger]

LGTM

compiler-rt/trunk/lib/xray/xray_profiling.cc

XRayLogFlushStatus profilingFlush() XRAY_NEVER_INSTRUMENT {
   if (!profilingFlags()->no_flush) {
     // First check whether we have data in the profile collector service
     // before we try and write anything down.
     XRayBuffer B = profileCollectorService::nextBuffer({nullptr, 0});
     if (B.Data == nullptr) {
       if (Verbosity())
         Report("profiling: No data to flush.\n");
     } else {
-      LogWriter* LW = LogWriter::Open();
+      LogWriter *LW = LogWriter::Open();
       if (LW == nullptr) {
         if (Verbosity())
           Report("profiling: Failed to flush to file, dropping data.\n");
       } else {
         // Now for each of the buffers, write out the profile data as we would
         // see it in memory, verbatim.
         while (B.Data != nullptr && B.Size != 0) {
           LW->WriteAll(reinterpret_cast<const char *>(B.Data),
if (!atomic_compare_exchange_strong(&ProfilerLogStatus, &CurrentStatus,
     if (Verbosity())
       Report("Cannot finalize profile, the profiling is not initialized.\n");
     return static_cast<XRayLogInitStatus>(CurrentStatus);
   }
 
   // Wait a grace period to allow threads to see that we're finalizing.
   SleepForMillis(profilingFlags()->grace_period_ms);
 
-  // We also want to make sure that the current thread's data is cleaned up,
-  // if we have any.
+  // We also want to make sure that the current thread's data is cleaned up, if
+  // we have any. We need to ensure that the call to postCurrentThreadFCT() is
+  // guarded by our recursion guard.
   auto &TLD = getThreadLocalData();
+  {
+    RecursionGuard G(ReentranceGuard);
+    if (G)
       postCurrentThreadFCT(TLD);
+  }
 
   // Then we force serialize the log data.
   profileCollectorService::serialize();
 
   atomic_store(&ProfilerLogStatus, XRayLogInitStatus::XRAY_LOG_FINALIZED,
                memory_order_release);
   return XRayLogInitStatus::XRAY_LOG_FINALIZED;
 }
profilingLoggingInit(UNUSED size_t BufferSize, UNUSED size_t BufferMax,
   static pthread_once_t Once = PTHREAD_ONCE_INIT;
   pthread_once(&Once, +[] {
     pthread_key_create(&ProfilingKey, +[](void *P) {
       // This is the thread-exit handler.
       auto &TLD = *reinterpret_cast<ProfilingData *>(P);
       if (TLD.Allocators == nullptr && TLD.FCT == nullptr)
         return;
 
+      {
+        // If we're somehow executing this while inside a non-reentrant-friendly
+        // context, we skip attempting to post the current thread's data.
+        RecursionGuard G(ReentranceGuard);
+        if (G)
           postCurrentThreadFCT(TLD);
+      }
     });
 
     // We also need to set up an exit handler, so that we can get the profile
     // information at exit time. We use the C API to do this, to not rely on C++
     // ABI functions for registering exit handlers.
     Atexit(+[] {
       // Finalize and flush.
       if (profilingFinalize() != XRAY_LOG_FINALIZED) {