[trace][intelpt] Add thin wrapper for perf_event_open API

[jj10306]

Summary

• Add PerfEvent class to handle creating ring buffers and handle the resources associated with the perf_event. This API can be used by the IntelPT collection code and by the future work in this series of diffs related to enabling TSC to timestamp conversion.
• Refactor IntelPT collection code to use this new API
• Add TSC to timestamp conversion logic with unittest

Depends on https://reviews.llvm.org/D121711
Second of the series of smaller diffs that split https://reviews.llvm.org/D120595 up

[jj10306]

Not sure if having this new, separate Perf.h file makes sense as the custom destructors for mmap and file descriptors can be used generally and don't directly relate to the perf API. I added this for the time being based on discussions on https://reviews.llvm.org/D120595, so feedback/thoughts are appreciated.

Also, this is my first time trying to create a "stack" of diffs so I just created the patch with the base being another diff's commit that's currently being reviewed instead of the base being some commit on the mainline - please let me know if there is a better/preferred to do this.

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

166

Should this free function be defined here or elsewhere? It's declared in the new Perf.h file

[wallace]

Move FetchPerfTscConversionParameters and StartTrace to the new Perf.h and Perf.cpp files. FetchPerfTscConversionParameters can easily be moved there. StartTrace should be refactored, so that a new method StartPerfEventWithAuxBuffer in Perf.h receives a configuration struct prepared by StartTrace in IntelPTCollector. This new StartPerfEventWithAuxBuffer could return a unique_ptr to a new PerfEvent object with pointers to m_mmap_meta and m_mmap_aux. The destructor of this object could free the resources accordingly. If you are able to do this, you could even share some code between FetchPerfTscConversionParameters and StartPerfEventWithAuxBuffer

[jj10306]

addressed major comment on previous version - see updated title/summary

[wallace]

pretty nice. Most of the comments are stylistic and about the code organization, not the underlying logic, which is overall correct.

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

8–27

Btw, there's a code style guideline regarding includes, which can be found here https://llvm.org/docs/CodingStandards.html#include-style. Let's try to follow it from now it. Being honest I wasn't really following it

9–10

do you need these?

198–199

tbh, this method doesn't need to be part of IntelPTThreadTrace. Just leave it as a private static function of this file.
Besides that, we can improve it a bit with the use of errorOrToExpected

198–199

we don't need to change this argument. We might later the behavior of this function to be "allocate the largest buffer possible that is <= the buffer size". Then we don't need to thing of pages anymore from a user point of view.
On the other hand, the PerfEvent API you are building should receive the number of pages as parameter because that's what the documentation says.

202–223

you can move this to a new static method CreateIntelPTPerfEventConfiguration

224–225

use auto only if the actual type is too complex, which is not the case here, so don't use auto. More here https://llvm.org/docs/CodingStandards.html#use-auto-type-deduction-to-make-code-more-readable

225–226

just use the -> operator instead of creating a new variable

227

that std::move is not needed. It should be done automatically by the compiler

230

i'd asume this std::move is also not needed, but all good if it's here

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

33–55

please move them to be bottom of this class and make them explicitly private

54–55

move the constructor to the top of the class and add documentation. Mention that the perf_event must be the result of a perf_event request for intel pt

54–59

move this method to the top of the class, to make it more readable. Also mention that this is the way to create an instance of this class

111

good one

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

34

35

the std::move should be able to go away

37

remove this, as it should be part of the documentation of GetMetadataPage

47

87–96

you can move the code that mmaps and checks for errors to a new function

First make resource_handle::MmapUP use always uint8_t instead of allowing a typename. In the end you mmap bytes and the getter methods in PerfEvent can do the casting.

private: 
Expected<resource_handle::MmapUP> PerfEvent::Mmap(size_t size, long int offset, StringRef buffer_name /*for errors*/) {
  errno = 0;
  auto mmap_result = ::mmap(nullptr, size, PROT_READ, MAP_SHARED, GetFd(), offset);

  if (mmap_result == MAP_FAILED) {
    std::string err_msg = llvm::formatv("perf event mmap allocation failed for {0}: {1}",
                                      buffer_name, std::strerror(errno));
    return createStringError(inconvertibleErrorCode(), err_msg);
  }
  return resource_handle::MmapUP(reinterpret_cast<uint8_t *>(mmap_result), size);
}

then you can use it like

Error LoadAuxBuffer(size_t pages) {
  size_t aux_mmap_size = pages * pagesize();
  if (Expected<resource_handle::MmapUP> mmap_aux = Mmap(aux_mmap_size, GetMetadata().aux_offset, "aux buffer"))
    m_aux_buffer = std::move(mmap_aux.get());
  else
    return mmap_aux.takeError();
}

Error LoadMetadataAndDataBuffer(size_t data_pages) {
  size_t size = (data_pages + 1) * pagesize();
  if (Expected<resource_handle::MmapUP> mmap_data = Mmap(size, 0, "metadata and data buffer"))
    m_metadata_and_data_buffer = std::move(mmap_data.get());
  else
    return m_metadata_and_data_buffer.takeError();
}

Error LoadMetadataAndBuffers(size_t data_pages, size_t aux_pages) {
  if (Error err = LoadMetadataAndDataBuffer(data_pages))
    return err;
  if (Error err = LoadAuxBuffer(aux_pages))
    return err;
  return Error::success();
}

