[trace][intelpt] Support system-wide tracing [3] - Refactor IntelPTThreadTrace

[wallace]

Summary

I'm refactoring IntelPTThreadTrace into IntelPTSingleBufferTrace so that it can
both single threads or single cores. In this diff I'm basically renaming the
class, moving it to its own file, and removing all the pieces that are not used
along with some basic cleanup.

Besides that, as we'll soon support per-core trace buffer, I'm renaming the
data kind "threadTraceBuffer" to "traceBuffer".

[jj10306]

lldb/docs/lldb-gdb-remote.txt

498

If perCore tracing is enabled, how will this packet work since currently it requires a tid, but in perCore mode the trace data will contain all activity on that core, not just the specified thread?

lldb/source/Plugins/Process/Linux/IntelPTCollector.h

136

update doc since this is no longer tied to thread's traces

lldb/source/Plugins/Process/Linux/IntelPTSingleBufferTrace.cpp

293–299

The PerfEvent logic will need to be updated to support per CPU or per thread as it currently only supports per thread

lldb/source/Plugins/Process/Linux/IntelPTSingleBufferTrace.h

2

nit: thoughts on the name IntelPTTraceBuffer instead of IntelPTSingleBufferTrace? The current name is a bit wordy imo

42–49

Shouldn't this structure be general and have no notion of a tid since it could represent the buffer of a single thread or the buffer of a single CPU?
The way I see it, this structure simply wraps the buffer of a specific perf_event but has no notion of if it's for a specific tid or cpu.
Then you could have two subclasses, one for thread one for cpu, that inherit from this and have the additional context about the buffer. The inheritance may be overkill, but point I'm trying to make is that this structure should be agnostic to what "unit's" (thread or cpu) trace data it contains

[wallace]

lldb/docs/lldb-gdb-remote.txt

498

the jLLDBGetBinaryData packet has, for example, an optional tid argument that indicates the data correspond to a specific tid. I'll add a new optional parameter called core_id, so that we can associate a data chunk with a core_id

lldb/source/Plugins/Process/Linux/IntelPTCollector.h

136

good catch!

lldb/source/Plugins/Process/Linux/IntelPTSingleBufferTrace.cpp

293–299

yes, definitely

lldb/source/Plugins/Process/Linux/IntelPTSingleBufferTrace.h

2

this is intentional because the next file will be IntelPTMultiCoreTrace.h.

I also don't want to call this IntelPTTraceBuffer because it'll eventually have itrace data so the object won't be just a trace buffer.

But I'm open to any suggestions because I also don't like super verbose names

42–49

what I was thinking is to change this in a later diff to be like

Start(const TraceIntelPTStartRequest &request, Optional<lldb::tid_t> tid, Optional<int> core_id);

which seems to me generic enough for all possible use cases. LLDB couldn't support cgroups, so we are limited to tids and core_ids. With this, it seems to me that having two child classes it's a little bit too much because the only difference are just two lines of code where we specify the perf_event configuration for tid and core_id.

But if you insist in the clarify of the subclasses, I for sure can do it that way.

[wallace]

lldb/source/Plugins/Process/Linux/IntelPTCollector.h

136

actually the comment is right because this collection is in fact for threads

[wallace]

update test

[jj10306]

I'm assuming the changes to make the single buffer trace class generic for threads and cpu buffers is done in the next diff so stamping this, feel free to update with those changes if that is not the case

lldb/source/Plugins/Process/Linux/IntelPTSingleBufferTrace.h

42–49

What you suggested makes sense, do you plan make this change in this diff or is this in one of the future ones?

[wallace]

lldb/source/Plugins/Process/Linux/IntelPTSingleBufferTrace.h

42–49

it's in a later diff

lldb/docs/lldb-gdb-remote.txt

 //
 // NOTES
 //   - "traceThreads" includes all thread traced by both "process tracing" and
 //     "thread tracing".
 //
 // INTEL PT
 //
 //  Binary data kinds:
-//    - threadTraceBuffer: trace buffer for a thread.
+//    - traceBuffer: trace buffer for a thread or a core.
 //    - procfsCpuInfo: contents of the /proc/cpuinfo file.
 //
 //  Counter info kinds:
 //    tsc-perf-zero-conversion:
 //
 //    This field allows converting Intel processor's TSC values to a wall time.
 //    It is available through the Linux perf_event API when cap_user_time and cap_user_time_zero
 //    are set.

 //       Offset of the data in bytes.
 //   "size": <decimal>,
 //      Number of bytes in to read starting from the offset.
 //  }
 //
 // INTEL PT
 //
 //  Binary data kinds:
-//    - threadTraceBuffer: trace buffer for a thread.
+//    - traceBuffer: trace buffer for a thread or a core.
 //    - procfsCpuInfo: contents of the /proc/cpuinfo file.
 //----------------------------------------------------------------------
 
 send packet: jLLDBTraceGetBinaryData:{"type":<type>,"kind":<query>,"tid":<tid>,"offset":<offset>,"size":<size>}]
 read packet: <binary data>/E<error code>;AAAAAAAAA
 
 //----------------------------------------------------------------------
 // "qRegisterInfo<hex-reg-id>"

