WIP strawman building perf.cpp on an older kernel

[DavidSpickett]

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

28

Use this sort of thing, or an ifdef set by cmake.

[labath]

(This file is only used for the processor trace feature, and one can debug just fine without it. So, I'd just conditionally compile out the processor trace support on older kernels -- it's highly questionable whether this works there anyway).

[DavidSpickett]

For https://github.com/llvm/llvm-project/issues/57594, succeeded by https://reviews.llvm.org/D133778.

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/Utility/TraceIntelPTGDBRemotePackets.h"
 #include "lldb/lldb-types.h"
 #include "llvm/Support/Error.h"
 #include <chrono>
 #include <cstdint>
 #include <linux/perf_event.h>
 
+struct perf_event_mmap_page_custom {
+  int cap_user_time;
+  int cap_user_time_zero;
+  uint32_t time_mult;
+  uint16_t time_shift;
+  uint64_t time_zero;
+
+  //uint64_t aux_head;
+  //int aux_offset;
+  //unsigned long aux_size;
+  //uint64_t data_head;
+  //int data_offset;
+  //unsigned long data_size;
+};
+
 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.
public:
   /// 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.
+  ///     the metadata, \a perf_event_mmap_page_custom, 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.
   ///
   /// \param[in] data_buffer_write
   ///     Whether to mmap the data buffer with WRITE permissions. This changes
public:
   /// 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;
+  ///   The data section's \a perf_event_mmap_page_custom.
+  perf_event_mmap_page_custom &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.
llvm::Expected<resource_handle::MmapUP> DoMmap(void *addr, size_t length,
                                                  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.
+  ///     the metadata, \a perf_event_mmap_page_custom, or the aux buffer.
   ///
   /// \param[in] data_buffer_write
   ///     Whether to mmap the data buffer with WRITE permissions. This changes
   ///     the behavior of how the kernel writes to the data buffer.
   llvm::Error MmapMetadataAndDataBuffer(size_t num_data_pages,
                                         bool data_buffer_write);
 
   /// Mmap the aux buffer of the perf event.

 ///
 /// \param[in] parent_perf_event
 ///   An optional perf event that will be grouped with the
 ///   new perf event.
 llvm::Expected<PerfEvent>
 CreateContextSwitchTracePerfEvent(lldb::cpu_id_t cpu_id,
                                   const PerfEvent *parent_perf_event = nullptr);
 
-/// Load \a PerfTscConversionParameters from \a perf_event_mmap_page, if
+/// Load \a PerfTscConversionParameters from \a perf_event_mmap_page_custom, if
 /// available.
 llvm::Expected<LinuxPerfZeroTscConversion> LoadPerfTscConversionParameters();
 
 } // 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 <unistd.h>
 
 using namespace lldb_private;
 using namespace process_linux;
 using namespace llvm;
 
 Expected<LinuxPerfZeroTscConversion>
 lldb_private::process_linux::LoadPerfTscConversionParameters() {
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 12, 0)
   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,
                                              /*data_buffer_write=*/false))
     return std::move(mmap_err);
 
-  perf_event_mmap_page &mmap_metada = perf_event->GetMetadataPage();
+  perf_event_mmap_page_custom &mmap_metada = perf_event->GetMetadataPage();
   if (mmap_metada.cap_user_time && mmap_metada.cap_user_time_zero) {
     return LinuxPerfZeroTscConversion{
         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. "
llvm::Error PerfEvent::MmapMetadataAndDataBuffer(size_t num_data_pages,
   } 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();
+  return llvm::createStringError(
+        llvm::inconvertibleErrorCode(), "foo");
 
-  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();
+//  perf_event_mmap_page_custom &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,
                                               bool data_buffer_write) {
   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, data_buffer_write))
     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());
