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_ 191