perf_event_mmap_page &PerfEvent::GetMetadataPage() const {
 return *reinterpret_cast<perf_event_mmap_page*>(m_metadata_and_data_buffer.get());
}

102–104

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

10

i know not all the code is consistent, but this is the guideline we all should follow
https://llvm.org/docs/CodingStandards.html#header-guard, so you should change this to

LLDB_SOURCE_PLUGINS_PROCESS_LINUX_PERF_H

an example is lldb/source/Plugins/ObjectFile/JIT/ObjectFileJIT.h

13–14

31

rename length to bytes to be more specific

Also add a default value with a length of 0, i.e. MmapDeleter(size_t length = 0). That'll be used for avoiding specifying 0 in the constructor of PerfEvent

31–32

32–34

move the implementation to a cpp file

45

remove this, already done

48

you don't need this

49–55

move the implementation to a cpp file. That will also reduce the number of headers in this file

59–62

Let's remove the template, so that we only deal with bytes. The low-level mmap function works in terms of bytes, so it's better to keep it as it is. This also plays well with the MmapDeleter that deletes a number of bytes.

68–69

94–98

let's keep this short

99–103

As this will be invoked as PerfEvent::InitPerfEvent(, better just rename these methods to Init, so that the user sees PerfEvent::Init(

102–103

Add documentation mentioning the parameters and when to invoke this method over the other

105

move this to the cpp file. Just keep implementation code in a header file if it makes sense to copy it everywhere the header is included, e.g. inline functions

108

111–113

Let's not mention the metadata page here because the fact that the data buffer comes right after the metadata page is an implementation detail.

116

119

we cannot talk about the mmap pointers because that's a minor implementation detail

121

Let's better use a descriptive name: MmapMetadataPageAndBuffers(size_t data_pages, size_t aux_pages)

121–125

blank lines between methods and documentation

123

Return a reference instead of a pointer to enforce the validity of the data, because it can't be nullptr if you are using this method correctly, and it should fail if otherwise

128–134

it's possible that you can do m_mmap_meta() instead of m_mmap_meta(nullptr, resource_handle::MmapDeleter(0)) if MmapDeleter has a parameter-less constructor. All good if you can't

129

rename to m_mmap_metadata_and_data_buffer or have two different mmaps for each chunk of data. If you keep only one, mention in a comment that we can do this because the data buffer comes right after the metadata page

154

can you use the current process' pid with getpid() instead of having the caller pass a pid? That'll make your code simpler

159

remove #ifndef

[jj10306]

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

227

it actually is required here

230

it actually is required here

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

35

it's actually required here

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

68–69

I don't think you finished your comment here

111–113

isn't "A value of 0 effectively is a no-op and no data is mmaped for this buffer." a bit misleading since the metadata page will always be mmaped even if 0 is passed?
I agree that it's a no-op for the aux buffer but I think it's worth noting here that the metadata page will always be allocated

[jj10306]

• remove template from MmapUP and use void * instead since this is what mmap returns. Leave casting of the pointer to the getter functions
• refactor internal mmap functions and provide a thin mmap wrapper function that simply forwards parameters to real mmap calls and allows for custom error message. Different callers might need to pass different prot, flag, etc so I decided to include all the mmap parameters, except fd since this is stored on the PerfEvent object itself. This could potentially be changed to accept a fd and be moved out of the PerfEvent class to be used globally since it simply wraps an mmap call and adds custom error messages and resource handling through the unique pointer.
• clean up and add documentation

[wallace]

only some minor documentation change and good to go

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

17

this shouldn't be there.

I'm even more amazed by the fact that

#include "llvm/ADT/DenseMap.h" 
#include "llvm/ADT/DenseSet.h"

are there in the first place. Maybe the intel guy who did this first added them

118

120–124

Too many implementation details. Better not mention them. The reason for avoiding giving too many details is that in the future the implementation might change and this comment won't make sense anymore.

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

112–117

Let's reduce the number of implementation details that might easily change in the future.

139–140

nice clarification

[jj10306]

Address minor comments and add unittests

[wallace]

some minor final details

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

60–61

??

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

116

254

??

lldb/unittests/Process/Linux/PerfTests.cpp

24

40–41

use lower_case format. The xray uses a different format

49

add a comment before this line explaining how the test will work

55

nice!!

also explain here that it's all fine to skip here

71

[jj10306]

final cleanup

[wallace]

great job!

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

 add_lldb_library(lldbPluginProcessLinux
   IntelPTCollector.cpp
   NativeProcessLinux.cpp
   NativeRegisterContextLinux.cpp
   NativeRegisterContextLinux_arm.cpp
   NativeRegisterContextLinux_arm64.cpp
   NativeRegisterContextLinux_ppc64le.cpp
   NativeRegisterContextLinux_s390x.cpp
   NativeRegisterContextLinux_x86_64.cpp
   NativeThreadLinux.cpp
+  Perf.cpp
   SingleStepCheck.cpp
 
   LINK_LIBS
     lldbCore
     lldbHost
     lldbSymbol
     lldbTarget
     lldbUtility
     lldbPluginProcessPOSIX
     lldbPluginProcessUtility
   LINK_COMPONENTS
     Support
   )

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 "lldb/Utility/Status.h"
 #include "lldb/Utility/TraceIntelPTGDBRemotePackets.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 at thread level.
 ///
 /// The kernel interface for us is the perf_event_open.
 class IntelPTThreadTrace;
 typedef std::unique_ptr<IntelPTThreadTrace> IntelPTThreadTraceUP;
 
 class IntelPTThreadTrace {
-
-  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;
-  lldb::tid_t m_tid;
-
-  /// Start tracing a thread
+  /// 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 llvm::Error::success if tracing was successful, or an
-  ///     \a llvm::Error otherwise.
-  llvm::Error StartTrace(lldb::pid_t pid, lldb::tid_t tid, uint64_t buffer_size,
-                         bool enable_tsc, llvm::Optional<size_t> psb_period);
-
-  llvm::MutableArrayRef<uint8_t> GetAuxBuffer() const;
-  llvm::MutableArrayRef<uint8_t> GetDataBuffer() const;
-
-  IntelPTThreadTrace()
-      : m_mmap_meta(nullptr, munmap_delete(0)),
-        m_mmap_aux(nullptr, munmap_delete(0)), m_fd(nullptr, file_close()) {}
-
-public:
-  /// Get the content of /proc/cpuinfo that can be later used to decode traces.
-  static llvm::Expected<llvm::ArrayRef<uint8_t>> GetCPUInfo();
-
-  /// Start tracing a thread.
-  ///
-  /// See \a StartTrace.
-  ///
-  /// \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.
   ///
public:
   ///
   /// \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,
+                               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) {}
 
   /// Dispose of all traces

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

 //===-- IntelPTCollector.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 <algorithm>
-#include <fstream>
-#include <sstream>
+#include "IntelPTCollector.h"
 
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/Error.h"
-#include "llvm/Support/MathExtras.h"
+#include "Perf.h"
 
-#include "IntelPTCollector.h"
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #include "lldb/Host/linux/Support.h"
 #include "lldb/Utility/StreamString.h"
 
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/MathExtras.h"
+
+#include <algorithm>
+#include <cstddef>
+#include <fstream>
+#include <linux/perf_event.h>
+#include <sstream>
 #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";
enum IntelPTConfigFileType {
   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
 };
 
+/// Get the content of /proc/cpuinfo that can be later used to decode traces.
+static Expected<ArrayRef<uint8_t>> GetCPUInfo() {
+  static llvm::Optional<std::vector<uint8_t>> cpu_info;
+  if (!cpu_info) {
+    auto buffer_or_error = errorOrToExpected(getProcFile("cpuinfo"));
+    if (!buffer_or_error)
+      return buffer_or_error.takeError();
+    MemoryBuffer &buffer = **buffer_or_error;
+    cpu_info = std::vector<uint8_t>(
+        reinterpret_cast<const uint8_t *>(buffer.getBufferStart()),
+        reinterpret_cast<const uint8_t *>(buffer.getBufferEnd()));
+  }
+  return *cpu_info;
+}
+
 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);
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 =
while (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_mmap_meta->aux_size;
+  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 (psb_period) {
     if (Expected<uint32_t> offset = ReadIntelPTConfigFile(
             kPSBPeriodBitOffsetFile, IntelPTConfigFileType::BitOffset))
       config |= *psb_period << *offset;
     else
       return offset.takeError();
   }
   return config;
 }
 
-Error IntelPTThreadTrace::StartTrace(lldb::pid_t pid, lldb::tid_t tid,
-                                     uint64_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);
-
-  m_tid = tid;
-  LLDB_LOG(log, "called thread id {0}", tid);
-  uint64_t page_size = getpagesize();
-
-  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 numpages = static_cast<uint64_t>(
-      llvm::PowerOf2Floor((buffer_size + page_size - 1) / page_size));
-  numpages = std::max<uint64_t>(1, numpages);
-  buffer_size = page_size * numpages;
-
+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;
-    LLDB_LOG(log, "intel pt config {0}", attr.config);
   } else {
     return config_value.takeError();
   }
 
   if (Expected<uint32_t> intel_pt_type = GetOSEventType()) {
     attr.type = *intel_pt_type;
-    LLDB_LOG(log, "intel pt type {0}", attr.type);
   } else {
     return intel_pt_type.takeError();
   }
 
