compiler-rt/lib/xray/xray_utils.cpp

   1 //===-- xray_utils.cpp ------------------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file is a part of XRay, a dynamic runtime instrumentation system.
  10 //
  11 //===----------------------------------------------------------------------===//
  12 #include "xray_utils.h"
  13
  14 #include "sanitizer_common/sanitizer_allocator_internal.h"
  15 #include "sanitizer_common/sanitizer_common.h"
  16 #include "xray_allocator.h"
  17 #include "xray_defs.h"
  18 #include "xray_flags.h"
  19 #include <cstdio>
  20 #include <errno.h>
  21 #include <fcntl.h>
  22 #include <iterator>
  23 #include <new>
  24 #include <stdlib.h>
  25 #include <sys/types.h>
  26 #include <tuple>
  27 #include <unistd.h>
  28 #include <utility>
  29
  30 #if SANITIZER_FUCHSIA
  31 #include "sanitizer_common/sanitizer_symbolizer_fuchsia.h"
  32
  33 #include <inttypes.h>
  34 #include <zircon/process.h>
  35 #include <zircon/sanitizer.h>
  36 #include <zircon/status.h>
  37 #include <zircon/syscalls.h>
  38 #endif
  39
  40 namespace __xray {
  41
  42 #if SANITIZER_FUCHSIA
  43 constexpr const char* ProfileSinkName = "llvm-xray";
  44
  45 LogWriter::~LogWriter() {
  46   _zx_handle_close(Vmo);
  47 }
  48
  49 void LogWriter::WriteAll(const char *Begin, const char *End) XRAY_NEVER_INSTRUMENT {
  50   if (Begin == End)
  51     return;
  52   auto TotalBytes = std::distance(Begin, End);
  53
  54   const size_t PageSize = flags()->xray_page_size_override > 0
  55                               ? flags()->xray_page_size_override
  56                               : GetPageSizeCached();
  57   if (RoundUpTo(Offset, PageSize) != RoundUpTo(Offset + TotalBytes, PageSize)) {
  58     // Resize the VMO to ensure there's sufficient space for the data.
  59     zx_status_t Status = _zx_vmo_set_size(Vmo, Offset + TotalBytes);
  60     if (Status != ZX_OK) {
  61       Report("Failed to resize VMO: %s\n", _zx_status_get_string(Status));
  62       return;
  63     }
  64   }
  65
  66   // Write the data into VMO.
  67   zx_status_t Status = _zx_vmo_write(Vmo, Begin, Offset, TotalBytes);
  68   if (Status != ZX_OK) {
  69     Report("Failed to write: %s\n", _zx_status_get_string(Status));
  70     return;
  71   }
  72   Offset += TotalBytes;
  73
  74   // Record the data size as a property of the VMO.
  75   _zx_object_set_property(Vmo, ZX_PROP_VMO_CONTENT_SIZE,
  76                           &Offset, sizeof(Offset));
  77 }
  78
  79 void LogWriter::Flush() XRAY_NEVER_INSTRUMENT {
  80   // Nothing to do here since WriteAll writes directly into the VMO.
  81 }
  82
  83 LogWriter *LogWriter::Open() XRAY_NEVER_INSTRUMENT {
  84   // Create VMO to hold the profile data.
  85   zx_handle_t Vmo;
  86   zx_status_t Status = _zx_vmo_create(0, ZX_VMO_RESIZABLE, &Vmo);
  87   if (Status != ZX_OK) {
  88     Report("XRay: cannot create VMO: %s\n", _zx_status_get_string(Status));
  89     return nullptr;
  90   }
  91
  92   // Get the KOID of the current process to use in the VMO name.
  93   zx_info_handle_basic_t Info;
  94   Status = _zx_object_get_info(_zx_process_self(), ZX_INFO_HANDLE_BASIC, &Info,
  95                                sizeof(Info), NULL, NULL);
  96   if (Status != ZX_OK) {
  97     Report("XRay: cannot get basic info about current process handle: %s\n",
  98            _zx_status_get_string(Status));
  99     return nullptr;
 100   }
 101
 102   // Give the VMO a name including our process KOID so it's easy to spot.
 103   char VmoName[ZX_MAX_NAME_LEN];
 104   internal_snprintf(VmoName, sizeof(VmoName), "%s.%zu", ProfileSinkName,
 105                     Info.koid);
 106   _zx_object_set_property(Vmo, ZX_PROP_NAME, VmoName, strlen(VmoName));
 107
 108   // Duplicate the handle since __sanitizer_publish_data consumes it and
 109   // LogWriter needs to hold onto it.
 110   zx_handle_t Handle;
 111   Status =_zx_handle_duplicate(Vmo, ZX_RIGHT_SAME_RIGHTS, &Handle);
 112   if (Status != ZX_OK) {
 113     Report("XRay: cannot duplicate VMO handle: %s\n",
 114            _zx_status_get_string(Status));
 115     return nullptr;
 116   }
 117
 118   // Publish the VMO that receives the logging. Note the VMO's contents can
 119   // grow and change after publication. The contents won't be read out until
 120   // after the process exits.
 121   __sanitizer_publish_data(ProfileSinkName, Handle);
 122
 123   // Use the dumpfile symbolizer markup element to write the name of the VMO.
 124   Report("XRay: " FORMAT_DUMPFILE "\n", ProfileSinkName, VmoName);
 125
 126   LogWriter *LW = reinterpret_cast<LogWriter *>(InternalAlloc(sizeof(LogWriter)));
 127   new (LW) LogWriter(Vmo);
 128   return LW;
 129 }
 130
 131 void LogWriter::Close(LogWriter *LW) {
 132   LW->~LogWriter();
 133   InternalFree(LW);
 134 }
 135 #else // SANITIZER_FUCHSIA
 136 LogWriter::~LogWriter() {
 137   internal_close(Fd);
 138 }
 139
 140 void LogWriter::WriteAll(const char *Begin, const char *End) XRAY_NEVER_INSTRUMENT {
 141   if (Begin == End)
 142     return;
 143   auto TotalBytes = std::distance(Begin, End);
 144   while (auto Written = write(Fd, Begin, TotalBytes)) {
 145     if (Written < 0) {
 146       if (errno == EINTR)
 147         continue; // Try again.
 148       Report("Failed to write; errno = %d\n", errno);
 149       return;
 150     }
 151     TotalBytes -= Written;
 152     if (TotalBytes == 0)
 153       break;
 154     Begin += Written;
 155   }
 156 }
 157
 158 void LogWriter::Flush() XRAY_NEVER_INSTRUMENT {
 159   fsync(Fd);
 160 }
 161
 162 LogWriter *LogWriter::Open() XRAY_NEVER_INSTRUMENT {
 163   // Open a temporary file once for the log.
 164   char TmpFilename[256] = {};
 165   char TmpWildcardPattern[] = "XXXXXX";
 166   auto **Argv = GetArgv();
 167   const char *Progname = !Argv ? "(unknown)" : Argv[0];
 168   const char *LastSlash = internal_strrchr(Progname, '/');
 169
 170   if (LastSlash != nullptr)
 171     Progname = LastSlash + 1;
 172
 173   int NeededLength = internal_snprintf(
 174       TmpFilename, sizeof(TmpFilename), "%s%s.%s",
 175       flags()->xray_logfile_base, Progname, TmpWildcardPattern);
 176   if (NeededLength > int(sizeof(TmpFilename))) {
 177     Report("XRay log file name too long (%d): %s\n", NeededLength, TmpFilename);
 178     return nullptr;
 179   }
 180   int Fd = mkstemp(TmpFilename);
 181   if (Fd == -1) {
 182     Report("XRay: Failed opening temporary file '%s'; not logging events.\n",
 183            TmpFilename);
 184     return nullptr;
 185   }
 186   if (Verbosity())
 187     Report("XRay: Log file in '%s'\n", TmpFilename);
 188
 189   LogWriter *LW = allocate<LogWriter>();
 190   new (LW) LogWriter(Fd);
 191   return LW;
 192 }
 193
 194 void LogWriter::Close(LogWriter *LW) {
 195   LW->~LogWriter();
 196   deallocate(LW);
 197 }
 198 #endif // SANITIZER_FUCHSIA
 199
 200 } // namespace __xray