simpleperf/record_file.h

   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_RECORD_FILE_H_
  18 #define SIMPLE_PERF_RECORD_FILE_H_
  19
  20 #include <stdio.h>
  21
  22 #include <functional>
  23 #include <map>
  24 #include <memory>
  25 #include <string>
  26 #include <unordered_map>
  27 #include <vector>
  28
  29 #include <android-base/macros.h>
  30
  31 #include "dso.h"
  32 #include "event_attr.h"
  33 #include "perf_event.h"
  34 #include "record.h"
  35 #include "record_file_format.h"
  36 #include "thread_tree.h"
  37
  38 // RecordFileWriter writes to a perf record file, like perf.data.
  39 // User should call RecordFileWriter::Close() to finish writing the file, otherwise the file will
  40 // be removed in RecordFileWriter::~RecordFileWriter().
  41 class RecordFileWriter {
  42  public:
  43   static std::unique_ptr<RecordFileWriter> CreateInstance(const std::string& filename);
  44
  45   ~RecordFileWriter();
  46
  47   bool WriteAttrSection(const std::vector<EventAttrWithId>& attr_ids);
  48   bool WriteRecord(const Record& record);
  49
  50   bool ReadDataSection(const std::function<void(const Record*)>& callback);
  51
  52   bool BeginWriteFeatures(size_t feature_count);
  53   bool WriteBuildIdFeature(const std::vector<BuildIdRecord>& build_id_records);
  54   bool WriteFeatureString(int feature, const std::string& s);
  55   bool WriteCmdlineFeature(const std::vector<std::string>& cmdline);
  56   bool WriteBranchStackFeature();
  57   bool WriteFileFeatures(const std::vector<Dso*>& files);
  58   bool WriteFileFeature(const std::string& file_path,
  59                         uint32_t file_type,
  60                         uint64_t min_vaddr,
  61                         const std::vector<const Symbol*>& symbols);
  62   bool WriteMetaInfoFeature(const std::unordered_map<std::string, std::string>& info_map);
  63   bool WriteFeature(int feature, const std::vector<char>& data);
  64   bool EndWriteFeatures();
  65
  66   bool Close();
  67
  68  private:
  69   RecordFileWriter(const std::string& filename, FILE* fp);
  70   void GetHitModulesInBuffer(const char* p, const char* end,
  71                              std::vector<std::string>* hit_kernel_modules,
  72                              std::vector<std::string>* hit_user_files);
  73   bool WriteFileHeader();
  74   bool WriteData(const void* buf, size_t len);
  75   bool Write(const void* buf, size_t len);
  76   bool Read(void* buf, size_t len);
  77   bool GetFilePos(uint64_t* file_pos);
  78   bool WriteStringWithLength(const std::string& s);
  79   bool WriteFeatureBegin(int feature);
  80   bool WriteFeatureEnd(int feature);
  81
  82   const std::string filename_;
  83   FILE* record_fp_;
  84
  85   perf_event_attr event_attr_;
  86   uint64_t attr_section_offset_;
  87   uint64_t attr_section_size_;
  88   uint64_t data_section_offset_;
  89   uint64_t data_section_size_;
  90   uint64_t feature_section_offset_;
  91
  92   std::map<int, PerfFileFormat::SectionDesc> features_;
  93   size_t feature_count_;
  94
  95   DISALLOW_COPY_AND_ASSIGN(RecordFileWriter);
  96 };
  97
  98 // RecordFileReader read contents from a perf record file, like perf.data.
  99 class RecordFileReader {
 100  public:
 101   static std::unique_ptr<RecordFileReader> CreateInstance(const std::string& filename);
 102
 103   ~RecordFileReader();
 104
 105   const PerfFileFormat::FileHeader& FileHeader() const {
 106     return header_;
 107   }
 108
 109   std::vector<EventAttrWithId> AttrSection() const {
 110     std::vector<EventAttrWithId> result(file_attrs_.size());
 111     for (size_t i = 0; i < file_attrs_.size(); ++i) {
 112       result[i].attr = &file_attrs_[i].attr;
 113       result[i].ids = event_ids_for_file_attrs_[i];
 114     }
 115     return result;
 116   }
 117
 118   const std::map<int, PerfFileFormat::SectionDesc>& FeatureSectionDescriptors() const {
 119     return feature_section_descriptors_;
 120   }
 121   bool HasFeature(int feature) const {
 122     return feature_section_descriptors_.find(feature) != feature_section_descriptors_.end();
 123   }
 124   bool ReadFeatureSection(int feature, std::vector<char>* data);
 125
 126   // There are two ways to read records in data section: one is by calling
 127   // ReadDataSection(), and [callback] is called for each Record. the other
 128   // is by calling ReadRecord() in a loop.
 129
 130   // If sorted is true, sort records before passing them to callback function.
 131   bool ReadDataSection(const std::function<bool(std::unique_ptr<Record>)>& callback,
 132                        bool sorted = true);
 133
 134   // Read next record. If read successfully, set [record] and return true.
 135   // If there is no more records, set [record] to nullptr and return true.
 136   // Otherwise return false.
 137   bool ReadRecord(std::unique_ptr<Record>& record, bool sorted = true);
 138
 139   size_t GetAttrIndexOfRecord(const Record* record);
 140
 141   std::vector<std::string> ReadCmdlineFeature();
 142   std::vector<BuildIdRecord> ReadBuildIdFeature();
 143   std::string ReadFeatureString(int feature);
 144
 145   // File feature section contains many file information. This function reads
 146   // one file information located at [read_pos]. [read_pos] is 0 at the first
 147   // call, and is updated to point to the next file information. Return true
 148   // if read successfully, and return false if there is no more file
 149   // information.
 150   bool ReadFileFeature(size_t& read_pos, std::string* file_path,
 151                        uint32_t* file_type, uint64_t* min_vaddr,
 152                        std::vector<Symbol>* symbols);
 153   bool ReadMetaInfoFeature(std::unordered_map<std::string, std::string>* info_map);
 154
 155   void LoadBuildIdAndFileFeatures(ThreadTree& thread_tree);
 156
 157   bool Close();
 158
 159   // For testing only.
 160   std::vector<std::unique_ptr<Record>> DataSection();
 161
 162  private:
 163   RecordFileReader(const std::string& filename, FILE* fp);
 164   bool ReadHeader();
 165   bool ReadAttrSection();
 166   bool ReadIdsForAttr(const PerfFileFormat::FileAttr& attr, std::vector<uint64_t>* ids);
 167   bool ReadFeatureSectionDescriptors();
 168   std::unique_ptr<Record> ReadRecord(uint64_t* nbytes_read);
 169   bool Read(void* buf, size_t len);
 170   void ProcessEventIdRecord(const EventIdRecord& r);
 171
 172   const std::string filename_;
 173   FILE* record_fp_;
 174
 175   PerfFileFormat::FileHeader header_;
 176   std::vector<PerfFileFormat::FileAttr> file_attrs_;
 177   std::vector<std::vector<uint64_t>> event_ids_for_file_attrs_;
 178   std::unordered_map<uint64_t, size_t> event_id_to_attr_map_;
 179   std::map<int, PerfFileFormat::SectionDesc> feature_section_descriptors_;
 180
 181   size_t event_id_pos_in_sample_records_;
 182   size_t event_id_reverse_pos_in_non_sample_records_;
 183
 184   std::unique_ptr<RecordCache> record_cache_;
 185   uint64_t read_record_size_;
 186
 187   DISALLOW_COPY_AND_ASSIGN(RecordFileReader);
 188 };
 189
 190 #endif  // SIMPLE_PERF_RECORD_FILE_H_