b6dbe9a99c
Summary: It defined a couple of types (condition_t) which we don't use anymore, as we have c++11 goodies now. I remove these definitions. Also it unnecessarily included a couple of headers which weren't necessary for it's operation. I remove these, and place the includes in the relevant files (usually .cpp, usually in Host code) which use them. This allows us to reduce namespace pollution in most of the lldb files which don't need the OS-specific definitions. Reviewers: zturner, jingham Subscribers: ki.stfu, lldb-commits Differential Revision: https://reviews.llvm.org/D35113 llvm-svn: 308304
142 lines
4.4 KiB
C++
142 lines
4.4 KiB
C++
//===-- ProcessorTrace.h -------------------------------------- -*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef liblldb_ProcessorTrace_H_
|
|
#define liblldb_ProcessorTrace_H_
|
|
|
|
#include "lldb/Utility/Status.h"
|
|
#include "lldb/Utility/TraceOptions.h"
|
|
#include "lldb/lldb-types.h"
|
|
#include "llvm/ADT/DenseMap.h"
|
|
#include "llvm/ADT/DenseSet.h"
|
|
|
|
#include <linux/perf_event.h>
|
|
#include <sys/mman.h>
|
|
#include <unistd.h>
|
|
|
|
namespace lldb_private {
|
|
|
|
namespace process_linux {
|
|
|
|
// ---------------------------------------------------------------------
|
|
// This class keeps track of one tracing instance of
|
|
// Intel(R) Processor Trace on Linux OS. There is a map keeping track
|
|
// of different tracing instances on each thread, which enables trace
|
|
// gathering on a per thread level.
|
|
//
|
|
// The tracing instance is linked with a trace id. The trace id acts like
|
|
// a key to the tracing instance and trace manipulations could be
|
|
// performed using the trace id.
|
|
//
|
|
// The traace id could map to trace instances for a group of threads
|
|
// (spanning to all the threads in the process) or a single thread.
|
|
// The kernel interface for us is the perf_event_open.
|
|
// ---------------------------------------------------------------------
|
|
|
|
class ProcessorTraceMonitor;
|
|
typedef std::unique_ptr<ProcessorTraceMonitor> ProcessorTraceMonitorUP;
|
|
|
|
class ProcessorTraceMonitor {
|
|
|
|
class munmap_delete {
|
|
size_t m_length;
|
|
|
|
public:
|
|
munmap_delete(size_t length) : m_length(length) {}
|
|
void operator()(void *ptr) {
|
|
if (m_length)
|
|
munmap(ptr, m_length);
|
|
}
|
|
};
|
|
|
|
class file_close {
|
|
|
|
public:
|
|
file_close() = default;
|
|
void operator()(int *ptr) {
|
|
if (ptr == nullptr)
|
|
return;
|
|
if (*ptr == -1)
|
|
return;
|
|
close(*ptr);
|
|
std::default_delete<int>()(ptr);
|
|
}
|
|
};
|
|
|
|
std::unique_ptr<perf_event_mmap_page, munmap_delete> m_mmap_meta;
|
|
std::unique_ptr<uint8_t, munmap_delete> m_mmap_aux;
|
|
std::unique_ptr<int, file_close> m_fd;
|
|
|
|
// perf_event_mmap_page *m_mmap_base;
|
|
lldb::user_id_t m_traceid;
|
|
lldb::tid_t m_thread_id;
|
|
|
|
// Counter to track trace instances.
|
|
static lldb::user_id_t m_trace_num;
|
|
|
|
void SetTraceID(lldb::user_id_t traceid) { m_traceid = traceid; }
|
|
|
|
Status StartTrace(lldb::pid_t pid, lldb::tid_t tid,
|
|
const TraceOptions &config);
|
|
|
|
llvm::MutableArrayRef<uint8_t> GetAuxBuffer();
|
|
llvm::MutableArrayRef<uint8_t> GetDataBuffer();
|
|
|
|
ProcessorTraceMonitor()
|
|
: m_mmap_meta(nullptr, munmap_delete(0)),
|
|
m_mmap_aux(nullptr, munmap_delete(0)), m_fd(nullptr, file_close()),
|
|
m_traceid(LLDB_INVALID_UID), m_thread_id(LLDB_INVALID_THREAD_ID){};
|
|
|
|
void SetThreadID(lldb::tid_t tid) { m_thread_id = tid; }
|
|
|
|
public:
|
|
static Status GetCPUType(TraceOptions &config);
|
|
|
|
static llvm::Expected<ProcessorTraceMonitorUP>
|
|
Create(lldb::pid_t pid, lldb::tid_t tid, const TraceOptions &config,
|
|
bool useProcessSettings);
|
|
|
|
Status ReadPerfTraceAux(llvm::MutableArrayRef<uint8_t> &buffer,
|
|
size_t offset = 0);
|
|
|
|
Status ReadPerfTraceData(llvm::MutableArrayRef<uint8_t> &buffer,
|
|
size_t offset = 0);
|
|
|
|
~ProcessorTraceMonitor() = default;
|
|
|
|
lldb::tid_t GetThreadID() const { return m_thread_id; }
|
|
|
|
lldb::user_id_t GetTraceID() const { return m_traceid; }
|
|
|
|
Status GetTraceConfig(TraceOptions &config) const;
|
|
|
|
// ---------------------------------------------------------------------
|
|
/// Read data from a cyclic buffer
|
|
///
|
|
/// @param[in] [out] buf
|
|
/// Destination buffer, the buffer will be truncated to written size.
|
|
///
|
|
/// @param[in] src
|
|
/// Source buffer which must be a cyclic buffer.
|
|
///
|
|
/// @param[in] src_cyc_index
|
|
/// The index pointer (start of the valid data in the cyclic
|
|
/// buffer).
|
|
///
|
|
/// @param[in] offset
|
|
/// The offset to begin reading the data in the cyclic buffer.
|
|
// ---------------------------------------------------------------------
|
|
static void ReadCyclicBuffer(llvm::MutableArrayRef<uint8_t> &dst,
|
|
llvm::MutableArrayRef<uint8_t> src,
|
|
size_t src_cyc_index, size_t offset);
|
|
};
|
|
} // namespace process_linux
|
|
} // namespace lldb_private
|
|
#endif
|