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