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