1 //===-- Perf.cpp ----------------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "Perf.h" 10 11 #include "llvm/Support/FormatVariadic.h" 12 #include "llvm/Support/MathExtras.h" 13 14 #include <sys/mman.h> 15 #include <sys/syscall.h> 16 #include <unistd.h> 17 18 using namespace lldb_private; 19 using namespace process_linux; 20 using namespace llvm; 21 22 Expected<LinuxPerfZeroTscConversion> 23 lldb_private::process_linux::LoadPerfTscConversionParameters() { 24 lldb::pid_t pid = getpid(); 25 perf_event_attr attr; 26 memset(&attr, 0, sizeof(attr)); 27 attr.size = sizeof(attr); 28 attr.type = PERF_TYPE_SOFTWARE; 29 attr.config = PERF_COUNT_SW_DUMMY; 30 31 Expected<PerfEvent> perf_event = PerfEvent::Init(attr, pid); 32 if (!perf_event) 33 return perf_event.takeError(); 34 if (Error mmap_err = perf_event->MmapMetadataAndBuffers(/*num_data_pages*/ 0, 35 /*num_aux_pages*/ 0)) 36 return std::move(mmap_err); 37 38 perf_event_mmap_page &mmap_metada = perf_event->GetMetadataPage(); 39 if (mmap_metada.cap_user_time && mmap_metada.cap_user_time_zero) { 40 return LinuxPerfZeroTscConversion{ 41 mmap_metada.time_mult, mmap_metada.time_shift, mmap_metada.time_zero}; 42 } else { 43 auto err_cap = 44 !mmap_metada.cap_user_time ? "cap_user_time" : "cap_user_time_zero"; 45 std::string err_msg = 46 llvm::formatv("Can't get TSC to real time conversion values. " 47 "perf_event capability '{0}' not supported.", 48 err_cap); 49 return llvm::createStringError(llvm::inconvertibleErrorCode(), err_msg); 50 } 51 } 52 53 void resource_handle::MmapDeleter::operator()(void *ptr) { 54 if (m_bytes && ptr != nullptr) 55 munmap(ptr, m_bytes); 56 } 57 58 void resource_handle::FileDescriptorDeleter::operator()(long *ptr) { 59 if (ptr == nullptr) 60 return; 61 if (*ptr == -1) 62 return; 63 close(*ptr); 64 std::default_delete<long>()(ptr); 65 } 66 67 llvm::Expected<PerfEvent> PerfEvent::Init(perf_event_attr &attr, 68 lldb::pid_t pid, int cpu, 69 int group_fd, unsigned long flags) { 70 errno = 0; 71 long fd = syscall(SYS_perf_event_open, &attr, pid, cpu, group_fd, flags); 72 if (fd == -1) { 73 std::string err_msg = 74 llvm::formatv("perf event syscall failed: {0}", std::strerror(errno)); 75 return llvm::createStringError(llvm::inconvertibleErrorCode(), err_msg); 76 } 77 return PerfEvent{fd}; 78 } 79 80 llvm::Expected<PerfEvent> PerfEvent::Init(perf_event_attr &attr, 81 lldb::pid_t pid) { 82 return Init(attr, pid, -1, -1, 0); 83 } 84 85 llvm::Expected<resource_handle::MmapUP> 86 PerfEvent::DoMmap(void *addr, size_t length, int prot, int flags, 87 long int offset, llvm::StringRef buffer_name) { 88 errno = 0; 89 auto mmap_result = ::mmap(nullptr, length, prot, flags, GetFd(), offset); 90 91 if (mmap_result == MAP_FAILED) { 92 std::string err_msg = 93 llvm::formatv("perf event mmap allocation failed for {0}: {1}", 94 buffer_name, std::strerror(errno)); 95 return createStringError(inconvertibleErrorCode(), err_msg); 96 } 97 return resource_handle::MmapUP(mmap_result, length); 98 } 99 100 llvm::Error PerfEvent::MmapMetadataAndDataBuffer(size_t num_data_pages) { 101 size_t mmap_size = (num_data_pages + 1) * getpagesize(); 102 if (Expected<resource_handle::MmapUP> mmap_metadata_data = 103 DoMmap(nullptr, mmap_size, PROT_WRITE, MAP_SHARED, 0, 104 "metadata and data buffer")) { 105 m_metadata_data_base = std::move(mmap_metadata_data.get()); 106 return Error::success(); 107 } else 108 return mmap_metadata_data.takeError(); 109 } 110 111 llvm::Error PerfEvent::MmapAuxBuffer(size_t num_aux_pages) { 112 if (num_aux_pages == 0) 113 return Error::success(); 114 115 perf_event_mmap_page &metadata_page = GetMetadataPage(); 116 metadata_page.aux_offset = 117 metadata_page.data_offset + metadata_page.data_size; 118 metadata_page.aux_size = num_aux_pages * getpagesize(); 119 120 if (Expected<resource_handle::MmapUP> mmap_aux = 121 DoMmap(nullptr, metadata_page.aux_size, PROT_READ, MAP_SHARED, 122 metadata_page.aux_offset, "aux buffer")) { 123 m_aux_base = std::move(mmap_aux.get()); 124 return Error::success(); 125 } else 126 return mmap_aux.takeError(); 127 } 128 129 llvm::Error PerfEvent::MmapMetadataAndBuffers(size_t num_data_pages, 130 size_t num_aux_pages) { 131 if (num_data_pages != 0 && !isPowerOf2_64(num_data_pages)) 132 return llvm::createStringError( 133 llvm::inconvertibleErrorCode(), 134 llvm::formatv("Number of data pages must be a power of 2, got: {0}", 135 num_data_pages)); 136 if (num_aux_pages != 0 && !isPowerOf2_64(num_aux_pages)) 137 return llvm::createStringError( 138 llvm::inconvertibleErrorCode(), 139 llvm::formatv("Number of aux pages must be a power of 2, got: {0}", 140 num_aux_pages)); 141 if (Error err = MmapMetadataAndDataBuffer(num_data_pages)) 142 return err; 143 if (Error err = MmapAuxBuffer(num_aux_pages)) 144 return err; 145 return Error::success(); 146 } 147 148 long PerfEvent::GetFd() const { return *(m_fd.get()); } 149 150 perf_event_mmap_page &PerfEvent::GetMetadataPage() const { 151 return *reinterpret_cast<perf_event_mmap_page *>(m_metadata_data_base.get()); 152 } 153 154 ArrayRef<uint8_t> PerfEvent::GetDataBuffer() const { 155 perf_event_mmap_page &mmap_metadata = GetMetadataPage(); 156 return {reinterpret_cast<uint8_t *>(m_metadata_data_base.get()) + 157 mmap_metadata.data_offset, 158 static_cast<size_t>(mmap_metadata.data_size)}; 159 } 160 161 ArrayRef<uint8_t> PerfEvent::GetAuxBuffer() const { 162 perf_event_mmap_page &mmap_metadata = GetMetadataPage(); 163 return {reinterpret_cast<uint8_t *>(m_aux_base.get()), 164 static_cast<size_t>(mmap_metadata.aux_size)}; 165 } 166