• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "perf_event.h"
29  
30  struct PerfCounter {
31    uint64_t value;         // The value of the event specified by the perf_event_file.
32    uint64_t time_enabled;  // The enabled time.
33    uint64_t time_running;  // The running time.
34    uint64_t id;            // The id of the perf_event_file.
35  };
36  
37  struct pollfd;
38  
39  // EventFd represents an opened perf_event_file.
40  class EventFd {
41   public:
42    static std::unique_ptr<EventFd> OpenEventFile(const perf_event_attr& attr, pid_t tid, int cpu,
43                                                  bool report_error = true);
44  
45    ~EventFd();
46  
47    uint64_t Id() const;
48  
ThreadId()49    pid_t ThreadId() const {
50      return tid_;
51    }
52  
Cpu()53    int Cpu() const {
54      return cpu_;
55    }
56  
57    bool ReadCounter(PerfCounter* counter) const;
58  
59    // Call mmap() for this perf_event_file, so we can read sampled records from mapped area.
60    // mmap_pages should be power of 2.
61    bool MmapContent(size_t mmap_pages);
62  
63    // When the kernel writes new sampled records to the mapped area, we can get them by returning
64    // the start address and size of the data.
65    size_t GetAvailableMmapData(char** pdata);
66  
67    // Prepare pollfd for poll() to wait on available mmap_data.
68    void PreparePollForMmapData(pollfd* poll_fd);
69  
70   private:
EventFd(int perf_event_fd,const std::string & event_name,pid_t tid,int cpu)71    EventFd(int perf_event_fd, const std::string& event_name, pid_t tid, int cpu)
72        : perf_event_fd_(perf_event_fd),
73          id_(0),
74          event_name_(event_name),
75          tid_(tid),
76          cpu_(cpu),
77          mmap_addr_(nullptr),
78          mmap_len_(0) {
79    }
80  
81    // Give information about this perf_event_file, like (event_name, tid, cpu).
82    std::string Name() const;
83  
84    // Discard how much data we have read, so the kernel can reuse this part of mapped area to store
85    // new data.
86    void DiscardMmapData(size_t discard_size);
87  
88    int perf_event_fd_;
89    mutable uint64_t id_;
90    const std::string event_name_;
91    pid_t tid_;
92    int cpu_;
93  
94    void* mmap_addr_;
95    size_t mmap_len_;
96    perf_event_mmap_page* mmap_metadata_page_;  // The first page of mmap_area.
97    char* mmap_data_buffer_;  // Starts from the second page of mmap_area, containing records written
98                              // by then kernel.
99    size_t mmap_data_buffer_size_;
100  
101    // As mmap_data_buffer is a ring buffer, it is possible that one record is wrapped at the
102    // end of the buffer. So we need to copy records from mmap_data_buffer to data_process_buffer
103    // before processing them.
104    static std::vector<char> data_process_buffer_;
105  
106    DISALLOW_COPY_AND_ASSIGN(EventFd);
107  };
108  
109  bool IsEventAttrSupportedByKernel(perf_event_attr attr);
110  
111  #endif  // SIMPLE_PERF_EVENT_FD_H_
112