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                                           Optional<lldb::pid_t> pid,
121                                           Optional<lldb::core_id_t> cpu,
122                                           Optional<int> group_fd,
123                                           unsigned long flags) {
124   errno = 0;
125   long fd = syscall(SYS_perf_event_open, &attr, pid.getValueOr(-1),
126                     cpu.getValueOr(-1), group_fd.getValueOr(-1), flags);
127   if (fd == -1) {
128     std::string err_msg =
129         llvm::formatv("perf event syscall failed: {0}", std::strerror(errno));
130     return llvm::createStringError(llvm::inconvertibleErrorCode(), err_msg);
131   }
132   return PerfEvent{fd};
133 }
134 
135 llvm::Expected<PerfEvent> PerfEvent::Init(perf_event_attr &attr,
136                                           Optional<lldb::pid_t> pid,
137                                           Optional<lldb::core_id_t> cpu) {
138   return Init(attr, pid, cpu, -1, 0);
139 }
140 
141 llvm::Expected<resource_handle::MmapUP>
142 PerfEvent::DoMmap(void *addr, size_t length, int prot, int flags,
143                   long int offset, llvm::StringRef buffer_name) {
144   errno = 0;
145   auto mmap_result = ::mmap(nullptr, length, prot, flags, GetFd(), offset);
146 
147   if (mmap_result == MAP_FAILED) {
148     std::string err_msg =
149         llvm::formatv("perf event mmap allocation failed for {0}: {1}",
150                       buffer_name, std::strerror(errno));
151     return createStringError(inconvertibleErrorCode(), err_msg);
152   }
153   return resource_handle::MmapUP(mmap_result, length);
154 }
155 
156 llvm::Error PerfEvent::MmapMetadataAndDataBuffer(size_t num_data_pages) {
157   size_t mmap_size = (num_data_pages + 1) * getpagesize();
158   if (Expected<resource_handle::MmapUP> mmap_metadata_data =
159           DoMmap(nullptr, mmap_size, PROT_WRITE, MAP_SHARED, 0,
160                  "metadata and data buffer")) {
161     m_metadata_data_base = std::move(mmap_metadata_data.get());
162     return Error::success();
163   } else
164     return mmap_metadata_data.takeError();
165 }
166 
167 llvm::Error PerfEvent::MmapAuxBuffer(size_t num_aux_pages) {
168   if (num_aux_pages == 0)
169     return Error::success();
170 
171   perf_event_mmap_page &metadata_page = GetMetadataPage();
172   metadata_page.aux_offset =
173       metadata_page.data_offset + metadata_page.data_size;
174   metadata_page.aux_size = num_aux_pages * getpagesize();
175 
176   if (Expected<resource_handle::MmapUP> mmap_aux =
177           DoMmap(nullptr, metadata_page.aux_size, PROT_READ, MAP_SHARED,
178                  metadata_page.aux_offset, "aux buffer")) {
179     m_aux_base = std::move(mmap_aux.get());
180     return Error::success();
181   } else
182     return mmap_aux.takeError();
183 }
184 
185 llvm::Error PerfEvent::MmapMetadataAndBuffers(size_t num_data_pages,
186                                               size_t num_aux_pages) {
187   if (num_data_pages != 0 && !isPowerOf2_64(num_data_pages))
188     return llvm::createStringError(
189         llvm::inconvertibleErrorCode(),
190         llvm::formatv("Number of data pages must be a power of 2, got: {0}",
191                       num_data_pages));
192   if (num_aux_pages != 0 && !isPowerOf2_64(num_aux_pages))
193     return llvm::createStringError(
194         llvm::inconvertibleErrorCode(),
195         llvm::formatv("Number of aux pages must be a power of 2, got: {0}",
196                       num_aux_pages));
197   if (Error err = MmapMetadataAndDataBuffer(num_data_pages))
198     return err;
199   if (Error err = MmapAuxBuffer(num_aux_pages))
200     return err;
201   return Error::success();
202 }
203 
204 long PerfEvent::GetFd() const { return *(m_fd.get()); }
205 
206 perf_event_mmap_page &PerfEvent::GetMetadataPage() const {
207   return *reinterpret_cast<perf_event_mmap_page *>(m_metadata_data_base.get());
208 }
209 
210 ArrayRef<uint8_t> PerfEvent::GetDataBuffer() const {
211   perf_event_mmap_page &mmap_metadata = GetMetadataPage();
212   return {reinterpret_cast<uint8_t *>(m_metadata_data_base.get()) +
213               mmap_metadata.data_offset,
214            static_cast<size_t>(mmap_metadata.data_size)};
215 }
216 
217 ArrayRef<uint8_t> PerfEvent::GetAuxBuffer() const {
218   perf_event_mmap_page &mmap_metadata = GetMetadataPage();
219   return {reinterpret_cast<uint8_t *>(m_aux_base.get()),
220            static_cast<size_t>(mmap_metadata.aux_size)};
221 }
222