Fix LLDB build on old Linux kernels (pre-4.1)

[calebzulawski]

Summary

These fields are guarded elsewhere, but were missing here.

[DavidSpickett]

Adding reviewers who know the trace feature.

Seems fine at a glance for the functions that return error types already but for example GetEffectiveDataBufferSize check who calls it and might crash if it returns 0.

[calebzulawski]

I'm not exactly sure what llvm_unreachable does, but I don't believe it will return 0 (maybe it aborts?)

[DavidSpickett]

llvm_unreachable is equivalent to __builtin_unreachable so yes it aborts with a stack trace. I misread and thought you were returning values still.

Worth trying one of the trace commands in this build and see if lldb crashes or we get a nice "not supported" message. unreachable is fine if we're reasonably sure you won't get there by accident.

[calebzulawski]

In terms of who calls it and might error, it looks like it's all used in IntelPTMultiCoreTrace.cpp

[DavidSpickett]

old Linux kernels

Also, could you include the kernel versions (that you know about at least) in the commit message. For the next person who hits this and wonders if your change is what they need to include.

[wallace]

Lgtm!

[wallace]

Thanks!!

[DavidSpickett]

Did this ever land? I only see https://github.com/llvm/llvm-project/commit/d35702efe73010409c75b1f1b64f205cc3b2f6d3.

We have a short time to get this into 15.0.2, so I'd like to land this if it is needed.

[DavidSpickett]

I only have newer kernels but replacing the type with what it looks like on an older kernel and undefing PERF_ATTR_SIZE_VER5, lldb does build. So it looks like this is a good thing to land.

[DavidSpickett]

I've landed this so it has some time to go through bots before a backport to 15.

Apologies that your name isn't in the commit, I did add an author line locally but Arc decided to remove it before landing.

If you do more fixes (and please do) get commit access yourself, or provide a name/email to use as the git author. Harder to miss that way.

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

if (Expected<resource_handle::MmapUP> mmap_metadata_data = DoMmap(
           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) {
+#ifndef PERF_ATTR_SIZE_VER5
+  return createStringError(inconvertibleErrorCode(),
+                           "Intel PT Linux perf event not supported");
+#else
   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();
+#endif
 }
 
 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(),

 
 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 {
+#ifndef PERF_ATTR_SIZE_VER5
+  llvm_unreachable("Intel PT Linux perf event not supported");
+#else
   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)};
+#endif
 }
 
 ArrayRef<uint8_t> PerfEvent::GetAuxBuffer() const {
+#ifndef PERF_ATTR_SIZE_VER5
+  llvm_unreachable("Intel PT Linux perf event not supported");
+#else
   perf_event_mmap_page &mmap_metadata = GetMetadataPage();
   return {reinterpret_cast<uint8_t *>(m_aux_base.get()),
           static_cast<size_t>(mmap_metadata.aux_size)};
+#endif
 }
 
 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.
 
+#ifndef PERF_ATTR_SIZE_VER5
+  return createStringError(inconvertibleErrorCode(),
+                           "Intel PT Linux perf event not supported");
+#else
   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
#else
   }
 
   if (was_enabled) {
     if (Error err = EnableWithIoctl())
       return std::move(err);
   }
 
   return output;
+#endif
 }
 
 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.
 
+#ifndef PERF_ATTR_SIZE_VER5
+  return createStringError(inconvertibleErrorCode(),
+                           "Intel PT Linux perf event not supported");
+#else
   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;
#else
   output.insert(output.end(), data.begin(), data.begin() + aux_head);
 
   if (was_enabled) {
     if (Error err = EnableWithIoctl())
       return std::move(err);
   }
 
   return output;
+#endif
 }
 
 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 {
+#ifndef PERF_ATTR_SIZE_VER5
+  llvm_unreachable("Intel PT Linux perf event not supported");
+#else
   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.
+#endif
 }
 
 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(),