1 /*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 #define ATRACE_TAG ATRACE_TAG_ALWAYS
17 #include "event_fd.h"
18
19 #include <fcntl.h>
20 #include <stdio.h>
21 #include <string.h>
22 #include <sys/ioctl.h>
23 #include <sys/mman.h>
24 #include <sys/syscall.h>
25 #include <sys/types.h>
26 #include <atomic>
27 #include <memory>
28 #include <cutils/trace.h>
29 #include <utils/Trace.h>
30
31 #include <android-base/file.h>
32 #include <android-base/logging.h>
33 #include <android-base/stringprintf.h>
34
35 #include "environment.h"
36 #include "event_attr.h"
37 #include "event_type.h"
38 #include "perf_event.h"
39 #include "utils.h"
40
perf_event_open(const perf_event_attr & attr,pid_t pid,int cpu,int group_fd,unsigned long flags)41 static int perf_event_open(const perf_event_attr& attr, pid_t pid, int cpu,
42 int group_fd, unsigned long flags) { // NOLINT
43 return syscall(__NR_perf_event_open, &attr, pid, cpu, group_fd, flags);
44 }
45
OpenEventFile(const perf_event_attr & attr,pid_t tid,int cpu,EventFd * group_event_fd,bool report_error)46 std::unique_ptr<EventFd> EventFd::OpenEventFile(const perf_event_attr& attr,
47 pid_t tid, int cpu,
48 EventFd* group_event_fd,
49 bool report_error) {
50 std::string event_name = GetEventNameByAttr(attr);
51 int group_fd = -1;
52 if (group_event_fd != nullptr) {
53 group_fd = group_event_fd->perf_event_fd_;
54 }
55 perf_event_attr real_attr = attr;
56 if (attr.freq) {
57 uint64_t max_sample_freq;
58 if (GetMaxSampleFrequency(&max_sample_freq) && max_sample_freq < attr.sample_freq) {
59 static bool warned = false;
60 if (!warned) {
61 warned = true;
62 LOG(INFO) << "Adjust sample freq to max allowed sample freq " << max_sample_freq;
63 }
64 real_attr.sample_freq = max_sample_freq;
65 }
66 }
67 int perf_event_fd = perf_event_open(real_attr, tid, cpu, group_fd, 0);
68 if (perf_event_fd == -1) {
69 if (report_error) {
70 PLOG(ERROR) << "open perf_event_file (event " << event_name << ", tid "
71 << tid << ", cpu " << cpu << ", group_fd " << group_fd
72 << ") failed";
73 } else {
74 PLOG(DEBUG) << "open perf_event_file (event " << event_name << ", tid "
75 << tid << ", cpu " << cpu << ", group_fd " << group_fd
76 << ") failed";
77 }
78 return nullptr;
79 }
80 if (fcntl(perf_event_fd, F_SETFD, FD_CLOEXEC) == -1) {
81 if (report_error) {
82 PLOG(ERROR) << "fcntl(FD_CLOEXEC) for perf_event_file (event "
83 << event_name << ", tid " << tid << ", cpu " << cpu
84 << ", group_fd " << group_fd << ") failed";
85 } else {
86 PLOG(DEBUG) << "fcntl(FD_CLOEXEC) for perf_event_file (event "
87 << event_name << ", tid " << tid << ", cpu " << cpu
88 << ", group_fd " << group_fd << ") failed";
89 }
90 return nullptr;
91 }
92 return std::unique_ptr<EventFd>(
93 new EventFd(real_attr, perf_event_fd, event_name, tid, cpu));
94 }
95
~EventFd()96 EventFd::~EventFd() {
97 DestroyMappedBuffer();
98 DestroyAuxBuffer();
99 close(perf_event_fd_);
100 }
101
Name() const102 std::string EventFd::Name() const {
103 return android::base::StringPrintf(
104 "perf_event_file(event %s, tid %d, cpu %d)", event_name_.c_str(), tid_,
105 cpu_);
106 }
107
Id() const108 uint64_t EventFd::Id() const {
109 if (id_ == 0) {
110 PerfCounter counter;
111 if (InnerReadCounter(&counter)) {
112 id_ = counter.id;
113 }
114 }
115 return id_;
116 }
117
SetEnableEvent(bool enable)118 bool EventFd::SetEnableEvent(bool enable) {
119 int result = ioctl(perf_event_fd_, enable ? PERF_EVENT_IOC_ENABLE : PERF_EVENT_IOC_DISABLE, 0);
120 if (result < 0) {
121 PLOG(ERROR) << "ioctl(" << (enable ? "enable" : "disable") << ")" << Name() << " failed";
122 return false;
123 }
124 return true;
125 }
126
SetFilter(const std::string & filter)127 bool EventFd::SetFilter(const std::string& filter) {
128 bool success = ioctl(perf_event_fd_, PERF_EVENT_IOC_SET_FILTER, filter.c_str()) >= 0;
129 if (!success) {
130 PLOG(ERROR) << "failed to set filter";
131 }
132 return success;
133 }
134
InnerReadCounter(PerfCounter * counter) const135 bool EventFd::InnerReadCounter(PerfCounter* counter) const {
136 CHECK(counter != nullptr);
137 if (!android::base::ReadFully(perf_event_fd_, counter, sizeof(*counter))) {
138 PLOG(ERROR) << "ReadCounter from " << Name() << " failed";
139 return false;
140 }
141 return true;
142 }
143
ReadCounter(PerfCounter * counter)144 bool EventFd::ReadCounter(PerfCounter* counter) {
145 if (!InnerReadCounter(counter)) {
146 return false;
147 }
148 // Trace is always available to systrace if enabled
149 if (tid_ > 0) {
150 ATRACE_INT64(android::base::StringPrintf(
151 "%s_tid%d_cpu%d", event_name_.c_str(), tid_,
152 cpu_).c_str(), counter->value - last_counter_value_);
153 } else {
154 ATRACE_INT64(android::base::StringPrintf(
155 "%s_cpu%d", event_name_.c_str(),
156 cpu_).c_str(), counter->value - last_counter_value_);
157 }
158 last_counter_value_ = counter->value;
159 return true;
160 }
161
CreateMappedBuffer(size_t mmap_pages,bool report_error)162 bool EventFd::CreateMappedBuffer(size_t mmap_pages, bool report_error) {
163 CHECK(IsPowerOfTwo(mmap_pages));
164 size_t page_size = sysconf(_SC_PAGE_SIZE);
165 size_t mmap_len = (mmap_pages + 1) * page_size;
166 void* mmap_addr = mmap(nullptr, mmap_len, PROT_READ | PROT_WRITE, MAP_SHARED,
167 perf_event_fd_, 0);
168 if (mmap_addr == MAP_FAILED) {
169 bool is_perm_error = (errno == EPERM);
170 if (report_error) {
171 PLOG(ERROR) << "mmap(" << mmap_pages << ") failed for " << Name();
172 } else {
173 PLOG(DEBUG) << "mmap(" << mmap_pages << ") failed for " << Name();
174 }
175 if (report_error && is_perm_error) {
176 LOG(ERROR)
177 << "It seems the kernel doesn't allow allocating enough "
178 << "buffer for dumping samples, consider decreasing mmap pages(-m).";
179 }
180 return false;
181 }
182 mmap_addr_ = mmap_addr;
183 mmap_len_ = mmap_len;
184 mmap_metadata_page_ = reinterpret_cast<perf_event_mmap_page*>(mmap_addr_);
185 mmap_data_buffer_ = reinterpret_cast<char*>(mmap_addr_) + page_size;
186 mmap_data_buffer_size_ = mmap_len_ - page_size;
187 return true;
188 }
189
ShareMappedBuffer(const EventFd & event_fd,bool report_error)190 bool EventFd::ShareMappedBuffer(const EventFd& event_fd, bool report_error) {
191 CHECK(!HasMappedBuffer());
192 CHECK(event_fd.HasMappedBuffer());
193 int result =
194 ioctl(perf_event_fd_, PERF_EVENT_IOC_SET_OUTPUT, event_fd.perf_event_fd_);
195 if (result != 0) {
196 if (report_error) {
197 PLOG(ERROR) << "failed to share mapped buffer of "
198 << event_fd.perf_event_fd_ << " with " << perf_event_fd_;
199 }
200 return false;
201 }
202 return true;
203 }
204
DestroyMappedBuffer()205 void EventFd::DestroyMappedBuffer() {
206 if (HasMappedBuffer()) {
207 munmap(mmap_addr_, mmap_len_);
208 mmap_addr_ = nullptr;
209 mmap_len_ = 0;
210 mmap_metadata_page_ = nullptr;
211 mmap_data_buffer_ = nullptr;
212 mmap_data_buffer_size_ = 0;
213 }
214 }
215
GetAvailableMmapData()216 std::vector<char> EventFd::GetAvailableMmapData() {
217 size_t data_pos;
218 size_t data_size = GetAvailableMmapDataSize(data_pos);
219 std::vector<char> data(data_size);
220 if (data_size > 0) {
221 size_t copy_size = std::min(data_size, mmap_data_buffer_size_ - data_pos);
222 memcpy(&data[0], mmap_data_buffer_ + data_pos, copy_size);
223 if (copy_size < data_size) {
224 memcpy(&data[copy_size], mmap_data_buffer_, data_size - copy_size);
225 }
226 DiscardMmapData(data_size);
227 }
228 return data;
229 }
230
GetAvailableMmapDataSize(size_t & data_pos)231 size_t EventFd::GetAvailableMmapDataSize(size_t& data_pos) {
232 // The mmap_data_buffer is used as a ring buffer between the kernel and
233 // simpleperf. The kernel continuously writes records to the buffer, and
234 // simpleperf continuously read records out.
235 // _________________________________________
236 // buffer | can write | can read | can write |
237 // ^ ^
238 // read_head write_head
239 //
240 // So simpleperf can read records in [read_head, write_head), and the kernel
241 // can write records in [write_head, read_head). The kernel is responsible
242 // for updating write_head, and simpleperf is responsible for updating
243 // read_head.
244
245 uint64_t write_head = mmap_metadata_page_->data_head;
246 uint64_t read_head = mmap_metadata_page_->data_tail;
247 // The kernel may decrease data_head temporarily (http://b/132446871), making
248 // write_head < read_head. So check it to avoid available data size underflow.
249 if (write_head <= read_head) {
250 // No available data.
251 return 0;
252 }
253 // rmb() used to ensure reading data after reading data_head.
254 __sync_synchronize();
255 data_pos = read_head & (mmap_data_buffer_size_ - 1);
256 return write_head - read_head;
257 }
258
DiscardMmapData(size_t discard_size)259 void EventFd::DiscardMmapData(size_t discard_size) {
260 // mb() used to ensure finish reading data before writing data_tail.
261 __sync_synchronize();
262 mmap_metadata_page_->data_tail += discard_size;
263 }
264
CreateAuxBuffer(size_t aux_buffer_size,bool report_error)265 bool EventFd::CreateAuxBuffer(size_t aux_buffer_size, bool report_error) {
266 CHECK(HasMappedBuffer());
267 CHECK(IsPowerOfTwo(aux_buffer_size));
268 mmap_metadata_page_->aux_offset = mmap_len_;
269 mmap_metadata_page_->aux_size = aux_buffer_size;
270 mmap_metadata_page_->aux_head = 0;
271 mmap_metadata_page_->aux_tail = 0;
272 void* mmap_addr = mmap(nullptr, aux_buffer_size, PROT_READ | PROT_WRITE, MAP_SHARED,
273 perf_event_fd_, mmap_metadata_page_->aux_offset);
274 if (mmap_addr == MAP_FAILED) {
275 if (report_error) {
276 PLOG(ERROR) << "failed to mmap aux buffer of size " << aux_buffer_size << " for " << Name();
277 } else {
278 PLOG(DEBUG) << "failed to mmap aux buffer of size " << aux_buffer_size << " for " << Name();
279 }
280 return false;
281 }
282 aux_buffer_ = static_cast<char*>(mmap_addr);
283 aux_buffer_size_ = aux_buffer_size;
284 return true;
285 }
286
DestroyAuxBuffer()287 void EventFd::DestroyAuxBuffer() {
288 if (HasAuxBuffer()) {
289 munmap(aux_buffer_, aux_buffer_size_);
290 aux_buffer_ = nullptr;
291 aux_buffer_size_ = 0;
292 }
293 }
294
GetAvailableAuxData(char ** buf1,size_t * size1,char ** buf2,size_t * size2)295 uint64_t EventFd::GetAvailableAuxData(char** buf1, size_t* size1, char** buf2, size_t* size2) {
296 // Aux buffer is similar to mapped_data_buffer. See comments in GetAvailableMmapData().
297 uint64_t write_head = mmap_metadata_page_->aux_head;
298 uint64_t read_head = mmap_metadata_page_->aux_tail;
299 if (write_head <= read_head) {
300 *size1 = *size2 = 0;
301 return 0; // No available data.
302 }
303 // rmb() used to ensure reading data after reading aux_head.
304 __sync_synchronize();
305 size_t data_pos = read_head & (aux_buffer_size_ - 1);
306 size_t data_size = write_head - read_head;
307 *buf1 = aux_buffer_ + data_pos;
308 if (data_size <= aux_buffer_size_ - data_pos) {
309 *size1 = data_size;
310 *size2 = 0;
311 } else {
312 *size1 = aux_buffer_size_ - data_pos;
313 *buf2 = aux_buffer_;
314 *size2 = data_size - *size1;
315 }
316 return read_head;
317 }
318
DiscardAuxData(size_t discard_size)319 void EventFd::DiscardAuxData(size_t discard_size) {
320 // mb() used to ensure finish reading data before writing aux_tail.
321 __sync_synchronize();
322 mmap_metadata_page_->aux_tail += discard_size;
323 }
324
StartPolling(IOEventLoop & loop,const std::function<bool ()> & callback)325 bool EventFd::StartPolling(IOEventLoop& loop,
326 const std::function<bool()>& callback) {
327 ioevent_ref_ = loop.AddReadEvent(perf_event_fd_, callback);
328 return ioevent_ref_ != nullptr;
329 }
330
StopPolling()331 bool EventFd::StopPolling() { return IOEventLoop::DelEvent(ioevent_ref_); }
332
IsEventAttrSupported(const perf_event_attr & attr)333 bool IsEventAttrSupported(const perf_event_attr& attr) {
334 if (attr.type == SIMPLEPERF_TYPE_USER_SPACE_SAMPLERS &&
335 attr.config == SIMPLEPERF_CONFIG_INPLACE_SAMPLER) {
336 // User space samplers don't need kernel support.
337 return true;
338 }
339 std::unique_ptr<EventFd> event_fd = EventFd::OpenEventFile(attr, getpid(), -1, nullptr, false);
340 return event_fd != nullptr;
341 }
342