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, attr.disabled ? CollectionState::Disabled
134                                      : CollectionState::Enabled);
135 }
136 
137 llvm::Expected<PerfEvent> PerfEvent::Init(perf_event_attr &attr,
138                                           Optional<lldb::pid_t> pid,
139                                           Optional<lldb::core_id_t> cpu) {
140   return Init(attr, pid, cpu, -1, 0);
141 }
142 
143 llvm::Expected<resource_handle::MmapUP>
144 PerfEvent::DoMmap(void *addr, size_t length, int prot, int flags,
145                   long int offset, llvm::StringRef buffer_name) {
146   errno = 0;
147   auto mmap_result = ::mmap(addr, length, prot, flags, GetFd(), offset);
148 
149   if (mmap_result == MAP_FAILED) {
150     std::string err_msg =
151         llvm::formatv("perf event mmap allocation failed for {0}: {1}",
152                       buffer_name, std::strerror(errno));
153     return createStringError(inconvertibleErrorCode(), err_msg);
154   }
155   return resource_handle::MmapUP(mmap_result, length);
156 }
157 
158 llvm::Error PerfEvent::MmapMetadataAndDataBuffer(size_t num_data_pages) {
159   size_t mmap_size = (num_data_pages + 1) * getpagesize();
160   if (Expected<resource_handle::MmapUP> mmap_metadata_data =
161           DoMmap(nullptr, mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED, 0,
162                  "metadata and data buffer")) {
163     m_metadata_data_base = std::move(mmap_metadata_data.get());
164     return Error::success();
165   } else
166     return mmap_metadata_data.takeError();
167 }
168 
169 llvm::Error PerfEvent::MmapAuxBuffer(size_t num_aux_pages) {
170   if (num_aux_pages == 0)
171     return Error::success();
172 
173   perf_event_mmap_page &metadata_page = GetMetadataPage();
174   metadata_page.aux_offset =
175       metadata_page.data_offset + metadata_page.data_size;
176   metadata_page.aux_size = num_aux_pages * getpagesize();
177 
178   if (Expected<resource_handle::MmapUP> mmap_aux =
179           DoMmap(nullptr, metadata_page.aux_size, PROT_READ, MAP_SHARED,
180                  metadata_page.aux_offset, "aux buffer")) {
181     m_aux_base = std::move(mmap_aux.get());
182     return Error::success();
183   } else
184     return mmap_aux.takeError();
185 }
186 
187 llvm::Error PerfEvent::MmapMetadataAndBuffers(size_t num_data_pages,
188                                               size_t num_aux_pages) {
189   if (num_data_pages != 0 && !isPowerOf2_64(num_data_pages))
190     return llvm::createStringError(
191         llvm::inconvertibleErrorCode(),
192         llvm::formatv("Number of data pages must be a power of 2, got: {0}",
193                       num_data_pages));
194   if (num_aux_pages != 0 && !isPowerOf2_64(num_aux_pages))
195     return llvm::createStringError(
196         llvm::inconvertibleErrorCode(),
197         llvm::formatv("Number of aux pages must be a power of 2, got: {0}",
198                       num_aux_pages));
199   if (Error err = MmapMetadataAndDataBuffer(num_data_pages))
200     return err;
201   if (Error err = MmapAuxBuffer(num_aux_pages))
202     return err;
203   return Error::success();
204 }
205 
206 long PerfEvent::GetFd() const { return *(m_fd.get()); }
207 
208 perf_event_mmap_page &PerfEvent::GetMetadataPage() const {
209   return *reinterpret_cast<perf_event_mmap_page *>(m_metadata_data_base.get());
210 }
211 
212 ArrayRef<uint8_t> PerfEvent::GetDataBuffer() const {
213   perf_event_mmap_page &mmap_metadata = GetMetadataPage();
214   return {reinterpret_cast<uint8_t *>(m_metadata_data_base.get()) +
215               mmap_metadata.data_offset,
216            static_cast<size_t>(mmap_metadata.data_size)};
217 }
218 
219 ArrayRef<uint8_t> PerfEvent::GetAuxBuffer() const {
220   perf_event_mmap_page &mmap_metadata = GetMetadataPage();
221   return {reinterpret_cast<uint8_t *>(m_aux_base.get()),
222            static_cast<size_t>(mmap_metadata.aux_size)};
223 }
224 
225 Expected<std::vector<uint8_t>>
226 PerfEvent::ReadFlushedOutAuxCyclicBuffer(size_t offset, size_t size) {
227   CollectionState previous_state = m_collection_state;
228   if (Error err = DisableWithIoctl())
229     return std::move(err);
230 
231   std::vector<uint8_t> data(size, 0);
232   perf_event_mmap_page &mmap_metadata = GetMetadataPage();
233   Log *log = GetLog(POSIXLog::Trace);
234   uint64_t head = mmap_metadata.aux_head;
235 
236   LLDB_LOG(log, "Aux size -{0} , Head - {1}", mmap_metadata.aux_size, head);
237 
238   /**
239    * When configured as ring buffer, the aux buffer keeps wrapping around
240    * the buffer and its not possible to detect how many times the buffer
241    * wrapped. Initially the buffer is filled with zeros,as shown below
242    * so in order to get complete buffer we first copy firstpartsize, followed
243    * by any left over part from beginning to aux_head
244    *
245    * aux_offset [d,d,d,d,d,d,d,d,0,0,0,0,0,0,0,0,0,0,0] aux_size
246    *                 aux_head->||<- firstpartsize  ->|
247    *
248    * */
249 
250   MutableArrayRef<uint8_t> buffer(data);
251   ReadCyclicBuffer(buffer, GetAuxBuffer(), static_cast<size_t>(head), offset);
252 
253   if (previous_state == CollectionState::Enabled) {
254     if (Error err = EnableWithIoctl())
255       return std::move(err);
256   }
257 
258   return data;
259 }
260 
261 Error PerfEvent::DisableWithIoctl() {
262   if (m_collection_state == CollectionState::Disabled)
263     return Error::success();
264 
265   if (ioctl(*m_fd, PERF_EVENT_IOC_DISABLE, PERF_IOC_FLAG_GROUP) < 0)
266     return createStringError(inconvertibleErrorCode(),
267                              "Can't disable perf event. %s",
268                              std::strerror(errno));
269 
270   m_collection_state = CollectionState::Disabled;
271   return Error::success();
272 }
273 
274 Error PerfEvent::EnableWithIoctl() {
275   if (m_collection_state == CollectionState::Enabled)
276     return Error::success();
277 
278   if (ioctl(*m_fd, PERF_EVENT_IOC_ENABLE, PERF_IOC_FLAG_GROUP) < 0)
279     return createStringError(inconvertibleErrorCode(),
280                              "Can't enable perf event. %s",
281                              std::strerror(errno));
282 
283   m_collection_state = CollectionState::Enabled;
284   return Error::success();
285 }
286 
287 size_t PerfEvent::GetEffectiveDataBufferSize() const {
288   perf_event_mmap_page &mmap_metadata = GetMetadataPage();
289   if (mmap_metadata.data_head < mmap_metadata.data_size)
290     return mmap_metadata.data_head;
291   else
292     return mmap_metadata.data_size; // The buffer has wrapped.
293 }
294