lldb/include/lldb/Utility/TraceIntelPTGDBRemotePackets.h

 #include <chrono>
 
 /// See docs/lldb-gdb-remote.txt for more information.
 namespace lldb_private {
 
 // List of data kinds used by jLLDBGetState and jLLDBGetBinaryData.
 struct IntelPTDataKinds {
   static const char *kProcFsCpuInfo;
-  static const char *kThreadTraceBuffer;
+  static const char *kTraceBuffer;
 };
 
 /// jLLDBTraceStart gdb-remote packet
 /// \{
 struct TraceIntelPTStartRequest : TraceStartRequest {
   /// Size in bytes to use for each thread's trace buffer.
   int64_t trace_buffer_size;
 

lldb/source/Plugins/Process/Linux/CMakeLists.txt

 add_lldb_library(lldbPluginProcessLinux
   IntelPTCollector.cpp
+  IntelPTSingleBufferTrace.cpp
   NativeProcessLinux.cpp
   NativeRegisterContextLinux.cpp
   NativeRegisterContextLinux_arm.cpp
   NativeRegisterContextLinux_arm64.cpp
   NativeRegisterContextLinux_ppc64le.cpp
   NativeRegisterContextLinux_s390x.cpp
   NativeRegisterContextLinux_x86_64.cpp
   NativeThreadLinux.cpp

lldb/source/Plugins/Process/Linux/IntelPTCollector.h

 //===-- IntelPTCollector.h -------------------------------------- -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_IntelPTCollector_H_
 #define liblldb_IntelPTCollector_H_
 
 #include "Perf.h"
 
+#include "IntelPTSingleBufferTrace.h"
+
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/TraceIntelPTGDBRemotePackets.h"
 #include "lldb/lldb-types.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 at thread level.
-///
-/// The kernel interface for us is the perf_event_open.
-class IntelPTThreadTrace;
-typedef std::unique_ptr<IntelPTThreadTrace> IntelPTThreadTraceUP;
-
-class IntelPTThreadTrace {
-public:
-  /// Create a new \a IntelPTThreadTrace and start tracing the thread.
-  ///
-  /// \param[in] pid
-  ///     The pid of the process whose thread will be traced.
-  ///
-  /// \param[in] tid
-  ///     The tid of the thread to be traced.
-  ///
-  /// \param[in] buffer_size
-  ///     Size of the thread buffer in bytes.
-  ///
-  /// \param[in] enable_tsc
-  ///     Whether to use enable TSC timestamps or not.
-  ///     More information in TraceIntelPT::GetStartConfigurationHelp().
-  ///
-  /// \param[in] psb_period
-  ///     This value defines the period in which PSB packets will be generated.
-  ///     More information in TraceIntelPT::GetStartConfigurationHelp().
-  ///
-  /// \return
-  ///   A \a IntelPTThreadTrace instance if tracing was successful, or
-  ///   an \a llvm::Error otherwise.
-  static llvm::Expected<IntelPTThreadTraceUP>
-  Create(lldb::pid_t pid, lldb::tid_t tid, size_t buffer_size, bool enable_tsc,
-         llvm::Optional<size_t> psb_period);
-
-  /// Create a \a perf_event_attr configured for
-  /// an IntelPT event.
-  ///
-  /// \return
-  ///   A \a perf_event_attr if successful,
-  ///   or an \a llvm::Error otherwise.
-  static llvm::Expected<perf_event_attr>
-  CreateIntelPTPerfEventConfiguration(bool enable_tsc,
-                                      llvm::Optional<size_t> psb_period);
-
-  /// Read the trace buffer of the currently traced thread.
-  ///
-  /// \param[in] offset
-  ///     Offset of the data to read.
-  ///
-  /// \param[in] size
-  ///     Number of bytes to read.
-  ///
-  /// \return
-  ///     A vector with the requested binary data. The vector will have the
-  ///     size of the requested \a size. Non-available positions will be
-  ///     filled with zeroes.
-  llvm::Expected<std::vector<uint8_t>> GetIntelPTBuffer(size_t offset,
-                                                        size_t size) const;
-
-  Status ReadPerfTraceAux(llvm::MutableArrayRef<uint8_t> &buffer,
-                          size_t offset = 0) const;
-
-  Status ReadPerfTraceData(llvm::MutableArrayRef<uint8_t> &buffer,
-                           size_t offset = 0) const;
-
-  /// Get the size in bytes of the aux section of the thread or process traced
-  /// by this object.
-  size_t GetTraceBufferSize() 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::ArrayRef<uint8_t> src,
-                               size_t src_cyc_index, size_t offset);
-
-  /// Return the thread-specific part of the jLLDBTraceGetState packet.
-  TraceThreadState GetState() const;
-
-private:
-  /// Construct new \a IntelPTThreadTrace. Users are supposed to create
-  /// instances of this class via the \a Create() method and not invoke this one
-  /// directly.
-  ///
-  /// \param[in] perf_event
-  ///   perf event configured for IntelPT.
-  ///
-  /// \param[in] tid
-  ///   The thread being traced.
-  IntelPTThreadTrace(PerfEvent &&perf_event, lldb::tid_t tid)
-      : m_perf_event(std::move(perf_event)), m_tid(tid) {}
-
-  /// perf event configured for IntelPT.
-  PerfEvent m_perf_event;
-  /// The thread being traced.
-  lldb::tid_t m_tid;
-};
-
 /// Manages a list of thread traces.
 class IntelPTThreadTraceCollection {
 public:
-  IntelPTThreadTraceCollection(lldb::pid_t pid) : m_pid(pid) {}
+  IntelPTThreadTraceCollection() {}
 
   /// Dispose of all traces
   void Clear();
 
   bool TracesThread(lldb::tid_t tid) const;
 
   size_t GetTotalBufferSize() const;
 
   std::vector<TraceThreadState> GetThreadStates() const;
 
-  llvm::Expected<const IntelPTThreadTrace &>
+  llvm::Expected<const IntelPTSingleBufferTrace &>
   GetTracedThread(lldb::tid_t tid) const;
 
   llvm::Error TraceStart(lldb::tid_t tid,
                          const TraceIntelPTStartRequest &request);
 
   llvm::Error TraceStop(lldb::tid_t tid);
 
 private:
-  lldb::pid_t m_pid;
-  llvm::DenseMap<lldb::tid_t, IntelPTThreadTraceUP> m_thread_traces;
+  llvm::DenseMap<lldb::tid_t, IntelPTSingleBufferTraceUP> m_thread_traces;
   /// Total actual thread buffer size in bytes
   size_t m_total_buffer_size = 0;
 };
 
 /// Manages a "process trace" instance.
 class IntelPTProcessTrace {
 public:
-  IntelPTProcessTrace(lldb::pid_t pid, const TraceIntelPTStartRequest &request)
-      : m_thread_traces(pid), m_tracing_params(request) {}
+  IntelPTProcessTrace(const TraceIntelPTStartRequest &request)
+      : m_tracing_params(request) {}
 
   bool TracesThread(lldb::tid_t tid) const;
 
   const IntelPTThreadTraceCollection &GetThreadTraces() const;
 
   llvm::Error TraceStart(lldb::tid_t tid);
 
   llvm::Error TraceStop(lldb::tid_t tid);
 
 private:
   IntelPTThreadTraceCollection m_thread_traces;
   /// Params used to trace threads when the user started "process tracing".
   TraceIntelPTStartRequest m_tracing_params;
 };
 
 /// Main class that manages intel-pt process and thread tracing.
 class IntelPTCollector {
 public:
-  IntelPTCollector(lldb::pid_t pid);
+  IntelPTCollector();
 
   static bool IsSupported();
 
   /// If "process tracing" is enabled, then trace the given thread.
   llvm::Error OnThreadCreated(lldb::tid_t tid);
 
   /// Stops tracing a tracing upon a destroy event.
   llvm::Error OnThreadDestroyed(lldb::tid_t tid);

 
 private:
   llvm::Error TraceStop(lldb::tid_t tid);
 
   /// Start tracing a specific thread.
   llvm::Error TraceStart(lldb::tid_t tid,
                          const TraceIntelPTStartRequest &request);
 
-  llvm::Expected<const IntelPTThreadTrace &>
+  llvm::Expected<const IntelPTSingleBufferTrace &>
   GetTracedThread(lldb::tid_t tid) const;
 
   bool IsProcessTracingEnabled() const;
 
   void ClearProcessTracing();
 
-  lldb::pid_t m_pid;
   /// Threads traced due to "thread tracing"
   IntelPTThreadTraceCollection m_thread_traces;
   /// Threads traced due to "process tracing". Only one active "process tracing"
   /// instance is assumed for a single process.
   llvm::Optional<IntelPTProcessTrace> m_process_trace;
   /// TSC to wall time conversion.
   TraceTscConversionUP m_tsc_conversion;
 };
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // liblldb_IntelPTCollector_H_

lldb/source/Plugins/Process/Linux/IntelPTCollector.cpp

 #include <sys/ioctl.h>
 #include <sys/syscall.h>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace process_linux;
 using namespace llvm;
 
-const char *kOSEventIntelPTTypeFile =
-    "/sys/bus/event_source/devices/intel_pt/type";
-
-const char *kPSBPeriodCapFile =
-    "/sys/bus/event_source/devices/intel_pt/caps/psb_cyc";
-
-const char *kPSBPeriodValidValuesFile =
-    "/sys/bus/event_source/devices/intel_pt/caps/psb_periods";
-
-const char *kTSCBitOffsetFile =
-    "/sys/bus/event_source/devices/intel_pt/format/tsc";
-
-const char *kPSBPeriodBitOffsetFile =
-    "/sys/bus/event_source/devices/intel_pt/format/psb_period";
-
-enum IntelPTConfigFileType {
-  Hex = 0,
-  // 0 or 1
-  ZeroOne,
-  Decimal,
-  // a bit index file always starts with the prefix config: following by an int,
-  // which represents the offset of the perf_event_attr.config value where to
-  // store a given configuration.
-  BitOffset
-};
-
-static Expected<uint32_t> ReadIntelPTConfigFile(const char *file,
-                                                IntelPTConfigFileType type) {
-  ErrorOr<std::unique_ptr<MemoryBuffer>> stream =
-      MemoryBuffer::getFileAsStream(file);
-
-  if (!stream)
-    return createStringError(inconvertibleErrorCode(),
-                             "Can't open the file '%s'", file);
-
-  uint32_t value = 0;
-  StringRef text_buffer = stream.get()->getBuffer();
-
-  if (type == BitOffset) {
-    const char *prefix = "config:";
-    if (!text_buffer.startswith(prefix))
-      return createStringError(inconvertibleErrorCode(),
-                               "The file '%s' contents doesn't start with '%s'",
-                               file, prefix);
-    text_buffer = text_buffer.substr(strlen(prefix));
-  }
-
-  auto getRadix = [&]() {
-    switch (type) {
-    case Hex:
-      return 16;
-    case ZeroOne:
-    case Decimal:
-    case BitOffset:
-      return 10;
-    }
-    llvm_unreachable("Fully covered switch above!");
-  };
-
-  auto createError = [&](const char *expected_value_message) {
-    return createStringError(
-        inconvertibleErrorCode(),
-        "The file '%s' has an invalid value. It should be %s.", file,
-        expected_value_message);
-  };
-
-  if (text_buffer.trim().consumeInteger(getRadix(), value) ||
-      (type == ZeroOne && value != 0 && value != 1)) {
-    switch (type) {
-    case Hex:
-      return createError("an unsigned hexadecimal int");
-    case ZeroOne:
-      return createError("0 or 1");
-    case Decimal:
-    case BitOffset:
-      return createError("an unsigned decimal int");
-    }
-  }
-  return value;
-}
-
-/// Return the Linux perf event type for Intel PT.
-static Expected<uint32_t> GetOSEventType() {
-  return ReadIntelPTConfigFile(kOSEventIntelPTTypeFile,
-                               IntelPTConfigFileType::Decimal);
-}
-
-static Error CheckPsbPeriod(size_t psb_period) {
-  Expected<uint32_t> cap =
-      ReadIntelPTConfigFile(kPSBPeriodCapFile, IntelPTConfigFileType::ZeroOne);
-  if (!cap)
-    return cap.takeError();
-  if (*cap == 0)
-    return createStringError(inconvertibleErrorCode(),
-                             "psb_period is unsupported in the system.");
-
-  Expected<uint32_t> valid_values = ReadIntelPTConfigFile(
-      kPSBPeriodValidValuesFile, IntelPTConfigFileType::Hex);
-  if (!valid_values)
-    return valid_values.takeError();
-
-  if (valid_values.get() & (1 << psb_period))
-    return Error::success();
-
-  std::ostringstream error;
-  // 0 is always a valid value
-  error << "Invalid psb_period. Valid values are: 0";
-  uint32_t mask = valid_values.get();
-  while (mask) {
-    int index = __builtin_ctz(mask);
-    if (index > 0)
-      error << ", " << index;
-    // clear the lowest bit
-    mask &= mask - 1;
-  }
-  error << ".";
-  return createStringError(inconvertibleErrorCode(), error.str().c_str());
-}
-
-size_t IntelPTThreadTrace::GetTraceBufferSize() const {
-#ifndef PERF_ATTR_SIZE_VER5
-  llvm_unreachable("Intel PT Linux perf event not supported");
-#else
-  return m_perf_event.GetAuxBuffer().size();
-#endif
-}
-
-static Expected<uint64_t>
-GeneratePerfEventConfigValue(bool enable_tsc, Optional<size_t> psb_period) {
-  uint64_t config = 0;
-  // tsc is always supported
-  if (enable_tsc) {
-    if (Expected<uint32_t> offset = ReadIntelPTConfigFile(
-            kTSCBitOffsetFile, IntelPTConfigFileType::BitOffset))
-      config |= 1 << *offset;
-    else
-      return offset.takeError();
-  }
-  if (psb_period) {
-    if (Error error = CheckPsbPeriod(*psb_period))
-      return std::move(error);
-
-    if (Expected<uint32_t> offset = ReadIntelPTConfigFile(
-            kPSBPeriodBitOffsetFile, IntelPTConfigFileType::BitOffset))
-      config |= *psb_period << *offset;
-    else
-      return offset.takeError();
-  }
-  return config;
-}
-
-llvm::Expected<perf_event_attr>
-IntelPTThreadTrace::CreateIntelPTPerfEventConfiguration(
-    bool enable_tsc, Optional<size_t> psb_period) {
-  perf_event_attr attr;
-  memset(&attr, 0, sizeof(attr));
-  attr.size = sizeof(attr);
-  attr.exclude_kernel = 1;
-  attr.sample_type = PERF_SAMPLE_TIME;
-  attr.sample_id_all = 1;
-  attr.exclude_hv = 1;
-  attr.exclude_idle = 1;
-  attr.mmap = 1;
-
-  if (Expected<uint64_t> config_value =
-          GeneratePerfEventConfigValue(enable_tsc, psb_period)) {
-    attr.config = *config_value;
-  } else {
-    return config_value.takeError();
-  }
-
-  if (Expected<uint32_t> intel_pt_type = GetOSEventType()) {
-    attr.type = *intel_pt_type;
-  } else {
-    return intel_pt_type.takeError();
-  }
-
-  return attr;
-}
-
-llvm::Expected<IntelPTThreadTraceUP>
-IntelPTThreadTrace::Create(lldb::pid_t pid, lldb::tid_t tid, size_t buffer_size,
-                           bool enable_tsc, Optional<size_t> psb_period) {
-#ifndef PERF_ATTR_SIZE_VER5
-  llvm_unreachable("Intel PT Linux perf event not supported");
-#else
-  Log *log = GetLog(POSIXLog::Ptrace);
-
-  LLDB_LOG(log, "called thread id {0}", tid);
-
-  if (__builtin_popcount(buffer_size) != 1 || buffer_size < 4096) {
-    return createStringError(
-        inconvertibleErrorCode(),
-        "The trace buffer size must be a power of 2 greater than or equal to "
-        "4096 (2^12) bytes. It was %" PRIu64 ".",
-        buffer_size);
-  }
-  uint64_t page_size = getpagesize();
-  uint64_t buffer_numpages = static_cast<uint64_t>(
-      llvm::PowerOf2Floor((buffer_size + page_size - 1) / page_size));
-
-  Expected<perf_event_attr> attr =
-      IntelPTThreadTrace::CreateIntelPTPerfEventConfiguration(enable_tsc,
-                                                              psb_period);
-  if (!attr)
-    return attr.takeError();
-
-  LLDB_LOG(log, "buffer size {0} ", buffer_size);
-
-  if (Expected<PerfEvent> perf_event = PerfEvent::Init(*attr, tid)) {
-    if (Error mmap_err = perf_event->MmapMetadataAndBuffers(buffer_numpages,
-                                                            buffer_numpages)) {
-      return std::move(mmap_err);
-    }
-    return IntelPTThreadTraceUP(
-        new IntelPTThreadTrace(std::move(*perf_event), tid));
-  } else {
-    return perf_event.takeError();
-  }
-#endif
-}
-
-Expected<std::vector<uint8_t>>
-IntelPTThreadTrace::GetIntelPTBuffer(size_t offset, size_t size) const {
-  std::vector<uint8_t> data(size, 0);
-  MutableArrayRef<uint8_t> buffer_ref(data);
-  Status error = ReadPerfTraceAux(buffer_ref, 0);
-  if (error.Fail())
-    return error.ToError();
-  return data;
-}
-
-Status
-IntelPTThreadTrace::ReadPerfTraceAux(llvm::MutableArrayRef<uint8_t> &buffer,
-                                     size_t offset) const {
-#ifndef PERF_ATTR_SIZE_VER5
-  llvm_unreachable("perf event not supported");
-#else
-  auto fd = m_perf_event.GetFd();
-  perf_event_mmap_page &mmap_metadata = m_perf_event.GetMetadataPage();
-  // Disable the perf event to force a flush out of the CPU's internal buffer.
-  // Besides, we can guarantee that the CPU won't override any data as we are
-  // reading the buffer.
-  //
-  // The Intel documentation says:
-  //
-  // Packets are first buffered internally and then written out asynchronously.
-  // To collect packet output for postprocessing, a collector needs first to
-  // ensure that all packet data has been flushed from internal buffers.
-  // Software can ensure this by stopping packet generation by clearing
-  // IA32_RTIT_CTL.TraceEn (see “Disabling Packet Generation” in
-  // Section 35.2.7.2).
-  //
-  // This is achieved by the PERF_EVENT_IOC_DISABLE ioctl request, as mentioned
-  // in the man page of perf_event_open.
-  ioctl(fd, PERF_EVENT_IOC_DISABLE);
-
-  Log *log = GetLog(POSIXLog::Ptrace);
-  Status error;
-  uint64_t head = mmap_metadata.aux_head;
-
-  LLDB_LOG(log, "Aux size -{0} , Head - {1}", mmap_metadata.aux_size, head);
-
-  /**
-   * When configured as ring buffer, the aux buffer keeps wrapping around
-   * the buffer and its not possible to detect how many times the buffer
-   * wrapped. Initially the buffer is filled with zeros,as shown below
-   * so in order to get complete buffer we first copy firstpartsize, followed
-   * by any left over part from beginning to aux_head
-   *
-   * aux_offset [d,d,d,d,d,d,d,d,0,0,0,0,0,0,0,0,0,0,0] aux_size
-   *                 aux_head->||<- firstpartsize  ->|
-   *
-   * */
-
-  ReadCyclicBuffer(buffer, m_perf_event.GetAuxBuffer(),
-                   static_cast<size_t>(head), offset);
-  LLDB_LOG(log, "ReadCyclic Buffer Done");
-
-  // Reenable tracing now we have read the buffer
-  ioctl(fd, PERF_EVENT_IOC_ENABLE);
-  return error;
-#endif
-}
-
-Status
-IntelPTThreadTrace::ReadPerfTraceData(llvm::MutableArrayRef<uint8_t> &buffer,
-                                      size_t offset) const {
-#ifndef PERF_ATTR_SIZE_VER5
-  llvm_unreachable("perf event not supported");
-#else
-  Log *log = GetLog(POSIXLog::Ptrace);
-  uint64_t bytes_remaining = buffer.size();
-  Status error;
-
-  perf_event_mmap_page &mmap_metadata = m_perf_event.GetMetadataPage();
-  uint64_t head = mmap_metadata.data_head;
-
-  /*
-   * The data buffer and aux buffer have different implementations
-   * with respect to their definition of head pointer. In the case
-   * of Aux data buffer the head always wraps around the aux buffer
-   * and we don't need to care about it, whereas the data_head keeps
-   * increasing and needs to be wrapped by modulus operator
-   */
-
-  LLDB_LOG(log, "bytes_remaining - {0}", bytes_remaining);
-
-  auto data_buffer = m_perf_event.GetDataBuffer();
-
-  if (head > data_buffer.size()) {
-    head = head % data_buffer.size();
-    LLDB_LOG(log, "Data size -{0} Head - {1}", mmap_metadata.data_size, head);
-
-    ReadCyclicBuffer(buffer, data_buffer, static_cast<size_t>(head), offset);
-    bytes_remaining -= buffer.size();
-  } else {
-    LLDB_LOG(log, "Head - {0}", head);
-    if (offset >= head) {
-      LLDB_LOG(log, "Invalid Offset ");
-      error.SetErrorString("invalid offset");
-      buffer = buffer.slice(buffer.size());
-      return error;
-    }
-
-    auto data = data_buffer.slice(offset, (head - offset));
-    auto remaining = std::copy(data.begin(), data.end(), buffer.begin());
-    bytes_remaining -= (remaining - buffer.begin());
-  }
-  buffer = buffer.drop_back(bytes_remaining);
-  return error;
-#endif
-}
-
-void IntelPTThreadTrace::ReadCyclicBuffer(llvm::MutableArrayRef<uint8_t> &dst,
-                                          llvm::ArrayRef<uint8_t> src,
-                                          size_t src_cyc_index, size_t offset) {
-
-  Log *log = GetLog(POSIXLog::Ptrace);
-
-  if (dst.empty() || src.empty()) {
-    dst = dst.drop_back(dst.size());
-    return;
-  }
-
-  if (dst.data() == nullptr || src.data() == nullptr) {
-    dst = dst.drop_back(dst.size());
-    return;
-  }
-
-  if (src_cyc_index > src.size()) {
-    dst = dst.drop_back(dst.size());
-    return;
-  }
-
-  if (offset >= src.size()) {
-    LLDB_LOG(log, "Too Big offset ");
-    dst = dst.drop_back(dst.size());
-    return;
-  }
-
-  llvm::SmallVector<ArrayRef<uint8_t>, 2> parts = {
-      src.slice(src_cyc_index), src.take_front(src_cyc_index)};
-
-  if (offset > parts[0].size()) {
-    parts[1] = parts[1].slice(offset - parts[0].size());
-    parts[0] = parts[0].drop_back(parts[0].size());
-  } else if (offset == parts[0].size()) {
-    parts[0] = parts[0].drop_back(parts[0].size());
-  } else {
-    parts[0] = parts[0].slice(offset);
-  }
-  auto next = dst.begin();
-  auto bytes_left = dst.size();
-  for (auto part : parts) {
-    size_t chunk_size = std::min(part.size(), bytes_left);
-    next = std::copy_n(part.begin(), chunk_size, next);
-    bytes_left -= chunk_size;
-  }
-  dst = dst.drop_back(bytes_left);
-}
-
-TraceThreadState IntelPTThreadTrace::GetState() const {
-  return {static_cast<int64_t>(m_tid),
-          {TraceBinaryData{IntelPTDataKinds::kThreadTraceBuffer,
-                           static_cast<int64_t>(GetTraceBufferSize())}}};
-}
-
 /// IntelPTThreadTraceCollection
 
 bool IntelPTThreadTraceCollection::TracesThread(lldb::tid_t tid) const {
   return m_thread_traces.count(tid);
 }
 
 Error IntelPTThreadTraceCollection::TraceStop(lldb::tid_t tid) {
   auto it = m_thread_traces.find(tid);
   if (it == m_thread_traces.end())
     return createStringError(inconvertibleErrorCode(),
                              "Thread %" PRIu64 " not currently traced", tid);
   m_total_buffer_size -= it->second->GetTraceBufferSize();
   m_thread_traces.erase(tid);
   return Error::success();
 }
 
 Error IntelPTThreadTraceCollection::TraceStart(
     lldb::tid_t tid, const TraceIntelPTStartRequest &request) {
   if (TracesThread(tid))
     return createStringError(inconvertibleErrorCode(),
                              "Thread %" PRIu64 " already traced", tid);
 
-  Expected<IntelPTThreadTraceUP> trace_up = IntelPTThreadTrace::Create(
-      m_pid, tid, request.trace_buffer_size, request.enable_tsc,
-      request.psb_period.map([](int64_t period) { return (size_t)period; }));
+  Expected<IntelPTSingleBufferTraceUP> trace_up =
+      IntelPTSingleBufferTrace::Start(request, tid);
   if (!trace_up)
     return trace_up.takeError();
 
   m_total_buffer_size += (*trace_up)->GetTraceBufferSize();
   m_thread_traces.try_emplace(tid, std::move(*trace_up));
   return Error::success();
 }
 
 size_t IntelPTThreadTraceCollection::GetTotalBufferSize() const {
   return m_total_buffer_size;
 }
 
 std::vector<TraceThreadState>
 IntelPTThreadTraceCollection::GetThreadStates() const {
   std::vector<TraceThreadState> states;
   for (const auto &it : m_thread_traces)
-    states.push_back(it.second->GetState());
+    states.push_back({static_cast<int64_t>(it.first),
+                      {TraceBinaryData{IntelPTDataKinds::kTraceBuffer,
+                                       static_cast<int64_t>(
+                                           it.second->GetTraceBufferSize())}}});
   return states;
 }
 
-Expected<const IntelPTThreadTrace &>
+Expected<const IntelPTSingleBufferTrace &>
 IntelPTThreadTraceCollection::GetTracedThread(lldb::tid_t tid) const {
   auto it = m_thread_traces.find(tid);
   if (it == m_thread_traces.end())
     return createStringError(inconvertibleErrorCode(),
                              "Thread %" PRIu64 " not currently traced", tid);
   return *it->second.get();
 }
 

 
 const IntelPTThreadTraceCollection &
 IntelPTProcessTrace::GetThreadTraces() const {
   return m_thread_traces;
 }
 
 /// IntelPTCollector
 
-IntelPTCollector::IntelPTCollector(lldb::pid_t pid)
-    : m_pid(pid), m_thread_traces(pid) {
+IntelPTCollector::IntelPTCollector() {
   if (Expected<LinuxPerfZeroTscConversion> tsc_conversion =
           LoadPerfTscConversionParameters())
     m_tsc_conversion =
         std::make_unique<LinuxPerfZeroTscConversion>(*tsc_conversion);
   else
     LLDB_LOG_ERROR(GetLog(POSIXLog::Trace), tsc_conversion.takeError(),
                    "unable to load TSC to wall time conversion: {0}");
 }
if (IsProcessTracingEnabled()) {
       return createStringError(
           inconvertibleErrorCode(),
           "Process currently traced. Stop process tracing first");
     }
     if (request.per_core_tracing.getValueOr(false)) {
       return createStringError(inconvertibleErrorCode(),
                                "Per-core tracing is not supported.");
     }
-    m_process_trace = IntelPTProcessTrace(m_pid, request);
+    m_process_trace = IntelPTProcessTrace(request);
 
     Error error = Error::success();
     for (lldb::tid_t tid : process_threads)
       error = joinErrors(std::move(error), m_process_trace->TraceStart(tid));
     return error;
   } else {
     Error error = Error::success();
     for (int64_t tid : *request.tids)
Expected<json::Value> IntelPTCollector::GetState() const {
   if (IsProcessTracingEnabled()) {
     thread_states = m_process_trace->GetThreadTraces().GetThreadStates();
     state.tracedThreads.insert(state.tracedThreads.end(), thread_states.begin(),
                                thread_states.end());
   }
   return toJSON(state);
 }
 
-Expected<const IntelPTThreadTrace &>
+Expected<const IntelPTSingleBufferTrace &>
 IntelPTCollector::GetTracedThread(lldb::tid_t tid) const {
   if (IsProcessTracingEnabled() && m_process_trace->TracesThread(tid))
     return m_process_trace->GetThreadTraces().GetTracedThread(tid);
   return m_thread_traces.GetTracedThread(tid);
 }
 
 Expected<std::vector<uint8_t>>
 IntelPTCollector::GetBinaryData(const TraceGetBinaryDataRequest &request) const {
-  if (request.kind == IntelPTDataKinds::kThreadTraceBuffer) {
-    if (Expected<const IntelPTThreadTrace &> trace =
+  if (request.kind == IntelPTDataKinds::kTraceBuffer) {
+    if (Expected<const IntelPTSingleBufferTrace &> trace =
             GetTracedThread(*request.tid))
-      return trace->GetIntelPTBuffer(request.offset, request.size);
+      return trace->GetTraceBuffer(request.offset, request.size);
     else
       return trace.takeError();
   } else if (request.kind == IntelPTDataKinds::kProcFsCpuInfo) {
     return GetProcfsCpuInfo();
   }
   return createStringError(inconvertibleErrorCode(),
                            "Unsuported trace binary data kind: %s",
                            request.kind.c_str());
 }
 
 void IntelPTCollector::ClearProcessTracing() { m_process_trace = None; }
 
 bool IntelPTCollector::IsSupported() {
-  Expected<uint32_t> intel_pt_type = GetOSEventType();
-  if (!intel_pt_type) {
+  if (Expected<uint32_t> intel_pt_type = GetIntelPTOSEventType()) {
+    return true;
+  } else {
     llvm::consumeError(intel_pt_type.takeError());
     return false;
   }
-  return true;
 }
 
 bool IntelPTCollector::IsProcessTracingEnabled() const {
   return (bool)m_process_trace;
 }
 
 void IntelPTCollector::Clear() {
   ClearProcessTracing();
   m_thread_traces.Clear();
 }

lldb/source/Plugins/Process/Linux/IntelPTSingleBufferTrace.h

+//===-- IntelPTSingleBufferTrace.h ---------------------------- -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_IntelPTSingleBufferTrace_H_
+#define liblldb_IntelPTSingleBufferTrace_H_
+
+#include "Perf.h"
+
+#include "lldb/Utility/TraceIntelPTGDBRemotePackets.h"
+#include "lldb/lldb-types.h"
+
+#include "llvm/Support/Error.h"
+
+#include <memory>
+
+namespace lldb_private {
+namespace process_linux {
+
+llvm::Expected<uint32_t> GetIntelPTOSEventType();
+
+class IntelPTTrace;
+class IntelPTSingleBufferTrace;
+
+using IntelPTThreadTraceUP = std::unique_ptr<IntelPTTrace>;
+using IntelPTSingleBufferTraceUP = std::unique_ptr<IntelPTSingleBufferTrace>;
+
+/// This class wraps a single perf event collecting intel pt data in a single
+/// buffer.
+class IntelPTSingleBufferTrace {
+public:
+  /// Start tracing using a single Intel PT trace buffer.
+  ///
+  /// \param[in] request
+  ///     Intel PT configuration parameters.
+  ///
+  /// \param[in] tid
+  ///     The tid of the thread to be traced.
+  ///
+  /// \return
+  ///   A \a IntelPTSingleBufferTrace instance if tracing was successful, or
+  ///   an \a llvm::Error otherwise.
+  static llvm::Expected<IntelPTSingleBufferTraceUP>
+  Start(const TraceIntelPTStartRequest &request, lldb::tid_t tid);
+
+  /// \return
+  ///    The bytes requested by a jLLDBTraceGetBinaryData packet that was routed
+  ///    to this trace instace.
+  llvm::Expected<std::vector<uint8_t>>
+  GetBinaryData(const TraceGetBinaryDataRequest &request) const;
+
+  /// Read the trace buffer managed by this trace instance.
+  ///
+  /// \param[in] offset
+  ///     Offset of the data to read.
+  ///
+  /// \param[in] size
+  ///     Number of bytes to read.
+  ///
+  /// \return
+  ///     A vector with the requested binary data. The vector will have the
+  ///     size of the requested \a size. Non-available positions will be
+  ///     filled with zeroes.
+  llvm::Expected<std::vector<uint8_t>> GetTraceBuffer(size_t offset,
+                                                      size_t size) const;
+
+  /// \return
+  ///   The total the size in bytes used by the trace buffer managed by this
+  ///   trace instance.
+  size_t GetTraceBufferSize() const;
+
+private:
+  /// Construct new \a IntelPTSingleBufferThreadTrace. Users are supposed to
+  /// create instances of this class via the \a Start() method and not invoke
+  /// this one directly.
+  ///
+  /// \param[in] perf_event
+  ///   perf event configured for IntelPT.
+  ///
+  /// \param[in] tid
+  ///   The thread being traced.
+  IntelPTSingleBufferTrace(PerfEvent &&perf_event, lldb::tid_t tid)
+      : m_perf_event(std::move(perf_event)) {}
+
+  /// perf event configured for IntelPT.
+  PerfEvent m_perf_event;
+};
+
+} // namespace process_linux
+} // namespace lldb_private
+
+#endif // liblldb_IntelPTSingleBufferTrace_H_

lldb/source/Plugins/Process/Linux/IntelPTSingleBufferTrace.cpp

+//===-- IntelPTSingleBufferTrace.cpp --------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "IntelPTSingleBufferTrace.h"
+
+#include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
+#include "lldb/Utility/Status.h"
+#include "lldb/Utility/StreamString.h"
+
+#include "llvm/Support/Host.h"
+#include "llvm/Support/MemoryBuffer.h"
+
+#include <sstream>
+
+#include <linux/perf_event.h>
+#include <sys/ioctl.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace process_linux;
+using namespace llvm;
+
+const char *kOSEventIntelPTTypeFile =
+    "/sys/bus/event_source/devices/intel_pt/type";
+
+const char *kPSBPeriodCapFile =
+    "/sys/bus/event_source/devices/intel_pt/caps/psb_cyc";
+
+const char *kPSBPeriodValidValuesFile =
+    "/sys/bus/event_source/devices/intel_pt/caps/psb_periods";
+
+const char *kPSBPeriodBitOffsetFile =
+    "/sys/bus/event_source/devices/intel_pt/format/psb_period";
+
+const char *kTSCBitOffsetFile =
+    "/sys/bus/event_source/devices/intel_pt/format/tsc";
+
+enum IntelPTConfigFileType {
+  Hex = 0,
+  // 0 or 1
+  ZeroOne,
+  Decimal,
+  // a bit index file always starts with the prefix config: following by an int,
+  // which represents the offset of the perf_event_attr.config value where to
+  // store a given configuration.
+  BitOffset
+};
+
+static Expected<uint32_t> ReadIntelPTConfigFile(const char *file,
+                                                IntelPTConfigFileType type) {
+  ErrorOr<std::unique_ptr<MemoryBuffer>> stream =
+      MemoryBuffer::getFileAsStream(file);
+
+  if (!stream)
+    return createStringError(inconvertibleErrorCode(),
+                             "Can't open the file '%s'", file);
+
+  uint32_t value = 0;
+  StringRef text_buffer = stream.get()->getBuffer();
+
+  if (type == BitOffset) {
+    const char *prefix = "config:";
+    if (!text_buffer.startswith(prefix))
+      return createStringError(inconvertibleErrorCode(),
+                               "The file '%s' contents doesn't start with '%s'",
+                               file, prefix);
+    text_buffer = text_buffer.substr(strlen(prefix));
+  }
+
+  auto getRadix = [&]() {
+    switch (type) {
+    case Hex:
+      return 16;
+    case ZeroOne:
+    case Decimal:
+    case BitOffset:
+      return 10;
+    }
+    llvm_unreachable("Fully covered switch above!");
+  };
+
+  auto createError = [&](const char *expected_value_message) {
+    return createStringError(
+        inconvertibleErrorCode(),
+        "The file '%s' has an invalid value. It should be %s.", file,
+        expected_value_message);
+  };
+
+  if (text_buffer.trim().consumeInteger(getRadix(), value) ||
+      (type == ZeroOne && value != 0 && value != 1)) {
+    switch (type) {
+    case Hex:
+      return createError("an unsigned hexadecimal int");
+    case ZeroOne:
+      return createError("0 or 1");
+    case Decimal:
+    case BitOffset:
+      return createError("an unsigned decimal int");
+    }
+  }
+  return value;
+}
+
+/// Return the Linux perf event type for Intel PT.
+Expected<uint32_t> process_linux::GetIntelPTOSEventType() {
+  return ReadIntelPTConfigFile(kOSEventIntelPTTypeFile,
+                               IntelPTConfigFileType::Decimal);
+}
+
+static Error CheckPsbPeriod(size_t psb_period) {
+  Expected<uint32_t> cap =
+      ReadIntelPTConfigFile(kPSBPeriodCapFile, IntelPTConfigFileType::ZeroOne);
+  if (!cap)
+    return cap.takeError();
+  if (*cap == 0)
+    return createStringError(inconvertibleErrorCode(),
+                             "psb_period is unsupported in the system.");
+
+  Expected<uint32_t> valid_values = ReadIntelPTConfigFile(
+      kPSBPeriodValidValuesFile, IntelPTConfigFileType::Hex);
+  if (!valid_values)
+    return valid_values.takeError();
+
+  if (valid_values.get() & (1 << psb_period))
+    return Error::success();
+
+  std::ostringstream error;
+  // 0 is always a valid value
+  error << "Invalid psb_period. Valid values are: 0";
+  uint32_t mask = valid_values.get();
+  while (mask) {
+    int index = __builtin_ctz(mask);
+    if (index > 0)
+      error << ", " << index;
+    // clear the lowest bit
+    mask &= mask - 1;
+  }
+  error << ".";
+  return createStringError(inconvertibleErrorCode(), error.str().c_str());
+}
+
+static Expected<uint64_t>
+GeneratePerfEventConfigValue(bool enable_tsc, Optional<size_t> psb_period) {
+  uint64_t config = 0;
+  // tsc is always supported
+  if (enable_tsc) {
+    if (Expected<uint32_t> offset = ReadIntelPTConfigFile(
+            kTSCBitOffsetFile, IntelPTConfigFileType::BitOffset))
+      config |= 1 << *offset;
+    else
+      return offset.takeError();
+  }
+  if (psb_period) {
+    if (Error error = CheckPsbPeriod(*psb_period))
+      return std::move(error);
+
+    if (Expected<uint32_t> offset = ReadIntelPTConfigFile(
+            kPSBPeriodBitOffsetFile, IntelPTConfigFileType::BitOffset))
+      config |= *psb_period << *offset;
+    else
+      return offset.takeError();
+  }
+  return config;
+}
+
+/// Create a \a perf_event_attr configured for
+/// an IntelPT event.
+///
+/// \return
+///   A \a perf_event_attr if successful,
+///   or an \a llvm::Error otherwise.
+static Expected<perf_event_attr>
+CreateIntelPTPerfEventConfiguration(bool enable_tsc,
+                                    llvm::Optional<size_t> psb_period) {
+#ifndef PERF_ATTR_SIZE_VER5
+  return llvm_unreachable("Intel PT Linux perf event not supported");
+#else
+  perf_event_attr attr;
+  memset(&attr, 0, sizeof(attr));
+  attr.size = sizeof(attr);
+  attr.exclude_kernel = 1;
+  attr.sample_type = PERF_SAMPLE_TIME;
+  attr.sample_id_all = 1;
+  attr.exclude_hv = 1;
+  attr.exclude_idle = 1;
+  attr.mmap = 1;
+
+  if (Expected<uint64_t> config_value =
+          GeneratePerfEventConfigValue(enable_tsc, psb_period))
+    attr.config = *config_value;
+  else
+    return config_value.takeError();
+
+  if (Expected<uint32_t> intel_pt_type = GetIntelPTOSEventType())
+    attr.type = *intel_pt_type;
+  else
+    return intel_pt_type.takeError();
+
+  return attr;
+#endif
+}
+
+size_t IntelPTSingleBufferTrace::GetTraceBufferSize() const {
+  return m_perf_event.GetAuxBuffer().size();
+}
+
+Expected<std::vector<uint8_t>>
+IntelPTSingleBufferTrace::GetTraceBuffer(size_t offset, size_t size) const {
+  auto fd = m_perf_event.GetFd();
+  perf_event_mmap_page &mmap_metadata = m_perf_event.GetMetadataPage();
+  // Disable the perf event to force a flush out of the CPU's internal buffer.
+  // Besides, we can guarantee that the CPU won't override any data as we are
+  // reading the buffer.
+  //
+  // The Intel documentation says:
+  //
+  // Packets are first buffered internally and then written out asynchronously.
+  // To collect packet output for postprocessing, a collector needs first to
+  // ensure that all packet data has been flushed from internal buffers.
+  // Software can ensure this by stopping packet generation by clearing
+  // IA32_RTIT_CTL.TraceEn (see “Disabling Packet Generation” in
+  // Section 35.2.7.2).
+  //
+  // This is achieved by the PERF_EVENT_IOC_DISABLE ioctl request, as mentioned
+  // in the man page of perf_event_open.
+  ioctl(fd, PERF_EVENT_IOC_DISABLE);
+
+  Log *log = GetLog(POSIXLog::Trace);
+  Status error;
+  uint64_t head = mmap_metadata.aux_head;
+
+  LLDB_LOG(log, "Aux size -{0} , Head - {1}", mmap_metadata.aux_size, head);
+
+  /**
+   * When configured as ring buffer, the aux buffer keeps wrapping around
+   * the buffer and its not possible to detect how many times the buffer
+   * wrapped. Initially the buffer is filled with zeros,as shown below
+   * so in order to get complete buffer we first copy firstpartsize, followed
+   * by any left over part from beginning to aux_head
+   *
+   * aux_offset [d,d,d,d,d,d,d,d,0,0,0,0,0,0,0,0,0,0,0] aux_size
+   *                 aux_head->||<- firstpartsize  ->|
+   *
+   * */
+
+  std::vector<uint8_t> data(size, 0);
+  MutableArrayRef<uint8_t> buffer(data);
+  ReadCyclicBuffer(buffer, m_perf_event.GetAuxBuffer(),
+                   static_cast<size_t>(head), offset);
+
+  // Reenable tracing now we have read the buffer
+  ioctl(fd, PERF_EVENT_IOC_ENABLE);
+  return data;
+}
+
+Expected<IntelPTSingleBufferTraceUP>
+IntelPTSingleBufferTrace::Start(const TraceIntelPTStartRequest &request,
+                                lldb::tid_t tid) {
+  Log *log = GetLog(POSIXLog::Trace);
+
+  LLDB_LOG(log, "Will start tracing thread id {0}", tid);
+
+  if (__builtin_popcount(request.trace_buffer_size) != 1 ||
+      request.trace_buffer_size < 4096) {
+    return createStringError(
+        inconvertibleErrorCode(),
+        "The trace buffer size must be a power of 2 greater than or equal to "
+        "4096 (2^12) bytes. It was %" PRIu64 ".",
+        request.trace_buffer_size);
+  }
+  uint64_t page_size = getpagesize();
+  uint64_t buffer_numpages = static_cast<uint64_t>(llvm::PowerOf2Floor(
+      (request.trace_buffer_size + page_size - 1) / page_size));
+
+  Expected<perf_event_attr> attr = CreateIntelPTPerfEventConfiguration(
+      request.enable_tsc, request.psb_period.map([](int value) {
+        return static_cast<uint64_t>(value);
+      }));
+  if (!attr)
+    return attr.takeError();
+
+  LLDB_LOG(log, "Will create trace buffer of size {0}",
+           request.trace_buffer_size);
+
+  if (Expected<PerfEvent> perf_event = PerfEvent::Init(*attr, tid)) {
+    if (Error mmap_err = perf_event->MmapMetadataAndBuffers(buffer_numpages,
+                                                            buffer_numpages)) {
+      return std::move(mmap_err);
+    }
+    return IntelPTSingleBufferTraceUP(
+        new IntelPTSingleBufferTrace(std::move(*perf_event), tid));
+  } else {
+    return perf_event.takeError();
+  }
+}

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

 
 // Public Instance Methods
 
 NativeProcessLinux::NativeProcessLinux(::pid_t pid, int terminal_fd,
                                        NativeDelegate &delegate,
                                        const ArchSpec &arch, MainLoop &mainloop,
                                        llvm::ArrayRef<::pid_t> tids)
     : NativeProcessELF(pid, terminal_fd, delegate), m_arch(arch),
-      m_main_loop(mainloop), m_intel_pt_collector(pid) {
+      m_main_loop(mainloop) {
   if (m_terminal_fd != -1) {
     Status status = EnsureFDFlags(m_terminal_fd, O_NONBLOCK);
     assert(status.Success());
   }
 
   Status status;
   m_sigchld_handle = mainloop.RegisterSignal(
       SIGCHLD, [this](MainLoopBase &) { SigchldHandler(); }, status);

lldb/source/Plugins/Process/Linux/Perf.h

 };
 
 using FileDescriptorUP =
     std::unique_ptr<long, resource_handle::FileDescriptorDeleter>;
 using MmapUP = std::unique_ptr<void, resource_handle::MmapDeleter>;
 
 } // namespace resource_handle
 
+/// 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.
+void ReadCyclicBuffer(llvm::MutableArrayRef<uint8_t> &dst,
+                      llvm::ArrayRef<uint8_t> src, size_t src_cyc_index,
+                      size_t offset);
+
 /// Thin wrapper of the perf_event_open API.
 ///
 /// Exposes the metadata page and data and aux buffers of a perf event.
 /// Handles the management of the event's file descriptor and mmap'ed
 /// regions.
 class PerfEvent {
 public:
   /// Create a new performance monitoring event via the perf_event_open syscall.

lldb/source/Plugins/Process/Linux/Perf.cpp

 //===-- Perf.cpp ----------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Perf.h"
 
+#include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #include "lldb/Host/linux/Support.h"
 
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 #include <sys/mman.h>
 #include <sys/syscall.h>
 #include <unistd.h>
 
 using namespace lldb_private;
 using namespace process_linux;
 using namespace llvm;
 
+void lldb_private::process_linux::ReadCyclicBuffer(
+    llvm::MutableArrayRef<uint8_t> &dst, llvm::ArrayRef<uint8_t> src,
+    size_t src_cyc_index, size_t offset) {
+
+  Log *log = GetLog(POSIXLog::Trace);
+
+  if (dst.empty() || src.empty()) {
+    dst = dst.drop_back(dst.size());
+    return;
+  }
+
+  if (dst.data() == nullptr || src.data() == nullptr) {
+    dst = dst.drop_back(dst.size());
+    return;
+  }
+
+  if (src_cyc_index > src.size()) {
+    dst = dst.drop_back(dst.size());
+    return;
+  }
+
+  if (offset >= src.size()) {
+    LLDB_LOG(log, "Too Big offset ");
+    dst = dst.drop_back(dst.size());
+    return;
+  }
+
+  llvm::SmallVector<ArrayRef<uint8_t>, 2> parts = {
+      src.slice(src_cyc_index), src.take_front(src_cyc_index)};
+
+  if (offset > parts[0].size()) {
+    parts[1] = parts[1].slice(offset - parts[0].size());
+    parts[0] = parts[0].drop_back(parts[0].size());
+  } else if (offset == parts[0].size()) {
+    parts[0] = parts[0].drop_back(parts[0].size());
+  } else {
+    parts[0] = parts[0].slice(offset);
+  }
+  auto next = dst.begin();
+  auto bytes_left = dst.size();
+  for (auto part : parts) {
+    size_t chunk_size = std::min(part.size(), bytes_left);
+    next = std::copy_n(part.begin(), chunk_size, next);
+    bytes_left -= chunk_size;
+  }
+  dst = dst.drop_back(bytes_left);
+}
+
 Expected<LinuxPerfZeroTscConversion>
 lldb_private::process_linux::LoadPerfTscConversionParameters() {
   lldb::pid_t pid = getpid();
   perf_event_attr attr;
   memset(&attr, 0, sizeof(attr));
   attr.size = sizeof(attr);
   attr.type = PERF_TYPE_SOFTWARE;
   attr.config = PERF_COUNT_SW_DUMMY;

lldb/source/Plugins/Trace/intel-pt/TraceIntelPT.cpp

 
 TraceIntelPT::TraceIntelPT(
     const pt_cpu &cpu_info,
     const std::vector<ThreadPostMortemTraceSP> &traced_threads)
     : m_cpu_info(cpu_info) {
   for (const ThreadPostMortemTraceSP &thread : traced_threads) {
     m_thread_decoders.emplace(thread->GetID(),
                               std::make_unique<ThreadDecoder>(thread, *this));
-    SetPostMortemThreadDataFile(thread->GetID(),
-                                IntelPTDataKinds::kThreadTraceBuffer,
+    SetPostMortemThreadDataFile(thread->GetID(), IntelPTDataKinds::kTraceBuffer,
                                 thread->GetTraceFile());
   }
 }
 
 DecodedThreadSP TraceIntelPT::Decode(Thread &thread) {
   RefreshLiveProcessState();
   if (m_live_refresh_error.hasValue())
     return std::make_shared<DecodedThread>(
if (configuration) {
     }
   }
 
   return Start(tids, trace_buffer_size, enable_tsc, psb_period);
 }
 
 Error TraceIntelPT::OnThreadBufferRead(lldb::tid_t tid,
                                        OnBinaryDataReadCallback callback) {
-  return OnThreadBinaryDataRead(tid, IntelPTDataKinds::kThreadTraceBuffer,
-                                callback);
+  return OnThreadBinaryDataRead(tid, IntelPTDataKinds::kTraceBuffer, callback);
 }
 
 TaskTimer &TraceIntelPT::GetTimer() { return m_task_timer; }

lldb/source/Plugins/Trace/intel-pt/TraceIntelPTSessionSaver.cpp

llvm::Error TraceIntelPTSessionSaver::SaveToDisk(TraceIntelPT &trace_ipt,
 
   llvm::Expected<JSONTraceIntelPTTrace> json_intel_pt_trace =
       BuildTraceSection(trace_ipt);
   if (!json_intel_pt_trace)
     return json_intel_pt_trace.takeError();
 
   llvm::Expected<JSONTraceSessionBase> json_session_description =
       TraceSessionSaver::BuildProcessesSection(
-          *live_process, IntelPTDataKinds::kThreadTraceBuffer, directory);
+          *live_process, IntelPTDataKinds::kTraceBuffer, directory);
 
   if (!json_session_description)
     return json_session_description.takeError();
 
   JSONTraceIntelPTSession json_intel_pt_session{json_intel_pt_trace.get(),
                                                 json_session_description.get()};
 
   return TraceSessionSaver::WriteSessionToFile(

lldb/source/Utility/TraceIntelPTGDBRemotePackets.cpp

 //===-- TraceIntelPTGDBRemotePackets.cpp ------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/TraceIntelPTGDBRemotePackets.h"
 
 using namespace llvm;
 using namespace llvm::json;
 
 namespace lldb_private {
 
 const char *IntelPTDataKinds::kProcFsCpuInfo = "procfsCpuInfo";
-const char *IntelPTDataKinds::kThreadTraceBuffer = "threadTraceBuffer";
+const char *IntelPTDataKinds::kTraceBuffer = "traceBuffer";
 
 bool fromJSON(const json::Value &value, TraceIntelPTStartRequest &packet,
               Path path) {
   ObjectMapper o(value, path);
   if (!o || !fromJSON(value, (TraceStartRequest &)packet, path) ||
       !o.map("enableTsc", packet.enable_tsc) ||
       !o.map("psbPeriod", packet.psb_period) ||
       !o.map("traceBufferSize", packet.trace_buffer_size))

lldb/unittests/Process/Linux/CMakeLists.txt

 add_lldb_unittest(ProcessLinuxTests
-  IntelPTCollectorTests.cpp
   PerfTests.cpp
   ProcfsTests.cpp
 
   LINK_LIBS
     lldbPluginProcessLinux
   )
 
 target_include_directories(ProcessLinuxTests PRIVATE
   ${LLDB_SOURCE_DIR}/source/Plugins/Process/Linux)

lldb/unittests/Process/Linux/IntelPTCollectorTests.cpp

-//===-- IntelPTCollectorTests.cpp -------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "gtest/gtest.h"
-
-#include "IntelPTCollector.h"
-#include "llvm/ADT/ArrayRef.h"
-
-
-using namespace lldb_private;
-using namespace process_linux;
-
-size_t ReadCylicBufferWrapper(void *buf, size_t buf_size, void *cyc_buf,
-                              size_t cyc_buf_size, size_t cyc_start,
-                              size_t offset) {
-  llvm::MutableArrayRef<uint8_t> dst(reinterpret_cast<uint8_t *>(buf),
-                                     buf_size);
-  llvm::ArrayRef<uint8_t> src(reinterpret_cast<uint8_t *>(cyc_buf),
-                              cyc_buf_size);
-  IntelPTThreadTrace::ReadCyclicBuffer(dst, src, cyc_start, offset);
-  return dst.size();
-}
-
-TEST(CyclicBuffer, EdgeCases) {
-  size_t bytes_read;
-  uint8_t cyclic_buffer[6] = {'l', 'i', 'c', 'c', 'y', 'c'};
-
-  // We will always leave the last bytes untouched
-  // so that string comparisons work.
-  char smaller_buffer[4] = {};
-
-  // empty buffer to read into
-  bytes_read = ReadCylicBufferWrapper(smaller_buffer, 0, cyclic_buffer,
-                                      sizeof(cyclic_buffer), 3, 0);
-  ASSERT_EQ(0u, bytes_read);
-
-  // empty cyclic buffer
-  bytes_read = ReadCylicBufferWrapper(smaller_buffer, sizeof(smaller_buffer),
-                                      cyclic_buffer, 0, 3, 0);
-  ASSERT_EQ(0u, bytes_read);
-
-  // bigger offset
-  bytes_read =
-      ReadCylicBufferWrapper(smaller_buffer, sizeof(smaller_buffer),
-                             cyclic_buffer, sizeof(cyclic_buffer), 3, 6);
-  ASSERT_EQ(0u, bytes_read);
-
-  // wrong offset
-  bytes_read =
-      ReadCylicBufferWrapper(smaller_buffer, sizeof(smaller_buffer),
-                             cyclic_buffer, sizeof(cyclic_buffer), 3, 7);
-  ASSERT_EQ(0u, bytes_read);
-
-  // wrong start
-  bytes_read =
-      ReadCylicBufferWrapper(smaller_buffer, sizeof(smaller_buffer),
-                             cyclic_buffer, sizeof(cyclic_buffer), 3, 7);
-  ASSERT_EQ(0u, bytes_read);
-}
-
-TEST(CyclicBuffer, EqualSizeBuffer) {
-  size_t bytes_read = 0;
-  uint8_t cyclic_buffer[6] = {'l', 'i', 'c', 'c', 'y', 'c'};
-
-  char cyclic[] = "cyclic";
-  for (size_t i = 0; i < sizeof(cyclic); i++) {
-    // We will always leave the last bytes untouched
-    // so that string comparisons work.
-    char equal_size_buffer[7] = {};
-    bytes_read =
-        ReadCylicBufferWrapper(equal_size_buffer, sizeof(cyclic_buffer),
-                               cyclic_buffer, sizeof(cyclic_buffer), 3, i);
-    ASSERT_EQ((sizeof(cyclic) - i - 1), bytes_read);
-    ASSERT_STREQ(equal_size_buffer, (cyclic + i));
-  }
-}
-
-TEST(CyclicBuffer, SmallerSizeBuffer) {
-  size_t bytes_read;
-  uint8_t cyclic_buffer[6] = {'l', 'i', 'c', 'c', 'y', 'c'};
-
-  // We will always leave the last bytes untouched
-  // so that string comparisons work.
-  char smaller_buffer[4] = {};
-  bytes_read =
-      ReadCylicBufferWrapper(smaller_buffer, (sizeof(smaller_buffer) - 1),
-                             cyclic_buffer, sizeof(cyclic_buffer), 3, 0);
-  ASSERT_EQ(3u, bytes_read);
-  ASSERT_STREQ(smaller_buffer, "cyc");
-
-  bytes_read =
-      ReadCylicBufferWrapper(smaller_buffer, (sizeof(smaller_buffer) - 1),
-                             cyclic_buffer, sizeof(cyclic_buffer), 3, 1);
-  ASSERT_EQ(3u, bytes_read);
-  ASSERT_STREQ(smaller_buffer, "ycl");
-
-  bytes_read =
-      ReadCylicBufferWrapper(smaller_buffer, (sizeof(smaller_buffer) - 1),
-                             cyclic_buffer, sizeof(cyclic_buffer), 3, 2);
-  ASSERT_EQ(3u, bytes_read);
-  ASSERT_STREQ(smaller_buffer, "cli");
-
-  bytes_read =
-      ReadCylicBufferWrapper(smaller_buffer, (sizeof(smaller_buffer) - 1),
-                             cyclic_buffer, sizeof(cyclic_buffer), 3, 3);
-  ASSERT_EQ(3u, bytes_read);
-  ASSERT_STREQ(smaller_buffer, "lic");
-
-  {
-    char smaller_buffer[4] = {};
-    bytes_read =
-        ReadCylicBufferWrapper(smaller_buffer, (sizeof(smaller_buffer) - 1),
-                               cyclic_buffer, sizeof(cyclic_buffer), 3, 4);
-    ASSERT_EQ(2u, bytes_read);
-    ASSERT_STREQ(smaller_buffer, "ic");
-  }
-  {
-    char smaller_buffer[4] = {};
-    bytes_read =
-        ReadCylicBufferWrapper(smaller_buffer, (sizeof(smaller_buffer) - 1),
-                               cyclic_buffer, sizeof(cyclic_buffer), 3, 5);
-    ASSERT_EQ(1u, bytes_read);
-    ASSERT_STREQ(smaller_buffer, "c");
-  }
-}
-
-TEST(CyclicBuffer, BiggerSizeBuffer) {
-  size_t bytes_read = 0;
-  uint8_t cyclic_buffer[6] = {'l', 'i', 'c', 'c', 'y', 'c'};
-
-  char cyclic[] = "cyclic";
-  for (size_t i = 0; i < sizeof(cyclic); i++) {
-    // We will always leave the last bytes untouched
-    // so that string comparisons work.
-    char bigger_buffer[10] = {};
-    bytes_read =
-        ReadCylicBufferWrapper(bigger_buffer, (sizeof(bigger_buffer) - 1),
-                               cyclic_buffer, sizeof(cyclic_buffer), 3, i);
-    ASSERT_EQ((sizeof(cyclic) - i - 1), bytes_read);
-    ASSERT_STREQ(bigger_buffer, (cyclic + i));
-  }
-}

lldb/unittests/Process/Linux/PerfTests.cpp

TEST(Perf, TscConversion) {
 
   std::chrono::microseconds acceptable_overhead(500);
 
   ASSERT_GE(converted_tsc_diff.count(), SLEEP_NANOS.count());
   ASSERT_LT(converted_tsc_diff.count(),
             (SLEEP_NANOS + acceptable_overhead).count());
 }
 
+size_t ReadCylicBufferWrapper(void *buf, size_t buf_size, void *cyc_buf,
+                              size_t cyc_buf_size, size_t cyc_start,
+                              size_t offset) {
+  llvm::MutableArrayRef<uint8_t> dst(reinterpret_cast<uint8_t *>(buf),
+                                     buf_size);
+  llvm::ArrayRef<uint8_t> src(reinterpret_cast<uint8_t *>(cyc_buf),
+                              cyc_buf_size);
+  ReadCyclicBuffer(dst, src, cyc_start, offset);
+  return dst.size();
+}
+
+TEST(CyclicBuffer, EdgeCases) {
+  size_t bytes_read;
+  uint8_t cyclic_buffer[6] = {'l', 'i', 'c', 'c', 'y', 'c'};
+
+  // We will always leave the last bytes untouched
+  // so that string comparisons work.
+  char smaller_buffer[4] = {};
+
+  // empty buffer to read into
+  bytes_read = ReadCylicBufferWrapper(smaller_buffer, 0, cyclic_buffer,
+                                      sizeof(cyclic_buffer), 3, 0);
+  ASSERT_EQ(0u, bytes_read);
+
+  // empty cyclic buffer
+  bytes_read = ReadCylicBufferWrapper(smaller_buffer, sizeof(smaller_buffer),
+                                      cyclic_buffer, 0, 3, 0);
+  ASSERT_EQ(0u, bytes_read);
+
+  // bigger offset
+  bytes_read =
+      ReadCylicBufferWrapper(smaller_buffer, sizeof(smaller_buffer),
+                             cyclic_buffer, sizeof(cyclic_buffer), 3, 6);
+  ASSERT_EQ(0u, bytes_read);
+
+  // wrong offset
+  bytes_read =
+      ReadCylicBufferWrapper(smaller_buffer, sizeof(smaller_buffer),
+                             cyclic_buffer, sizeof(cyclic_buffer), 3, 7);
+  ASSERT_EQ(0u, bytes_read);
+
+  // wrong start
+  bytes_read =
+      ReadCylicBufferWrapper(smaller_buffer, sizeof(smaller_buffer),
+                             cyclic_buffer, sizeof(cyclic_buffer), 3, 7);
+  ASSERT_EQ(0u, bytes_read);
+}
+
+TEST(CyclicBuffer, EqualSizeBuffer) {
+  size_t bytes_read = 0;
+  uint8_t cyclic_buffer[6] = {'l', 'i', 'c', 'c', 'y', 'c'};
+
+  char cyclic[] = "cyclic";
+  for (size_t i = 0; i < sizeof(cyclic); i++) {
+    // We will always leave the last bytes untouched
+    // so that string comparisons work.
+    char equal_size_buffer[7] = {};
+    bytes_read =
+        ReadCylicBufferWrapper(equal_size_buffer, sizeof(cyclic_buffer),
+                               cyclic_buffer, sizeof(cyclic_buffer), 3, i);
+    ASSERT_EQ((sizeof(cyclic) - i - 1), bytes_read);
+    ASSERT_STREQ(equal_size_buffer, (cyclic + i));
+  }
+}
+
+TEST(CyclicBuffer, SmallerSizeBuffer) {
+  size_t bytes_read;
+  uint8_t cyclic_buffer[6] = {'l', 'i', 'c', 'c', 'y', 'c'};
+
+  // We will always leave the last bytes untouched
+  // so that string comparisons work.
+  char smaller_buffer[4] = {};
+  bytes_read =
+      ReadCylicBufferWrapper(smaller_buffer, (sizeof(smaller_buffer) - 1),
+                             cyclic_buffer, sizeof(cyclic_buffer), 3, 0);
+  ASSERT_EQ(3u, bytes_read);
+  ASSERT_STREQ(smaller_buffer, "cyc");
+
+  bytes_read =
+      ReadCylicBufferWrapper(smaller_buffer, (sizeof(smaller_buffer) - 1),
+                             cyclic_buffer, sizeof(cyclic_buffer), 3, 1);
+  ASSERT_EQ(3u, bytes_read);
+  ASSERT_STREQ(smaller_buffer, "ycl");
+
+  bytes_read =
+      ReadCylicBufferWrapper(smaller_buffer, (sizeof(smaller_buffer) - 1),
+                             cyclic_buffer, sizeof(cyclic_buffer), 3, 2);
+  ASSERT_EQ(3u, bytes_read);
+  ASSERT_STREQ(smaller_buffer, "cli");
+
+  bytes_read =
+      ReadCylicBufferWrapper(smaller_buffer, (sizeof(smaller_buffer) - 1),
+                             cyclic_buffer, sizeof(cyclic_buffer), 3, 3);
+  ASSERT_EQ(3u, bytes_read);
+  ASSERT_STREQ(smaller_buffer, "lic");
+
+  {
+    char smaller_buffer[4] = {};
+    bytes_read =
+        ReadCylicBufferWrapper(smaller_buffer, (sizeof(smaller_buffer) - 1),
+                               cyclic_buffer, sizeof(cyclic_buffer), 3, 4);
+    ASSERT_EQ(2u, bytes_read);
+    ASSERT_STREQ(smaller_buffer, "ic");
+  }
+  {
+    char smaller_buffer[4] = {};
+    bytes_read =
+        ReadCylicBufferWrapper(smaller_buffer, (sizeof(smaller_buffer) - 1),
+                               cyclic_buffer, sizeof(cyclic_buffer), 3, 5);
+    ASSERT_EQ(1u, bytes_read);
+    ASSERT_STREQ(smaller_buffer, "c");
+  }
+}
+
+TEST(CyclicBuffer, BiggerSizeBuffer) {
+  size_t bytes_read = 0;
+  uint8_t cyclic_buffer[6] = {'l', 'i', 'c', 'c', 'y', 'c'};
+
+  char cyclic[] = "cyclic";
+  for (size_t i = 0; i < sizeof(cyclic); i++) {
+    // We will always leave the last bytes untouched
+    // so that string comparisons work.
+    char bigger_buffer[10] = {};
+    bytes_read =
+        ReadCylicBufferWrapper(bigger_buffer, (sizeof(bigger_buffer) - 1),
+                               cyclic_buffer, sizeof(cyclic_buffer), 3, i);
+    ASSERT_EQ((sizeof(cyclic) - i - 1), bytes_read);
+    ASSERT_STREQ(bigger_buffer, (cyclic + i));
+  }
+}
+
 #endif // __x86_64__