-  LLDB_LOG(log, "buffer size {0} ", buffer_size);
-
-  errno = 0;
-  auto fd =
-      syscall(SYS_perf_event_open, &attr, static_cast<::tid_t>(tid), -1, -1, 0);
-  if (fd == -1) {
-    LLDB_LOG(log, "syscall error {0}", errno);
-    return createStringError(inconvertibleErrorCode(),
-                             "perf event syscall failed");
-  }
+  return attr;
 
-  m_fd = std::unique_ptr<int, file_close>(new int(fd), file_close());
-
-  errno = 0;
-  auto base =
-      mmap(nullptr, (buffer_size + page_size), PROT_WRITE, MAP_SHARED, fd, 0);
-
-  if (base == MAP_FAILED) {
-    LLDB_LOG(log, "mmap base error {0}", errno);
-    return createStringError(inconvertibleErrorCode(),
-                             "Meta buffer allocation failed");
-  }
-
-  m_mmap_meta = std::unique_ptr<perf_event_mmap_page, munmap_delete>(
-      reinterpret_cast<perf_event_mmap_page *>(base),
-      munmap_delete(buffer_size + page_size));
-
-  m_mmap_meta->aux_offset = m_mmap_meta->data_offset + m_mmap_meta->data_size;
-  m_mmap_meta->aux_size = buffer_size;
-
-  errno = 0;
-  auto mmap_aux = mmap(nullptr, buffer_size, PROT_READ, MAP_SHARED, fd,
-                       static_cast<long int>(m_mmap_meta->aux_offset));
-
-  if (mmap_aux == MAP_FAILED) {
-    LLDB_LOG(log, "second mmap done {0}", errno);
-    return createStringError(inconvertibleErrorCode(),
-                             "Trace buffer allocation failed");
-  }
-  m_mmap_aux = std::unique_ptr<uint8_t, munmap_delete>(
-      reinterpret_cast<uint8_t *>(mmap_aux), munmap_delete(buffer_size));
-  return Error::success();
-#endif
-}
-
-llvm::MutableArrayRef<uint8_t> IntelPTThreadTrace::GetDataBuffer() const {
+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
-  return MutableArrayRef<uint8_t>(
-      (reinterpret_cast<uint8_t *>(m_mmap_meta.get()) +
-       m_mmap_meta->data_offset),
-      m_mmap_meta->data_size);
-#endif
-}
+  Log *log = GetLog(POSIXLog::Ptrace);
 
