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 
17 #ifndef SIMPLE_PERF_EVENT_FD_H_
18 #define SIMPLE_PERF_EVENT_FD_H_
19 
20 #include <sys/types.h>
21 
22 #include <memory>
23 #include <string>
24 #include <vector>
25 
26 #include <android-base/macros.h>
27 
28 #include "IOEventLoop.h"
29 #include "perf_event.h"
30 
31 struct PerfCounter {
32   uint64_t value;  // The value of the event specified by the perf_event_file.
33   uint64_t time_enabled;  // The enabled time.
34   uint64_t time_running;  // The running time.
35   uint64_t id;            // The id of the perf_event_file.
36 };
37 
38 // EventFd represents an opened perf_event_file.
39 class EventFd {
40  public:
41   static std::unique_ptr<EventFd> OpenEventFile(const perf_event_attr& attr,
42                                                 pid_t tid, int cpu,
43                                                 EventFd* group_event_fd,
44                                                 bool report_error = true);
45 
46   ~EventFd();
47 
48   // Give information about this perf_event_file, like (event_name, tid, cpu).
49   std::string Name() const;
50 
51   uint64_t Id() const;
52 
ThreadId()53   pid_t ThreadId() const { return tid_; }
54 
Cpu()55   int Cpu() const { return cpu_; }
56 
attr()57   const perf_event_attr& attr() const { return attr_; }
58 
59   // It tells the kernel to start counting and recording events specified by
60   // this file.
61   bool EnableEvent();
62 
63   bool ReadCounter(PerfCounter* counter) const;
64 
65   // Create mapped buffer used to receive records sent by the kernel.
66   // mmap_pages should be power of 2.
67   bool CreateMappedBuffer(size_t mmap_pages, bool report_error);
68 
69   // Share the mapped buffer used by event_fd. The two EventFds should monitor
70   // the same event on the same cpu, but have different thread ids.
71   bool ShareMappedBuffer(const EventFd& event_fd, bool report_error);
72 
HasMappedBuffer()73   bool HasMappedBuffer() const { return mmap_data_buffer_size_ != 0; }
74 
75   void DestroyMappedBuffer();
76 
77   // When the kernel writes new sampled records to the mapped area, we can get
78   // them by returning the start address and size of the data.
79   size_t GetAvailableMmapData(std::vector<char>& buffer, size_t& buffer_pos);
80 
81   // [callback] is called when there is data available in the mapped buffer.
82   bool StartPolling(IOEventLoop& loop, const std::function<bool()>& callback);
83   bool StopPolling();
84 
85  private:
EventFd(const perf_event_attr & attr,int perf_event_fd,const std::string & event_name,pid_t tid,int cpu)86   EventFd(const perf_event_attr& attr, int perf_event_fd,
87           const std::string& event_name, pid_t tid, int cpu)
88       : attr_(attr),
89         perf_event_fd_(perf_event_fd),
90         id_(0),
91         event_name_(event_name),
92         tid_(tid),
93         cpu_(cpu),
94         mmap_addr_(nullptr),
95         mmap_len_(0),
96         mmap_metadata_page_(nullptr),
97         mmap_data_buffer_(nullptr),
98         mmap_data_buffer_size_(0),
99         ioevent_ref_(nullptr) {}
100 
101   // Discard how much data we have read, so the kernel can reuse this part of
102   // mapped area to store new data.
103   void DiscardMmapData(size_t discard_size);
104 
105   const perf_event_attr attr_;
106   int perf_event_fd_;
107   mutable uint64_t id_;
108   const std::string event_name_;
109   pid_t tid_;
110   int cpu_;
111 
112   void* mmap_addr_;
113   size_t mmap_len_;
114   perf_event_mmap_page* mmap_metadata_page_;  // The first page of mmap_area.
115   char* mmap_data_buffer_;  // Starting from the second page of mmap_area,
116                             // containing records written by then kernel.
117   size_t mmap_data_buffer_size_;
118 
119   // As mmap_data_buffer is a ring buffer, it is possible that one record is
120   // wrapped at the end of the buffer. So we need to copy records from
121   // mmap_data_buffer to data_process_buffer before processing them.
122   static std::vector<char> data_process_buffer_;
123 
124   IOEventRef ioevent_ref_;
125 
126   DISALLOW_COPY_AND_ASSIGN(EventFd);
127 };
128 
129 bool IsEventAttrSupported(const perf_event_attr& attr);
130 
131 #endif  // SIMPLE_PERF_EVENT_FD_H_
132