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 "Plugins/Process/POSIX/ProcessPOSIXLog.h"
12 #include "lldb/Host/linux/Support.h"
13 
14 #include "llvm/Support/FormatVariadic.h"
15 #include "llvm/Support/MathExtras.h"
16 #include "llvm/Support/MemoryBuffer.h"
17 
18 #include <sys/ioctl.h>
19 #include <sys/mman.h>
20 #include <sys/syscall.h>
21 #include <unistd.h>
22 
23 using namespace lldb_private;
24 using namespace process_linux;
25 using namespace llvm;
26 
27 void lldb_private::process_linux::ReadCyclicBuffer(
28     llvm::MutableArrayRef<uint8_t> &dst, llvm::ArrayRef<uint8_t> src,
29     size_t src_cyc_index, size_t offset) {
30 
31   Log *log = GetLog(POSIXLog::Trace);
32 
33   if (dst.empty() || src.empty()) {
34     dst = dst.drop_back(dst.size());
35     return;
36   }
37 
38   if (dst.data() == nullptr || src.data() == nullptr) {
39     dst = dst.drop_back(dst.size());
40     return;
41   }
42 
43   if (src_cyc_index > src.size()) {
44     dst = dst.drop_back(dst.size());
45     return;
46   }
47 
48   if (offset >= src.size()) {
49     LLDB_LOG(log, "Too Big offset ");
50     dst = dst.drop_back(dst.size());
51     return;
52   }
53 
54   llvm::SmallVector<ArrayRef<uint8_t>, 2> parts = {
55       src.slice(src_cyc_index), src.take_front(src_cyc_index)};
56 
57   if (offset > parts[0].size()) {
58     parts[1] = parts[1].slice(offset - parts[0].size());
59     parts[0] = parts[0].drop_back(parts[0].size());
60   } else if (offset == parts[0].size()) {
61     parts[0] = parts[0].drop_back(parts[0].size());
62   } else {
63     parts[0] = parts[0].slice(offset);
64   }
65   auto next = dst.begin();
66   auto bytes_left = dst.size();
67   for (auto part : parts) {
68     size_t chunk_size = std::min(part.size(), bytes_left);
69     next = std::copy_n(part.begin(), chunk_size, next);
70     bytes_left -= chunk_size;
71   }
72   dst = dst.drop_back(bytes_left);
73 }
74 
75 Expected<LinuxPerfZeroTscConversion>
76 lldb_private::process_linux::LoadPerfTscConversionParameters() {
77   lldb::pid_t pid = getpid();
78   perf_event_attr attr;
79   memset(&attr, 0, sizeof(attr));
80   attr.size = sizeof(attr);
81   attr.type = PERF_TYPE_SOFTWARE;
82   attr.config = PERF_COUNT_SW_DUMMY;
83 
84   Expected<PerfEvent> perf_event = PerfEvent::Init(attr, pid);
85   if (!perf_event)
86     return perf_event.takeError();
87   if (Error mmap_err = perf_event->MmapMetadataAndBuffers(/*num_data_pages*/ 0,
88                                                           /*num_aux_pages*/ 0))
89     return std::move(mmap_err);
90 
91   perf_event_mmap_page &mmap_metada = perf_event->GetMetadataPage();
92   if (mmap_metada.cap_user_time && mmap_metada.cap_user_time_zero) {
93     return LinuxPerfZeroTscConversion{
94         mmap_metada.time_mult, mmap_metada.time_shift, mmap_metada.time_zero};
95   } else {
96     auto err_cap =
97         !mmap_metada.cap_user_time ? "cap_user_time" : "cap_user_time_zero";
98     std::string err_msg =
99         llvm::formatv("Can't get TSC to real time conversion values. "
100                       "perf_event capability '{0}' not supported.",
101                       err_cap);
102     return llvm::createStringError(llvm::inconvertibleErrorCode(), err_msg);
103   }
104 }
105 
106 void resource_handle::MmapDeleter::operator()(void *ptr) {
107   if (m_bytes && ptr != nullptr)
108     munmap(ptr, m_bytes);
109 }
110 
111 void resource_handle::FileDescriptorDeleter::operator()(long *ptr) {
112   if (ptr == nullptr)
113     return;
114   if (*ptr == -1)
115     return;
116   close(*ptr);
117   std::default_delete<long>()(ptr);
118 }
119 
120 llvm::Expected<PerfEvent> PerfEvent::Init(perf_event_attr &attr,
121                                           Optional<lldb::pid_t> pid,
122                                           Optional<lldb::core_id_t> cpu,
123                                           Optional<int> group_fd,
124                                           unsigned long flags) {
125   errno = 0;
126   long fd = syscall(SYS_perf_event_open, &attr, pid.getValueOr(-1),
127                     cpu.getValueOr(-1), group_fd.getValueOr(-1), flags);
128   if (fd == -1) {
129     std::string err_msg =
130         llvm::formatv("perf event syscall failed: {0}", std::strerror(errno));
131     return llvm::createStringError(llvm::inconvertibleErrorCode(), err_msg);
132   }
133   return PerfEvent{fd};
134 }
135 
136 llvm::Expected<PerfEvent> PerfEvent::Init(perf_event_attr &attr,
137                                           Optional<lldb::pid_t> pid,
138                                           Optional<lldb::core_id_t> cpu) {
139   return Init(attr, pid, cpu, -1, 0);
140 }
141 
142 llvm::Expected<resource_handle::MmapUP>
143 PerfEvent::DoMmap(void *addr, size_t length, int prot, int flags,
144                   long int offset, llvm::StringRef buffer_name) {
145   errno = 0;
146   auto mmap_result = ::mmap(nullptr, length, prot, flags, GetFd(), offset);
147 
148   if (mmap_result == MAP_FAILED) {
149     std::string err_msg =
150         llvm::formatv("perf event mmap allocation failed for {0}: {1}",
151                       buffer_name, std::strerror(errno));
152     return createStringError(inconvertibleErrorCode(), err_msg);
153   }
154   return resource_handle::MmapUP(mmap_result, length);
155 }
156 
157 llvm::Error PerfEvent::MmapMetadataAndDataBuffer(size_t num_data_pages) {
158   size_t mmap_size = (num_data_pages + 1) * getpagesize();
159   if (Expected<resource_handle::MmapUP> mmap_metadata_data =
160           DoMmap(nullptr, mmap_size, PROT_WRITE, MAP_SHARED, 0,
161                  "metadata and data buffer")) {
162     m_metadata_data_base = std::move(mmap_metadata_data.get());
163     return Error::success();
164   } else
165     return mmap_metadata_data.takeError();
166 }
167 
168 llvm::Error PerfEvent::MmapAuxBuffer(size_t num_aux_pages) {
169   if (num_aux_pages == 0)
170     return Error::success();
171 
172   perf_event_mmap_page &metadata_page = GetMetadataPage();
173   metadata_page.aux_offset =
174       metadata_page.data_offset + metadata_page.data_size;
175   metadata_page.aux_size = num_aux_pages * getpagesize();
176 
177   if (Expected<resource_handle::MmapUP> mmap_aux =
178           DoMmap(nullptr, metadata_page.aux_size, PROT_READ, MAP_SHARED,
179                  metadata_page.aux_offset, "aux buffer")) {
180     m_aux_base = std::move(mmap_aux.get());
181     return Error::success();
182   } else
183     return mmap_aux.takeError();
184 }
185 
186 llvm::Error PerfEvent::MmapMetadataAndBuffers(size_t num_data_pages,
187                                               size_t num_aux_pages) {
188   if (num_data_pages != 0 && !isPowerOf2_64(num_data_pages))
189     return llvm::createStringError(
190         llvm::inconvertibleErrorCode(),
191         llvm::formatv("Number of data pages must be a power of 2, got: {0}",
192                       num_data_pages));
193   if (num_aux_pages != 0 && !isPowerOf2_64(num_aux_pages))
194     return llvm::createStringError(
195         llvm::inconvertibleErrorCode(),
196         llvm::formatv("Number of aux pages must be a power of 2, got: {0}",
197                       num_aux_pages));
198   if (Error err = MmapMetadataAndDataBuffer(num_data_pages))
199     return err;
200   if (Error err = MmapAuxBuffer(num_aux_pages))
201     return err;
202   return Error::success();
203 }
204 
205 long PerfEvent::GetFd() const { return *(m_fd.get()); }
206 
207 perf_event_mmap_page &PerfEvent::GetMetadataPage() const {
208   return *reinterpret_cast<perf_event_mmap_page *>(m_metadata_data_base.get());
209 }
210 
211 ArrayRef<uint8_t> PerfEvent::GetDataBuffer() const {
212   perf_event_mmap_page &mmap_metadata = GetMetadataPage();
213   return {reinterpret_cast<uint8_t *>(m_metadata_data_base.get()) +
214               mmap_metadata.data_offset,
215            static_cast<size_t>(mmap_metadata.data_size)};
216 }
217 
218 ArrayRef<uint8_t> PerfEvent::GetAuxBuffer() const {
219   perf_event_mmap_page &mmap_metadata = GetMetadataPage();
220   return {reinterpret_cast<uint8_t *>(m_aux_base.get()),
221            static_cast<size_t>(mmap_metadata.aux_size)};
222 }
223 
224 Error PerfEvent::DisableWithIoctl() const {
225   if (ioctl(*m_fd, PERF_EVENT_IOC_DISABLE) < 0)
226     return createStringError(inconvertibleErrorCode(),
227                              "Can't disable perf event. %s",
228                              std::strerror(errno));
229   return Error::success();
230 }
231 
232 Error PerfEvent::EnableWithIoctl() const {
233   if (ioctl(*m_fd, PERF_EVENT_IOC_ENABLE) < 0)
234     return createStringError(inconvertibleErrorCode(),
235                              "Can't disable perf event. %s",
236                              std::strerror(errno));
237   return Error::success();
238 }
239