[XRay] Encapsulate all FD log related logic into a class

[phosek]

Summary

This abstracts away the file descriptor related logic which makes it
easier to port XRay to platform that don't use file descriptors or
file system for writing the log data, such as Fuchsia.

[dberris]

compiler-rt/lib/xray/xray_utils.cc

89–90 ↗

(On Diff #165708)

Is it possible to avoid using InternalAlloc and InternalFree here, and instead use the XRay-specific allocators in xray_allocator.h (allocate<T>(...) and deallocate(...))?

[dberris]

compiler-rt/lib/xray/xray_utils.cc

89–90 ↗

(On Diff #165708)

Marked done but I don't see the changes -- I still see InternalAlloc and InternalFree?

[phosek]

compiler-rt/lib/xray/xray_utils.cc

89–90 ↗

(On Diff #165708)

I accidentally reuploaded the old patch, sorry about that.

[dberris]

LGTM

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

 
 struct alignas(64) ThreadLocalData {
   void *InMemoryBuffer = nullptr;
   size_t BufferSize = 0;
   size_t BufferOffset = 0;
   void *ShadowStack = nullptr;
   size_t StackSize = 0;
   size_t StackEntries = 0;
-  int Fd = -1;
+  LogWriter *LogWriter = nullptr;
 };
 
 struct BasicLoggingOptions {
   int DurationFilterMicros = 0;
   size_t MaxStackDepth = 0;
   size_t ThreadBufferSize = 0;
 };
 } // namespace
 
 static pthread_key_t PThreadKey;
 
 static atomic_uint8_t BasicInitialized{0};
 
 struct BasicLoggingOptions GlobalOptions;
 
 thread_local atomic_uint8_t Guard{0};
 
 static atomic_uint8_t UseRealTSC{0};
 static atomic_uint64_t ThresholdTicks{0};
 static atomic_uint64_t TicksPerSec{0};
 static atomic_uint64_t CycleFrequency{NanosecondsPerSecond};
 
-static int openLogFile() XRAY_NEVER_INSTRUMENT {
-  int F = getLogFD();
-  if (F == -1)
-    return -1;
+static LogWriter *getLog() XRAY_NEVER_INSTRUMENT {
+  LogWriter* LW = LogWriter::Open();
+  if (LW == nullptr)
+    return LW;
 
   static pthread_once_t DetectOnce = PTHREAD_ONCE_INIT;
   pthread_once(&DetectOnce, +[] {
     if (atomic_load(&UseRealTSC, memory_order_acquire))
       atomic_store(&CycleFrequency, getTSCFrequency(), memory_order_release);
   });
 
   // Since we're here, we get to write the header. We set it up so that the
   // header will only be written once, at the start, and let the threads
   // logging do writes which just append.
   XRayFileHeader Header;
   // Version 2 includes tail exit records.
   // Version 3 includes pid inside records.
   Header.Version = 3;
   Header.Type = FileTypes::NAIVE_LOG;
   Header.CycleFrequency = atomic_load(&CycleFrequency, memory_order_acquire);
 
   // FIXME: Actually check whether we have 'constant_tsc' and 'nonstop_tsc'
   // before setting the values in the header.
   Header.ConstantTSC = 1;
   Header.NonstopTSC = 1;
-  retryingWriteAll(F, reinterpret_cast<char *>(&Header),
-                   reinterpret_cast<char *>(&Header) + sizeof(Header));
-  return F;
+  LW->WriteAll(reinterpret_cast<char *>(&Header),
+  return LW;
 }
 
-static int getGlobalFd() XRAY_NEVER_INSTRUMENT {
+static LogWriter *getGlobalLog() XRAY_NEVER_INSTRUMENT {
   static pthread_once_t OnceInit = PTHREAD_ONCE_INIT;
-  static int Fd = 0;
-  pthread_once(&OnceInit, +[] { Fd = openLogFile(); });
-  return Fd;
+  static LogWriter *LW = nullptr;
+  pthread_once(&OnceInit, +[] { LW = getLog(); });
+  return LW;
 }
 
 static ThreadLocalData &getThreadLocalData() XRAY_NEVER_INSTRUMENT {
   thread_local ThreadLocalData TLD;
   thread_local bool UNUSED TOnce = [] {
     if (GlobalOptions.ThreadBufferSize == 0) {
       if (Verbosity())
         Report("Not initializing TLD since ThreadBufferSize == 0.\n");
       return false;
     }
     pthread_setspecific(PThreadKey, &TLD);
-    TLD.Fd = getGlobalFd();
+    TLD.LogWriter = getGlobalLog();
     TLD.InMemoryBuffer = reinterpret_cast<XRayRecord *>(
         InternalAlloc(sizeof(XRayRecord) * GlobalOptions.ThreadBufferSize,
                       nullptr, alignof(XRayRecord)));
     TLD.BufferSize = GlobalOptions.ThreadBufferSize;
     TLD.BufferOffset = 0;
     if (GlobalOptions.MaxStackDepth == 0) {
       if (Verbosity())
         Report("Not initializing the ShadowStack since MaxStackDepth == 0.\n");
static ThreadLocalData &getThreadLocalData() XRAY_NEVER_INSTRUMENT {
   }();
   return TLD;
 }
 
 template <class RDTSC>
 void InMemoryRawLog(int32_t FuncId, XRayEntryType Type,
                     RDTSC ReadTSC) XRAY_NEVER_INSTRUMENT {
   auto &TLD = getThreadLocalData();
-  int Fd = getGlobalFd();
-  if (Fd == -1)
+  LogWriter *LW = getGlobalLog();
+  if (LW == nullptr)
     return;
 
   // Use a simple recursion guard, to handle cases where we're already logging
   // and for one reason or another, this function gets called again in the same
   // thread.
   RecursionGuard G(Guard);
   if (!G)
     return;
void InMemoryRawLog(int32_t FuncId, XRayEntryType Type,
   R.TSC = TSC;
   R.TId = GetTid(); 
   R.PId = internal_getpid(); 
   R.Type = Type;
   R.FuncId = FuncId;
   auto FirstEntry = reinterpret_cast<XRayRecord *>(TLD.InMemoryBuffer);
   internal_memcpy(FirstEntry + TLD.BufferOffset, &R, sizeof(R));
   if (++TLD.BufferOffset == TLD.BufferSize) {
-    SpinMutexLock L(&LogMutex);
-    retryingWriteAll(Fd, reinterpret_cast<char *>(FirstEntry),
-                     reinterpret_cast<char *>(FirstEntry + TLD.BufferOffset));
+    SpinMutexLock Lock(&LogMutex);
+    LW->WriteAll(reinterpret_cast<char *>(FirstEntry),
     TLD.BufferOffset = 0;
     TLD.StackEntries = 0;
   }
 }
 
 template <class RDTSC>
 void InMemoryRawLogWithArg(int32_t FuncId, XRayEntryType Type, uint64_t Arg1,
                            RDTSC ReadTSC) XRAY_NEVER_INSTRUMENT {
   auto &TLD = getThreadLocalData();
   auto FirstEntry =
       reinterpret_cast<XRayArgPayload *>(TLD.InMemoryBuffer);
   const auto &BuffLen = TLD.BufferSize;
-  int Fd = getGlobalFd();
-  if (Fd == -1)
+  LogWriter *LW = getGlobalLog();
+  if (LW == nullptr)
     return;
 
   // First we check whether there's enough space to write the data consecutively
   // in the thread-local buffer. If not, we first flush the buffer before
   // attempting to write the two records that must be consecutive.
   if (TLD.BufferOffset + 2 > BuffLen) {
-    SpinMutexLock L(&LogMutex);
-    retryingWriteAll(Fd, reinterpret_cast<char *>(FirstEntry),
-                     reinterpret_cast<char *>(FirstEntry + TLD.BufferOffset));
+    SpinMutexLock Lock(&LogMutex);
+    LW->WriteAll(reinterpret_cast<char *>(FirstEntry),
     TLD.BufferOffset = 0;
     TLD.StackEntries = 0;
   }
 
   // Then we write the "we have an argument" record.
   InMemoryRawLog(FuncId, Type, ReadTSC);
 
   RecursionGuard G(Guard);
   if (!G)
     return;
 
   // And, from here on write the arg payload.
   XRayArgPayload R;
   R.RecordType = RecordTypes::ARG_PAYLOAD;
   R.FuncId = FuncId;
   R.TId = GetTid(); 
   R.PId = internal_getpid(); 
   R.Arg = Arg1;
   internal_memcpy(FirstEntry + TLD.BufferOffset, &R, sizeof(R));
   if (++TLD.BufferOffset == BuffLen) {
-    SpinMutexLock L(&LogMutex);
-    retryingWriteAll(Fd, reinterpret_cast<char *>(FirstEntry),
-                     reinterpret_cast<char *>(FirstEntry + TLD.BufferOffset));
+    SpinMutexLock Lock(&LogMutex);
+    LW->WriteAll(reinterpret_cast<char *>(FirstEntry),
     TLD.BufferOffset = 0;
     TLD.StackEntries = 0;
   }
 }
 
 void basicLoggingHandleArg0RealTSC(int32_t FuncId,
                                    XRayEntryType Type) XRAY_NEVER_INSTRUMENT {
   InMemoryRawLog(FuncId, Type, readTSC);
auto ExitGuard = at_scope_exit([&TLD] {
     if (TLD.InMemoryBuffer)
       InternalFree(TLD.InMemoryBuffer);
     if (TLD.ShadowStack)
       InternalFree(TLD.ShadowStack);
     if (Verbosity())
       Report("Cleaned up log for TID: %d\n", GetTid());
   });
 
-  if (TLD.Fd == -1 || TLD.BufferOffset == 0) {
+  if (TLD.LogWriter == nullptr || TLD.BufferOffset == 0) {
     if (Verbosity())
-      Report("Skipping buffer for TID: %d; Fd = %d; Offset = %llu\n", GetTid(),
-             TLD.Fd, TLD.BufferOffset);
+      Report("Skipping buffer for TID: %d; Offset = %llu\n", GetTid(),
+             TLD.BufferOffset);
     return;
   }
 
   {
     SpinMutexLock L(&LogMutex);
-    retryingWriteAll(TLD.Fd, reinterpret_cast<char *>(TLD.InMemoryBuffer),
+    TLD.LogWriter->WriteAll(reinterpret_cast<char *>(TLD.InMemoryBuffer),
                             reinterpret_cast<char *>(TLD.InMemoryBuffer) +
                             (sizeof(XRayRecord) * TLD.BufferOffset));
   }
 
   // Because this thread's exit could be the last one trying to write to
   // the file and that we're not able to close out the file properly, we
   // sync instead and hope that the pending writes are flushed as the
   // thread exits.
-  fsync(TLD.Fd);
+  TLD.LogWriter->Flush();
 }
 
 XRayLogInitStatus basicLoggingInit(UNUSED size_t BufferSize,
                                    UNUSED size_t BufferMax, void *Options,
                                    size_t OptionsSize) XRAY_NEVER_INSTRUMENT {
   uint8_t Expected = 0;
   if (!atomic_compare_exchange_strong(&BasicInitialized, &Expected, 1,
                                       memory_order_acq_rel)) {

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

XRayLogFlushStatus fdrLoggingFlush() XRAY_NEVER_INSTRUMENT {
   //
   //   1) We write down the XRay file header with version 1, type FDR_LOG.
   //   2) Then we use the 'apply' member of the BufferQueue that's live, to
   //      ensure that at this point in time we write down the buffers that have
   //      been released (and marked "used") -- we dump the full buffer for now
   //      (fixed-sized) and let the tools reading the buffers deal with the data
   //      afterwards.
   //
-  int Fd = getLogFD();
-  if (Fd == -1) {
+  LogWriter* LW = LogWriter::Open();
+  if (LW == nullptr) {
     auto Result = XRayLogFlushStatus::XRAY_LOG_NOT_FLUSHING;
     atomic_store(&LogFlushStatus, Result, memory_order_release);
     return Result;
   }
 
   XRayFileHeader Header = fdrCommonHeaderInfo();
   Header.FdrData = FdrAdditionalHeaderData{BQ->ConfiguredBufferSize()};
-  retryingWriteAll(Fd, reinterpret_cast<char *>(&Header),
-                   reinterpret_cast<char *>(&Header) + sizeof(Header));
+  LW->WriteAll(reinterpret_cast<char *>(&Header),
 
   // Release the current thread's buffer before we attempt to write out all the
   // buffers. This ensures that in case we had only a single thread going, that
   // we are able to capture the data nonetheless.
   auto &TLD = getThreadLocalData();
   if (TLD.RecordPtr != nullptr && TLD.BQ != nullptr)
     releaseThreadLocalBuffer(*TLD.BQ);
 
   BQ->apply([&](const BufferQueue::Buffer &B) {
     // Starting at version 2 of the FDR logging implementation, we only write
     // the records identified by the extents of the buffer. We use the Extents
     // from the Buffer and write that out as the first record in the buffer.  We
     // still use a Metadata record, but fill in the extents instead for the
     // data.
     MetadataRecord ExtentsRecord;
     auto BufferExtents = atomic_load(&B.Extents, memory_order_acquire);
     DCHECK(BufferExtents <= B.Size);
     ExtentsRecord.Type = uint8_t(RecordType::Metadata);
     ExtentsRecord.RecordKind =
         uint8_t(MetadataRecord::RecordKinds::BufferExtents);
     internal_memcpy(ExtentsRecord.Data, &BufferExtents, sizeof(BufferExtents));
     if (BufferExtents > 0) {
-      retryingWriteAll(Fd, reinterpret_cast<char *>(&ExtentsRecord),
-                       reinterpret_cast<char *>(&ExtentsRecord) +
-                           sizeof(MetadataRecord));
-      retryingWriteAll(Fd, reinterpret_cast<char *>(B.Data),
-                       reinterpret_cast<char *>(B.Data) + BufferExtents);
+      LW->WriteAll(reinterpret_cast<char *>(&ExtentsRecord),
+      LW->WriteAll(reinterpret_cast<char *>(B.Data),
     }
   });
 
   atomic_store(&LogFlushStatus, XRayLogFlushStatus::XRAY_LOG_FLUSHED,
                memory_order_release);
   return XRayLogFlushStatus::XRAY_LOG_FLUSHED;
 }
 

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 {
-      int Fd = getLogFD();
-      if (Fd == -1) {
+      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) {
-          retryingWriteAll(Fd, reinterpret_cast<const char *>(B.Data),
-                           reinterpret_cast<const char *>(B.Data) + B.Size);
+          LW->WriteAll(reinterpret_cast<const char *>(B.Data),
           B = profileCollectorService::nextBuffer(B);
         }
-        // Then we close out the file.
-        internal_close(Fd);
       }
+      LogWriter::Close(LW);
     }
   }
 
   profileCollectorService::reset();
 
   // Flush the current thread's local data structures as well.
   cleanupTLD();
 

compiler-rt/trunk/lib/xray/xray_utils.h

 
 #include <cstddef>
 #include <cstdint>
 #include <sys/types.h>
 #include <utility>
 
 namespace __xray {
 
+class LogWriter {
+public:
+  explicit LogWriter(int Fd) : Fd(Fd) {}
+  ~LogWriter();
+
+  // Write a character range into a log.
+  void WriteAll(const char *Begin, const char *End);
+
+  void Flush();
+
+  // Returns a new log instance initialized using the flag-provided values.
+  static LogWriter *Open();
+  // Closes and deallocates the log instance.
+  static void Close(LogWriter *LogWriter);
+
+private:
+  int Fd = -1;
+};
+
 // Default implementation of the reporting interface for sanitizer errors.
 void printToStdErr(const char *Buffer);
 
-// EINTR-safe write routine, provided a file descriptor and a character range.
-void retryingWriteAll(int Fd, const char *Begin, const char *End);
-
-// Reads a long long value from a provided file.
-bool readValueFromFile(const char *Filename, long long *Value);
-
-// EINTR-safe read routine, providing a file descriptor and a character range.
-std::pair<ssize_t, bool> retryingReadSome(int Fd, char *Begin, char *End);
-
-// EINTR-safe open routine, uses flag-provided values for initialising a log
-// file.
-int getLogFD();
-
 constexpr size_t gcd(size_t a, size_t b) {
   return (b == 0) ? a : gcd(b, a % b);
 }
 
 constexpr size_t lcm(size_t a, size_t b) { return a * b / gcd(a, b); }
 
 constexpr size_t nearest_boundary(size_t number, size_t multiple) {
   return multiple * ((number / multiple) + (number % multiple ? 1 : 0));

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

 //===-- xray_utils.cc -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of XRay, a dynamic runtime instrumentation system.
 //
 //===----------------------------------------------------------------------===//
 #include "xray_utils.h"
 
+#include "sanitizer_common/sanitizer_allocator_internal.h"
 #include "sanitizer_common/sanitizer_common.h"
+#include "xray_allocator.h"
 #include "xray_defs.h"
 #include "xray_flags.h"
 #include <cstdio>
 #include <errno.h>
 #include <fcntl.h>
 #include <iterator>
 #include <stdlib.h>
 #include <sys/types.h>
 #include <tuple>
 #include <unistd.h>
 #include <utility>
 
 namespace __xray {
 
 void printToStdErr(const char *Buffer) XRAY_NEVER_INSTRUMENT {
   fprintf(stderr, "%s", Buffer);
 }
 
-void retryingWriteAll(int Fd, const char *Begin, const char *End) XRAY_NEVER_INSTRUMENT {
+LogWriter::~LogWriter() {
+  internal_close(Fd);
+}
+
+void LogWriter::WriteAll(const char *Begin, const char *End) XRAY_NEVER_INSTRUMENT {
   if (Begin == End)
     return;
   auto TotalBytes = std::distance(Begin, End);
   while (auto Written = write(Fd, Begin, TotalBytes)) {
     if (Written < 0) {
       if (errno == EINTR)
         continue; // Try again.
       Report("Failed to write; errno = %d\n", errno);
       return;
     }
     TotalBytes -= Written;
     if (TotalBytes == 0)
       break;
     Begin += Written;
   }
 }
 
-std::pair<ssize_t, bool> retryingReadSome(int Fd, char *Begin,
-                                          char *End) XRAY_NEVER_INSTRUMENT {
-  auto BytesToRead = std::distance(Begin, End);
-  ssize_t BytesRead;
-  ssize_t TotalBytesRead = 0;
-  while (BytesToRead && (BytesRead = read(Fd, Begin, BytesToRead))) {
-    if (BytesRead == -1) {
-      if (errno == EINTR)
-        continue;
-      Report("Read error; errno = %d\n", errno);
-      return std::make_pair(TotalBytesRead, false);
-    }
-
-    TotalBytesRead += BytesRead;
-    BytesToRead -= BytesRead;
-    Begin += BytesRead;
-  }
-  return std::make_pair(TotalBytesRead, true);
-}
-
-bool readValueFromFile(const char *Filename,
-                       long long *Value) XRAY_NEVER_INSTRUMENT {
-  int Fd = open(Filename, O_RDONLY | O_CLOEXEC);
-  if (Fd == -1)
-    return false;
-  static constexpr size_t BufSize = 256;
-  char Line[BufSize] = {};
-  ssize_t BytesRead;
-  bool Success;
-  std::tie(BytesRead, Success) = retryingReadSome(Fd, Line, Line + BufSize);
-  if (!Success)
-    return false;
-  close(Fd);
-  const char *End = nullptr;
-  long long Tmp = internal_simple_strtoll(Line, &End, 10);
-  bool Result = false;
-  if (Line[0] != '\0' && (*End == '\n' || *End == '\0')) {
-    *Value = Tmp;
-    Result = true;
-  }
-  return Result;
+void LogWriter::Flush() XRAY_NEVER_INSTRUMENT {
+  fsync(Fd);
 }
 
-int getLogFD() XRAY_NEVER_INSTRUMENT {
+LogWriter *LogWriter::Open() XRAY_NEVER_INSTRUMENT {
   // Open a temporary file once for the log.
   char TmpFilename[256] = {};
   char TmpWildcardPattern[] = "XXXXXX";
   auto **Argv = GetArgv();
   const char *Progname = !Argv ? "(unknown)" : Argv[0];
   const char *LastSlash = internal_strrchr(Progname, '/');
 
   if (LastSlash != nullptr)
     Progname = LastSlash + 1;
 
   int NeededLength = internal_snprintf(
       TmpFilename, sizeof(TmpFilename), "%s%s.%s",
       flags()->xray_logfile_base, Progname, TmpWildcardPattern);
   if (NeededLength > int(sizeof(TmpFilename))) {
     Report("XRay log file name too long (%d): %s\n", NeededLength, TmpFilename);
-    return -1;
+    return nullptr;
   }
   int Fd = mkstemp(TmpFilename);
   if (Fd == -1) {
     Report("XRay: Failed opening temporary file '%s'; not logging events.\n",
            TmpFilename);
-    return -1;
+    return nullptr;
   }
   if (Verbosity())
     Report("XRay: Log file in '%s'\n", TmpFilename);
 
-  return Fd;
+  LogWriter *LW = allocate<LogWriter>();
+  new (LW) LogWriter(Fd);
+  return LW;
+}
+
+void LogWriter::Close(LogWriter *LW) {
+  LW->~LogWriter();
+  deallocate(LW);
 }
 
 } // namespace __xray