Home | History | Annotate | Download | only in simpleperf 
      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 
     49   pid_t ThreadId() const {
     50     return tid_;
     51   }
     52 
     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:
     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