forked from OSchip/llvm-project
195 lines
6.3 KiB
C++
195 lines
6.3 KiB
C++
//===-- xray_inmemory_log.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.
|
|
//
|
|
// Implementation of a simple in-memory log of XRay events. This defines a
|
|
// logging function that's compatible with the XRay handler interface, and
|
|
// routines for exporting data to files.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include <cassert>
|
|
#include <cstdint>
|
|
#include <cstdio>
|
|
#include <fcntl.h>
|
|
#include <mutex>
|
|
#include <sys/stat.h>
|
|
#include <sys/syscall.h>
|
|
#include <sys/types.h>
|
|
#include <thread>
|
|
#include <unistd.h>
|
|
|
|
#if defined(__x86_64__)
|
|
#include "xray_x86_64.h"
|
|
#elif defined(__arm__) || defined(__aarch64__)
|
|
#include "xray_emulate_tsc.h"
|
|
#else
|
|
#error "Unsupported CPU Architecture"
|
|
#endif /* Architecture-specific inline intrinsics */
|
|
|
|
#include "sanitizer_common/sanitizer_libc.h"
|
|
#include "xray/xray_records.h"
|
|
#include "xray_defs.h"
|
|
#include "xray_flags.h"
|
|
#include "xray_interface_internal.h"
|
|
|
|
// __xray_InMemoryRawLog will use a thread-local aligned buffer capped to a
|
|
// certain size (32kb by default) and use it as if it were a circular buffer for
|
|
// events. We store simple fixed-sized entries in the log for external analysis.
|
|
|
|
extern "C" {
|
|
void __xray_InMemoryRawLog(int32_t FuncId,
|
|
XRayEntryType Type) XRAY_NEVER_INSTRUMENT;
|
|
}
|
|
|
|
namespace __xray {
|
|
|
|
std::mutex LogMutex;
|
|
|
|
static void retryingWriteAll(int Fd, char *Begin,
|
|
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;
|
|
}
|
|
}
|
|
|
|
class ThreadExitFlusher {
|
|
int Fd;
|
|
XRayRecord *Start;
|
|
size_t &Offset;
|
|
|
|
public:
|
|
explicit ThreadExitFlusher(int Fd, XRayRecord *Start,
|
|
size_t &Offset) XRAY_NEVER_INSTRUMENT
|
|
: Fd(Fd),
|
|
Start(Start),
|
|
Offset(Offset) {}
|
|
|
|
~ThreadExitFlusher() XRAY_NEVER_INSTRUMENT {
|
|
std::lock_guard<std::mutex> L(LogMutex);
|
|
if (Fd > 0 && Start != nullptr) {
|
|
retryingWriteAll(Fd, reinterpret_cast<char *>(Start),
|
|
reinterpret_cast<char *>(Start + Offset));
|
|
// 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(Fd);
|
|
}
|
|
}
|
|
};
|
|
|
|
} // namespace __xray
|
|
|
|
using namespace __xray;
|
|
|
|
void PrintToStdErr(const char *Buffer) XRAY_NEVER_INSTRUMENT {
|
|
fprintf(stderr, "%s", Buffer);
|
|
}
|
|
|
|
static int __xray_OpenLogFile() XRAY_NEVER_INSTRUMENT {
|
|
// FIXME: Figure out how to make this less stderr-dependent.
|
|
SetPrintfAndReportCallback(PrintToStdErr);
|
|
// Open a temporary file once for the log.
|
|
static char TmpFilename[256] = {};
|
|
static char TmpWildcardPattern[] = "XXXXXX";
|
|
auto Argv = GetArgv();
|
|
const char *Progname = Argv[0] == nullptr ? "(unknown)" : Argv[0];
|
|
const char *LastSlash = internal_strrchr(Progname, '/');
|
|
|
|
if (LastSlash != nullptr)
|
|
Progname = LastSlash + 1;
|
|
|
|
const int HalfLength = sizeof(TmpFilename) / 2 - sizeof(TmpWildcardPattern);
|
|
int NeededLength = internal_snprintf(TmpFilename, sizeof(TmpFilename),
|
|
"%.*s%.*s.%s",
|
|
HalfLength, flags()->xray_logfile_base,
|
|
HalfLength, Progname,
|
|
TmpWildcardPattern);
|
|
if (NeededLength > int(sizeof(TmpFilename))) {
|
|
Report("XRay log file name too long (%d): %s\n", NeededLength, TmpFilename);
|
|
return -1;
|
|
}
|
|
int Fd = mkstemp(TmpFilename);
|
|
if (Fd == -1) {
|
|
Report("XRay: Failed opening temporary file '%s'; not logging events.\n",
|
|
TmpFilename);
|
|
return -1;
|
|
}
|
|
if (Verbosity())
|
|
fprintf(stderr, "XRay: Log file in '%s'\n", TmpFilename);
|
|
|
|
// 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;
|
|
Header.Version = 1;
|
|
Header.Type = FileTypes::NAIVE_LOG;
|
|
Header.CycleFrequency = __xray::cycleFrequency();
|
|
|
|
// 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(Fd, reinterpret_cast<char *>(&Header),
|
|
reinterpret_cast<char *>(&Header) + sizeof(Header));
|
|
return Fd;
|
|
}
|
|
|
|
void __xray_InMemoryRawLog(int32_t FuncId,
|
|
XRayEntryType Type) XRAY_NEVER_INSTRUMENT {
|
|
using Buffer =
|
|
std::aligned_storage<sizeof(XRayRecord), alignof(XRayRecord)>::type;
|
|
static constexpr size_t BuffLen = 1024;
|
|
thread_local static Buffer InMemoryBuffer[BuffLen] = {};
|
|
thread_local static size_t Offset = 0;
|
|
static int Fd = __xray_OpenLogFile();
|
|
if (Fd == -1)
|
|
return;
|
|
thread_local __xray::ThreadExitFlusher Flusher(
|
|
Fd, reinterpret_cast<__xray::XRayRecord *>(InMemoryBuffer), Offset);
|
|
thread_local pid_t TId = syscall(SYS_gettid);
|
|
|
|
// First we get the useful data, and stuff it into the already aligned buffer
|
|
// through a pointer offset.
|
|
auto &R = reinterpret_cast<__xray::XRayRecord *>(InMemoryBuffer)[Offset];
|
|
R.RecordType = RecordTypes::NORMAL;
|
|
R.TSC = __xray::readTSC(R.CPU);
|
|
R.TId = TId;
|
|
R.Type = Type;
|
|
R.FuncId = FuncId;
|
|
++Offset;
|
|
if (Offset == BuffLen) {
|
|
std::lock_guard<std::mutex> L(LogMutex);
|
|
auto RecordBuffer = reinterpret_cast<__xray::XRayRecord *>(InMemoryBuffer);
|
|
retryingWriteAll(Fd, reinterpret_cast<char *>(RecordBuffer),
|
|
reinterpret_cast<char *>(RecordBuffer + Offset));
|
|
Offset = 0;
|
|
}
|
|
}
|
|
|
|
static auto Unused = [] {
|
|
if (flags()->xray_naive_log)
|
|
__xray_set_handler(__xray_InMemoryRawLog);
|
|
return true;
|
|
}();
|