+perf_event_mmap_page_custom &PerfEvent::GetMetadataPage() const {
+  return *reinterpret_cast<perf_event_mmap_page_custom *>(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,
-          static_cast<size_t>(mmap_metadata.data_size)};
+  // TODO: assert that this isn't called!
+  return {};
+//  perf_event_mmap_page_custom &mmap_metadata = GetMetadataPage();
+//  return {reinterpret_cast<uint8_t *>(m_metadata_data_base.get()) +
+//              mmap_metadata.data_offset,
+//          static_cast<size_t>(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()),
-          static_cast<size_t>(mmap_metadata.aux_size)};
+  return {};
+//  perf_event_mmap_page_custom &mmap_metadata = GetMetadataPage();
+//  return {reinterpret_cast<uint8_t *>(m_aux_base.get()),
+//          static_cast<size_t>(mmap_metadata.aux_size)};
 }
 
 Expected<std::vector<uint8_t>> PerfEvent::GetReadOnlyDataBuffer() {
   // The following code assumes that the protection level of the DATA page
   // is PROT_READ. If PROT_WRITE is used, then reading would require that
   // this piece of code updates some pointers. See more about data_tail
   // in https://man7.org/linux/man-pages/man2/perf_event_open.2.html.
 
-  bool was_enabled = m_enabled;
+  //bool was_enabled = m_enabled;
   if (Error err = DisableWithIoctl())
     return std::move(err);
 
   /**
    * The data buffer and aux buffer have different implementations
    * with respect to their definition of head pointer when using PROD_READ only.
    * 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
    */
-  perf_event_mmap_page &mmap_metadata = GetMetadataPage();
-
-  ArrayRef<uint8_t> data = GetDataBuffer();
-  uint64_t data_head = mmap_metadata.data_head;
-  uint64_t data_size = mmap_metadata.data_size;
-  std::vector<uint8_t> output;
-  output.reserve(data.size());
-
-  if (data_head > data_size) {
-    uint64_t actual_data_head = data_head % data_size;
-    // The buffer has wrapped, so we first the oldest chunk of data
-    output.insert(output.end(), data.begin() + actual_data_head, data.end());
-    // And we we read the most recent chunk of data
-    output.insert(output.end(), data.begin(), data.begin() + actual_data_head);
-  } else {
-    // There's been no wrapping, so we just read linearly
-    output.insert(output.end(), data.begin(), data.begin() + data_head);
-  }
-
-  if (was_enabled) {
-    if (Error err = EnableWithIoctl())
-      return std::move(err);
-  }
-
-  return output;
+  return llvm::createStringError(
+      llvm::inconvertibleErrorCode(), "foo");
+//  perf_event_mmap_page_custom &mmap_metadata = GetMetadataPage();
+//
+//  ArrayRef<uint8_t> data = GetDataBuffer();
+//  uint64_t data_head = mmap_metadata.data_head;
+//  uint64_t data_size = mmap_metadata.data_size;
+//  std::vector<uint8_t> output;
+//  output.reserve(data.size());
+//
+//  if (data_head > data_size) {
+//    uint64_t actual_data_head = data_head % data_size;
+//    // The buffer has wrapped, so we first the oldest chunk of data
+//    output.insert(output.end(), data.begin() + actual_data_head, data.end());
+//    // And we we read the most recent chunk of data
+//    output.insert(output.end(), data.begin(), data.begin() + actual_data_head);
+//  } else {
+//    // There's been no wrapping, so we just read linearly
+//    output.insert(output.end(), data.begin(), data.begin() + data_head);
+//  }
+//
+//  if (was_enabled) {
+//    if (Error err = EnableWithIoctl())
+//      return std::move(err);
+//  }
+//
+//  return output;
 }
 
 Expected<std::vector<uint8_t>> PerfEvent::GetReadOnlyAuxBuffer() {
   // The following code assumes that the protection level of the AUX page
   // is PROT_READ. If PROT_WRITE is used, then reading would require that
   // this piece of code updates some pointers. See more about aux_tail
   // in https://man7.org/linux/man-pages/man2/perf_event_open.2.html.
 
-  bool was_enabled = m_enabled;
+  //bool was_enabled = m_enabled;
   if (Error err = DisableWithIoctl())
     return std::move(err);
 
-  perf_event_mmap_page &mmap_metadata = GetMetadataPage();
-
-  ArrayRef<uint8_t> data = GetAuxBuffer();
-  uint64_t aux_head = mmap_metadata.aux_head;
-  std::vector<uint8_t> output;
-  output.reserve(data.size());
-
-  /**
-   * 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  ->|
-   *
-   * */
-
-  output.insert(output.end(), data.begin() + aux_head, data.end());
-  output.insert(output.end(), data.begin(), data.begin() + aux_head);
-
-  if (was_enabled) {
-    if (Error err = EnableWithIoctl())
-      return std::move(err);
-  }
+  return llvm::createStringError(
+      llvm::inconvertibleErrorCode(), "foo");
 
-  return output;
+//  perf_event_mmap_page_custom &mmap_metadata = GetMetadataPage();
+//
+//  ArrayRef<uint8_t> data = GetAuxBuffer();
+//  uint64_t aux_head = mmap_metadata.aux_head;
+//  std::vector<uint8_t> output;
+//  output.reserve(data.size());
+//
+//  /**
+//   * 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  ->|
+//   *
+//   * */
+//
+//  output.insert(output.end(), data.begin() + aux_head, data.end());
+//  output.insert(output.end(), data.begin(), data.begin() + aux_head);
+//
+//  if (was_enabled) {
+//    if (Error err = EnableWithIoctl())
+//      return std::move(err);
+//  }
+//
+//  return output;
 }
 
 Error PerfEvent::DisableWithIoctl() {
   if (!m_enabled)
     return Error::success();
 
   if (ioctl(*m_fd, PERF_EVENT_IOC_DISABLE, PERF_IOC_FLAG_GROUP) < 0)
     return createStringError(inconvertibleErrorCode(),
return createStringError(inconvertibleErrorCode(),
                              "Can't enable perf event. %s",
                              std::strerror(errno));
 
   m_enabled = true;
   return Error::success();
 }
 
 size_t PerfEvent::GetEffectiveDataBufferSize() const {
-  perf_event_mmap_page &mmap_metadata = GetMetadataPage();
-  if (mmap_metadata.data_head < mmap_metadata.data_size)
-    return mmap_metadata.data_head;
-  else
-    return mmap_metadata.data_size; // The buffer has wrapped.
+  // TODO: assert not called!
+  return 0;
+//  perf_event_mmap_page_custom &mmap_metadata = GetMetadataPage();
+//  if (mmap_metadata.data_head < mmap_metadata.data_size)
+//    return mmap_metadata.data_head;
+//  else
+//    return mmap_metadata.data_size; // The buffer has wrapped.
 }
 
 Expected<PerfEvent>
 lldb_private::process_linux::CreateContextSwitchTracePerfEvent(
     lldb::cpu_id_t cpu_id, const PerfEvent *parent_perf_event) {
   Log *log = GetLog(POSIXLog::Trace);
 #ifndef PERF_ATTR_SIZE_VER5
   return createStringError(inconvertibleErrorCode(),