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