-llvm::MutableArrayRef<uint8_t> IntelPTThreadTrace::GetAuxBuffer() const {
-#ifndef PERF_ATTR_SIZE_VER5
-  llvm_unreachable("Intel PT Linux perf event not supported");
-#else
-  return MutableArrayRef<uint8_t>(m_mmap_aux.get(), m_mmap_meta->aux_size);
-#endif
-}
+  LLDB_LOG(log, "called thread id {0}", tid);
 
-Expected<ArrayRef<uint8_t>> IntelPTThreadTrace::GetCPUInfo() {
-  static llvm::Optional<std::vector<uint8_t>> cpu_info;
-  if (!cpu_info) {
-    auto buffer_or_error = getProcFile("cpuinfo");
-    if (!buffer_or_error)
-      return Status(buffer_or_error.getError()).ToError();
-    MemoryBuffer &buffer = **buffer_or_error;
-    cpu_info = std::vector<uint8_t>(
-        reinterpret_cast<const uint8_t *>(buffer.getBufferStart()),
-        reinterpret_cast<const uint8_t *>(buffer.getBufferEnd()));
-  }
-  return *cpu_info;
+  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));
 
-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) {
-  IntelPTThreadTraceUP thread_trace_up(new IntelPTThreadTrace());
+  Expected<perf_event_attr> attr =
+      IntelPTThreadTrace::CreateIntelPTPerfEventConfiguration(enable_tsc,
+                                                              psb_period);
+  if (!attr)
+    return attr.takeError();
 
-  if (llvm::Error err = thread_trace_up->StartTrace(pid, tid, buffer_size,
-                                                    enable_tsc, psb_period))
-    return std::move(err);
+  LLDB_LOG(log, "buffer size {0} ", buffer_size);
 
-  return std::move(thread_trace_up);
+  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(*m_fd, PERF_EVENT_IOC_DISABLE);
+  ioctl(fd, PERF_EVENT_IOC_DISABLE);
 
   Log *log = GetLog(POSIXLog::Ptrace);
   Status error;
-  uint64_t head = m_mmap_meta->aux_head;
+  uint64_t head = mmap_metadata.aux_head;
 
-  LLDB_LOG(log, "Aux size -{0} , Head - {1}", m_mmap_meta->aux_size, 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, GetAuxBuffer(), static_cast<size_t>(head), offset);
-  LLDB_LOG(log, "ReadCyclic BUffer Done");
+  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(*m_fd, PERF_EVENT_IOC_ENABLE);
+  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;
 
-  uint64_t head = m_mmap_meta->data_head;
+  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 = GetDataBuffer();
+  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}", m_mmap_meta->data_size, head);
+    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::MutableArrayRef<uint8_t> src,
+                                          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;
   }
void IntelPTThreadTrace::ReadCyclicBuffer(llvm::MutableArrayRef<uint8_t> &dst,
   }
 
   if (offset >= src.size()) {
     LLDB_LOG(log, "Too Big offset ");
     dst = dst.drop_back(dst.size());
     return;
   }
 
-  llvm::SmallVector<MutableArrayRef<uint8_t>, 2> parts = {
+  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 {
Error IntelPTCollector::OnThreadDestroyed(lldb::tid_t tid) {
   if (IsProcessTracingEnabled() && m_process_trace->TracesThread(tid))
     return m_process_trace->TraceStop(tid);
   else if (m_thread_traces.TracesThread(tid))
     return m_thread_traces.TraceStop(tid);
   return Error::success();
 }
 
 Expected<json::Value> IntelPTCollector::GetState() const {
-  Expected<ArrayRef<uint8_t>> cpu_info = IntelPTThreadTrace::GetCPUInfo();
+  Expected<ArrayRef<uint8_t>> cpu_info = GetCPUInfo();
   if (!cpu_info)
     return cpu_info.takeError();
 
   TraceGetStateResponse state;
   state.processBinaryData.push_back(
       {"cpuInfo", static_cast<int64_t>(cpu_info->size())});
 
   std::vector<TraceThreadState> thread_states =

 IntelPTCollector::GetBinaryData(const TraceGetBinaryDataRequest &request) const {
   if (request.kind == "threadTraceBuffer") {
     if (Expected<const IntelPTThreadTrace &> trace =
             GetTracedThread(*request.tid))
       return trace->GetIntelPTBuffer(request.offset, request.size);
     else
       return trace.takeError();
   } else if (request.kind == "cpuInfo") {
-    return IntelPTThreadTrace::GetCPUInfo();
+    return GetCPUInfo();
   }
   return createStringError(inconvertibleErrorCode(),
                            "Unsuported trace binary data kind: %s",
                            request.kind.c_str());
 }
 
 void IntelPTCollector::ClearProcessTracing() { m_process_trace = None; }
 

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

+//===-- Perf.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
+//
+//===----------------------------------------------------------------------===//
+/// \file
+/// This file contains a thin wrapper of the perf_event_open API
+/// and classes to handle the destruction of file descriptors
+/// and mmap pointers.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SOURCE_PLUGINS_PROCESS_LINUX_PERF_H
+#define LLDB_SOURCE_PLUGINS_PROCESS_LINUX_PERF_H
+
+#include "lldb/lldb-types.h"
+
+#include "llvm/Support/Error.h"
+
+#include <chrono>
+#include <cstdint>
+#include <linux/perf_event.h>
+
+namespace lldb_private {
+namespace process_linux {
+namespace resource_handle {
+
+/// Custom deleter for the pointer returned by \a mmap.
+///
+/// This functor type is provided to \a unique_ptr to properly
+/// unmap the region at destruction time.
+class MmapDeleter {
+public:
+  /// Construct new \a MmapDeleter.
+  ///
+  /// \param[in] bytes
+  ///   Size of the mmap'ed region in bytes.
+  MmapDeleter(size_t bytes = 0) : m_bytes(bytes) {}
+
+  /// Unmap the mmap'ed region.
+  ///
+  /// If \a m_bytes==0 or \a ptr==nullptr, nothing is unmmapped.
+  ///
+  /// \param[in] ptr
+  ///   pointer to the region to be unmmapped.
+  void operator()(void *ptr);
+
+private:
+  /// Size of the mmap'ed region, in bytes, to be unmapped.
+  size_t m_bytes;
+};
+
+/// Custom deleter for a file descriptor.
+///
+/// This functor type is provided to \a unique_ptr to properly release
+/// the resources associated with the file descriptor at destruction time.
+class FileDescriptorDeleter {
+public:
+  /// Close and free the memory associated with the file descriptor pointer.
+  ///
+  /// Effectively a no-op if \a ptr==nullptr or \a*ptr==-1.
+  ///
+  /// \param[in] ptr
+  ///   Pointer to the file descriptor.
+  void operator()(long *ptr);
+};
+
+using FileDescriptorUP =
+    std::unique_ptr<long, resource_handle::FileDescriptorDeleter>;
+using MmapUP = std::unique_ptr<void, resource_handle::MmapDeleter>;
+
+} // namespace resource_handle
+
+/// 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.
+  ///
+  /// The parameters are directly forwarded to a perf_event_open syscall,
+  /// for additional information on the parameters visit
+  /// https://man7.org/linux/man-pages/man2/perf_event_open.2.html.
+  ///
+  /// \param[in] attr
+  ///     Configuration information for the event.
+  ///
+  /// \param[in] pid
+  ///     The process to be monitored by the event.
+  ///
+  /// \param[in] cpu
+  ///     The cpu to be monitored by the event.
+  ///
+  /// \param[in] group_fd
+  ///     File descriptor of the group leader.
+  ///
+  /// \param[in] flags
+  ///     Bitmask of additional configuration flags.
+  ///
+  /// \return
+  ///     If the perf_event_open syscall was successful, a minimal \a PerfEvent
+  ///     instance, or an \a llvm::Error otherwise.
+  static llvm::Expected<PerfEvent> Init(perf_event_attr &attr, lldb::pid_t pid,
+                                        int cpu, int group_fd,
+                                        unsigned long flags);
+
+  /// Create a new performance monitoring event via the perf_event_open syscall
+  /// with "default" values for the cpu, group_fd and flags arguments.
+  ///
+  /// Convenience method to be used when the perf event requires minimal
+  /// configuration. It handles the default values of all other arguments.
+  ///
+  /// \param[in] attr
+  ///     Configuration information for the event.
+  ///
+  /// \param[in] pid
+  ///     The process to be monitored by the event.
+  static llvm::Expected<PerfEvent> Init(perf_event_attr &attr, lldb::pid_t pid);
+
+  /// Mmap the metadata page and the data and aux buffers of the perf event and
+  /// expose them through \a PerfEvent::GetMetadataPage() , \a
+  /// PerfEvent::GetDataBuffer() and \a PerfEvent::GetAuxBuffer().
+  ///
+  /// This uses mmap underneath, which means that the number of pages mmap'ed
+  /// must be less than the actual data available by the kernel. The metadata
+  /// page is always mmap'ed.
+  ///
+  /// Mmap is needed because the underlying data might be changed by the kernel
+  /// dynamically.
+  ///
+  /// \param[in] num_data_pages
+  ///     Number of pages in the data buffer to mmap, must be a power of 2.
+  ///     A value of 0 is useful for "dummy" events that only want to access
+  ///     the metadata, \a perf_event_mmap_page, or the aux buffer.
+  ///
+  /// \param[in] num_aux_pages
+  ///     Number of pages in the aux buffer to mmap, must be a power of 2.
+  ///     A value of 0 effectively is a no-op and no data is mmap'ed for this
+  ///     buffer.
+  ///
+  /// \return
+  ///   \a llvm::Error::success if the mmap operations succeeded,
+  ///   or an \a llvm::Error otherwise.
+  llvm::Error MmapMetadataAndBuffers(size_t num_data_pages,
+                                     size_t num_aux_pages);
+
+  /// Get the file descriptor associated with the perf event.
+  long GetFd() const;
+
+  /// Get the metadata page from the data section's mmap buffer.
+  ///
+  /// The metadata page is always mmap'ed, even when \a num_data_pages is 0.
+  ///
+  /// This should be called only after \a PerfEvent::MmapMetadataAndBuffers,
+  /// otherwise a failure might happen.
+  ///
+  /// \return
+  ///   The data section's \a perf_event_mmap_page.
+  perf_event_mmap_page &GetMetadataPage() const;
+
+  /// Get the data buffer from the data section's mmap buffer.
+  ///
+  /// The data buffer is the region of the data section's mmap buffer where
+  /// perf sample data is located.
+  ///
+  /// This should be called only after \a PerfEvent::MmapMetadataAndBuffers,
+  /// otherwise a failure might happen.
+  ///
+  /// \return
+  ///   \a ArrayRef<uint8_t> extending \a data_size bytes from \a data_offset.
+  llvm::ArrayRef<uint8_t> GetDataBuffer() const;
+
+  /// Get the AUX buffer.
+  ///
+  /// AUX buffer is a region for high-bandwidth data streams
+  /// such as IntelPT. This is separate from the metadata and data buffer.
+  ///
+  /// This should be called only after \a PerfEvent::MmapMetadataAndBuffers,
+  /// otherwise a failure might happen.
+  ///
+  /// \return
+  ///   \a ArrayRef<uint8_t> extending \a aux_size bytes from \a aux_offset.
+  llvm::ArrayRef<uint8_t> GetAuxBuffer() const;
+
+private:
+  /// Create new \a PerfEvent.
+  ///
+  /// \param[in] fd
+  ///   File descriptor of the perf event.
+  PerfEvent(long fd)
+      : m_fd(new long(fd), resource_handle::FileDescriptorDeleter()),
+        m_metadata_data_base(), m_aux_base() {}
+
+  /// Wrapper for \a mmap to provide custom error messages.
+  ///
+  /// The parameters are directly forwarded to a \a mmap syscall,
+  /// for information on the parameters visit
+  /// https://man7.org/linux/man-pages/man2/mmap.2.html.
+  ///
+  /// The value of \a GetFd() is passed as the \a fd argument to \a mmap.
+  llvm::Expected<resource_handle::MmapUP> DoMmap(void *addr, size_t length,
+                                                 int prot, int flags,
+                                                 long int offset,
+                                                 llvm::StringRef buffer_name);
+
+  /// Mmap the data buffer of the perf event.
+  ///
+  /// \param[in] num_data_pages
+  ///     Number of pages in the data buffer to mmap, must be a power of 2.
+  ///     A value of 0 is useful for "dummy" events that only want to access
+  ///     the metadata, \a perf_event_mmap_page, or the aux buffer.
+  llvm::Error MmapMetadataAndDataBuffer(size_t num_data_pages);
+
+  /// Mmap the aux buffer of the perf event.
+  ///
+  /// \param[in] num_aux_pages
+  ///   Number of pages in the aux buffer to mmap, must be a power of 2.
+  ///   A value of 0 effectively is a no-op and no data is mmap'ed for this
+  ///   buffer.
+  llvm::Error MmapAuxBuffer(size_t num_aux_pages);
+
+  /// The file descriptor representing the perf event.
+  resource_handle::FileDescriptorUP m_fd;
+  /// Metadata page and data section where perf samples are stored.
+  resource_handle::MmapUP m_metadata_data_base;
+  /// AUX buffer is a separate region for high-bandwidth data streams
+  /// such as IntelPT.
+  resource_handle::MmapUP m_aux_base;
+};
+
+/// TSC to nanoseconds conversion values defined by the Linux perf_event API
+/// when the capibilities cap_user_time and cap_user_time_zero are set. See the
+/// documentation of `time_zero` in
+/// https://man7.org/linux/man-pages/man2/perf_event_open.2.html for more
+/// information.
+struct PerfTscConversionParameters {
+  uint32_t m_time_mult;
+  uint16_t m_time_shift;
+  uint64_t m_time_zero;
+
+  /// Convert TSC value to nanosecond wall time.
+  ///
+  /// \a param[in] tsc
+  ///   The TSC value to be converted.
+  ///
+  /// \return
+  ///   Nanosecond wall time.
+  std::chrono::nanoseconds ToWallTime(uint64_t tsc);
+};
+
+/// Fetch \a PerfTscConversionParameters from \a perf_event_mmap_page, if
+/// available.
+llvm::Expected<PerfTscConversionParameters> FetchPerfTscConversionParameters();
+
+} // namespace process_linux
+} // namespace lldb_private
+
+#endif // LLDB_SOURCE_PLUGINS_PROCESS_LINUX_PERF_H

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 "lldb/lldb-types.h"
+
+#include "llvm/Support/Error.h"
+#include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/MathExtras.h"
+
+#include <chrono>
+#include <cstdint>
+#include <linux/perf_event.h>
+#include <sys/mman.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+
+using namespace lldb_private;
+using namespace process_linux;
+using namespace llvm;
+
+Expected<PerfTscConversionParameters>
+lldb_private::process_linux::FetchPerfTscConversionParameters() {
+  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;
+
+  Expected<PerfEvent> perf_event = PerfEvent::Init(attr, pid);
+  if (!perf_event)
+    return perf_event.takeError();
+  if (Error mmap_err = perf_event->MmapMetadataAndBuffers(/*num_data_pages*/ 0,
+                                                          /*num_aux_pages*/ 0))
+    return std::move(mmap_err);
+
+  perf_event_mmap_page &mmap_metada = perf_event->GetMetadataPage();
+  if (mmap_metada.cap_user_time && mmap_metada.cap_user_time_zero) {
+    return PerfTscConversionParameters{
+        mmap_metada.time_mult, mmap_metada.time_shift, mmap_metada.time_zero};
+  } else {
+    auto err_cap =
+        !mmap_metada.cap_user_time ? "cap_user_time" : "cap_user_time_zero";
+    std::string err_msg =
+        llvm::formatv("Can't get TSC to real time conversion values. "
+                      "perf_event capability '{0}' not supported.",
+                      err_cap);
+    return llvm::createStringError(llvm::inconvertibleErrorCode(), err_msg);
+  }
+}
+
+std::chrono::nanoseconds PerfTscConversionParameters::ToWallTime(uint64_t tsc) {
+  // See 'time_zero' section of
+  // https://man7.org/linux/man-pages/man2/perf_event_open.2.html
+  uint64_t quot = tsc >> m_time_shift;
+  uint64_t rem_flag = (((uint64_t)1 << m_time_shift) - 1);
+  uint64_t rem = tsc & rem_flag;
+  return std::chrono::nanoseconds{m_time_zero + quot * m_time_mult +
+                                  ((rem * m_time_mult) >> m_time_shift)};
+}
+
+void resource_handle::MmapDeleter::operator()(void *ptr) {
+  if (m_bytes && ptr != nullptr)
+    munmap(ptr, m_bytes);
+}
+
+void resource_handle::FileDescriptorDeleter::operator()(long *ptr) {
+  if (ptr == nullptr)
+    return;
+  if (*ptr == -1)
+    return;
+  close(*ptr);
+  std::default_delete<long>()(ptr);
+}
+
+llvm::Expected<PerfEvent> PerfEvent::Init(perf_event_attr &attr,
+                                          lldb::pid_t pid, int cpu,
+                                          int group_fd, unsigned long flags) {
+  errno = 0;
+  long fd = syscall(SYS_perf_event_open, &attr, pid, cpu, group_fd, flags);
+  if (fd == -1) {
+    std::string err_msg =
+        llvm::formatv("perf event syscall failed: {0}", std::strerror(errno));
+    return llvm::createStringError(llvm::inconvertibleErrorCode(), err_msg);
+  }
+  return PerfEvent{fd};
+}
+
+llvm::Expected<PerfEvent> PerfEvent::Init(perf_event_attr &attr,
+                                          lldb::pid_t pid) {
+  return Init(attr, pid, -1, -1, 0);
+}
+
+llvm::Expected<resource_handle::MmapUP>
+PerfEvent::DoMmap(void *addr, size_t length, int prot, int flags,
+                  long int offset, llvm::StringRef buffer_name) {
+  errno = 0;
+  auto mmap_result = ::mmap(nullptr, length, prot, flags, GetFd(), offset);
+
+  if (mmap_result == MAP_FAILED) {
+    std::string err_msg =
+        llvm::formatv("perf event mmap allocation failed for {0}: {1}",
+                      buffer_name, std::strerror(errno));
+    return createStringError(inconvertibleErrorCode(), err_msg);
+  }
+  return resource_handle::MmapUP(mmap_result, length);
+}
+
+llvm::Error PerfEvent::MmapMetadataAndDataBuffer(size_t num_data_pages) {
+  size_t mmap_size = (num_data_pages + 1) * getpagesize();
+  if (Expected<resource_handle::MmapUP> mmap_metadata_data =
+          DoMmap(nullptr, mmap_size, PROT_WRITE, MAP_SHARED, 0,
+                 "metadata and data buffer")) {
+    m_metadata_data_base = std::move(mmap_metadata_data.get());
+    return Error::success();
+  } else
+    return mmap_metadata_data.takeError();
+}
+
+llvm::Error PerfEvent::MmapAuxBuffer(size_t num_aux_pages) {
+  if (num_aux_pages == 0)
+    return Error::success();
+
+  perf_event_mmap_page &metadata_page = GetMetadataPage();
+  metadata_page.aux_offset =
+      metadata_page.data_offset + metadata_page.data_size;
+  metadata_page.aux_size = num_aux_pages * getpagesize();
+
+  if (Expected<resource_handle::MmapUP> mmap_aux =
+          DoMmap(nullptr, metadata_page.aux_size, PROT_READ, MAP_SHARED,
+                 metadata_page.aux_offset, "aux buffer")) {
+    m_aux_base = std::move(mmap_aux.get());
+    return Error::success();
+  } else
+    return mmap_aux.takeError();
+}
+
+llvm::Error PerfEvent::MmapMetadataAndBuffers(size_t num_data_pages,
+                                              size_t num_aux_pages) {
+  if (num_data_pages != 0 && !isPowerOf2_64(num_data_pages))
+    return llvm::createStringError(
+        llvm::inconvertibleErrorCode(),
+        llvm::formatv("Number of data pages must be a power of 2, got: {0}",
+                      num_data_pages));
+  if (num_aux_pages != 0 && !isPowerOf2_64(num_aux_pages))
+    return llvm::createStringError(
+        llvm::inconvertibleErrorCode(),
+        llvm::formatv("Number of aux pages must be a power of 2, got: {0}",
+                      num_aux_pages));
+  if (Error err = MmapMetadataAndDataBuffer(num_data_pages))
+    return err;
+  if (Error err = MmapAuxBuffer(num_aux_pages))
+    return err;
+  return Error::success();
+}
+
+long PerfEvent::GetFd() const { return *(m_fd.get()); }
+
+perf_event_mmap_page &PerfEvent::GetMetadataPage() const {
+  return *reinterpret_cast<perf_event_mmap_page *>(m_metadata_data_base.get());
+}
+
+ArrayRef<uint8_t> PerfEvent::GetDataBuffer() const {
+  perf_event_mmap_page &mmap_metadata = GetMetadataPage();
+  return {reinterpret_cast<uint8_t *>(m_metadata_data_base.get()) +
+              mmap_metadata.data_offset,
+          mmap_metadata.data_size};
+}
+
+ArrayRef<uint8_t> PerfEvent::GetAuxBuffer() const {
+  perf_event_mmap_page &mmap_metadata = GetMetadataPage();
+  return {reinterpret_cast<uint8_t *>(m_aux_base.get()),
+          mmap_metadata.aux_size};
+}

lldb/unittests/Process/Linux/CMakeLists.txt

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

lldb/unittests/Process/Linux/IntelPTCollectorTests.cpp

 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::MutableArrayRef<uint8_t> src(reinterpret_cast<uint8_t *>(cyc_buf),
-                                     cyc_buf_size);
+  llvm::ArrayRef<uint8_t> src(reinterpret_cast<uint8_t *>(cyc_buf),
   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'};
 

lldb/unittests/Process/Linux/PerfTests.cpp

+//===-- PerfTests.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 "llvm/Support/Error.h"
+
+#include "gtest/gtest.h"
+#include <chrono>
+#include <cstdint>
+
+using namespace lldb_private;
+using namespace process_linux;
+using namespace llvm;
+
+/// Helper function to read current TSC value.
+///
+/// This code is based on llvm/xray.
+static Expected<uint64_t> readTsc() {
+
+  unsigned int eax, ebx, ecx, edx;
+
+  // We check whether rdtscp support is enabled. According to the x86_64 manual,
+  // level should be set at 0x80000001, and we should have a look at bit 27 in
+  // EDX. That's 0x8000000 (or 1u << 27).
+  __asm__ __volatile__("cpuid"
+                       : "=a"(eax), "=b"(ebx), "=c"(ecx), "=d"(edx)
+                       : "0"(0x80000001));
+  if (!(edx & (1u << 27))) {
+    return createStringError(inconvertibleErrorCode(),
+                             "Missing rdtscp support.");
+  }
+
+  unsigned cpu;
+  unsigned long rax, rdx;
+
+  __asm__ __volatile__("rdtscp\n" : "=a"(rax), "=d"(rdx), "=c"(cpu)::);
+
+  return (rdx << 32) + rax;
+}
+
+// Test TSC to walltime conversion based on perf conversion values.
+TEST(Perf, TscConversion) {
+  // This test works by first reading the TSC value directly before
+  // and after sleeping, then converting these values to nanoseconds, and
+  // finally ensuring the difference is approximately equal to the sleep time.
+  //
+  // There will be slight overhead associated with the sleep call, so it isn't
+  // reasonable to expect the difference to be exactly equal to the sleep time.
+
+  const int SLEEP_SECS = 1;
+  std::chrono::nanoseconds SLEEP_NANOS{std::chrono::seconds(SLEEP_SECS)};
+
+  Expected<PerfTscConversionParameters> params =
+      FetchPerfTscConversionParameters();
+
+  // Skip the test if the conversion parameters aren't available.
+  if (!params)
+    GTEST_SKIP() << params.takeError();
+
+  Expected<uint64_t> tsc_before_sleep = readTsc();
+  sleep(SLEEP_SECS);
+  Expected<uint64_t> tsc_after_sleep = readTsc();
+
+  // Skip the test if we are unable to read the TSC value.
+  if (!tsc_before_sleep)
+    GTEST_SKIP() << tsc_before_sleep.takeError();
+  if (!tsc_after_sleep)
+    GTEST_SKIP() << tsc_after_sleep.takeError();
+
+  std::chrono::nanoseconds converted_tsc_diff =
+      params->ToWallTime(*tsc_after_sleep) -
+      params->ToWallTime(*tsc_before_sleep);
+
+  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());
+}