| /* |
| * Copyright (C) 2015 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef SIMPLE_PERF_RECORD_FILE_H_ |
| #define SIMPLE_PERF_RECORD_FILE_H_ |
| |
| #include <stdio.h> |
| |
| #include <functional> |
| #include <map> |
| #include <memory> |
| #include <string> |
| #include <unordered_map> |
| #include <vector> |
| |
| #include <android-base/macros.h> |
| |
| #include "dso.h" |
| #include "event_attr.h" |
| #include "perf_event.h" |
| #include "record.h" |
| #include "record_file_format.h" |
| #include "thread_tree.h" |
| |
| // RecordFileWriter writes to a perf record file, like perf.data. |
| // User should call RecordFileWriter::Close() to finish writing the file, otherwise the file will |
| // be removed in RecordFileWriter::~RecordFileWriter(). |
| class RecordFileWriter { |
| public: |
| static std::unique_ptr<RecordFileWriter> CreateInstance(const std::string& filename); |
| |
| ~RecordFileWriter(); |
| |
| bool WriteAttrSection(const std::vector<EventAttrWithId>& attr_ids); |
| bool WriteRecord(const Record& record); |
| |
| uint64_t GetDataSectionSize() const { return data_section_size_; } |
| bool ReadDataSection(const std::function<void(const Record*)>& callback); |
| |
| bool BeginWriteFeatures(size_t feature_count); |
| bool WriteBuildIdFeature(const std::vector<BuildIdRecord>& build_id_records); |
| bool WriteFeatureString(int feature, const std::string& s); |
| bool WriteCmdlineFeature(const std::vector<std::string>& cmdline); |
| bool WriteBranchStackFeature(); |
| bool WriteFileFeatures(const std::vector<Dso*>& files); |
| bool WriteMetaInfoFeature(const std::unordered_map<std::string, std::string>& info_map); |
| bool WriteFeature(int feature, const std::vector<char>& data); |
| bool EndWriteFeatures(); |
| |
| bool Close(); |
| |
| private: |
| RecordFileWriter(const std::string& filename, FILE* fp); |
| void GetHitModulesInBuffer(const char* p, const char* end, |
| std::vector<std::string>* hit_kernel_modules, |
| std::vector<std::string>* hit_user_files); |
| bool WriteFileHeader(); |
| bool WriteData(const void* buf, size_t len); |
| bool Write(const void* buf, size_t len); |
| bool Read(void* buf, size_t len); |
| bool GetFilePos(uint64_t* file_pos); |
| bool WriteStringWithLength(const std::string& s); |
| bool WriteFileFeature(const std::string& file_path, |
| uint32_t file_type, |
| uint64_t min_vaddr, |
| uint64_t file_offset_of_min_vaddr, |
| const std::vector<const Symbol*>& symbols, |
| const std::vector<uint64_t>* dex_file_offsets); |
| bool WriteFeatureBegin(int feature); |
| bool WriteFeatureEnd(int feature); |
| |
| const std::string filename_; |
| FILE* record_fp_; |
| |
| perf_event_attr event_attr_; |
| uint64_t attr_section_offset_; |
| uint64_t attr_section_size_; |
| uint64_t data_section_offset_; |
| uint64_t data_section_size_; |
| uint64_t feature_section_offset_; |
| |
| std::map<int, PerfFileFormat::SectionDesc> features_; |
| size_t feature_count_; |
| |
| DISALLOW_COPY_AND_ASSIGN(RecordFileWriter); |
| }; |
| |
| // RecordFileReader read contents from a perf record file, like perf.data. |
| class RecordFileReader { |
| public: |
| static std::unique_ptr<RecordFileReader> CreateInstance(const std::string& filename); |
| |
| ~RecordFileReader(); |
| |
| const PerfFileFormat::FileHeader& FileHeader() const { |
| return header_; |
| } |
| |
| std::vector<EventAttrWithId> AttrSection() const { |
| std::vector<EventAttrWithId> result(file_attrs_.size()); |
| for (size_t i = 0; i < file_attrs_.size(); ++i) { |
| result[i].attr = &file_attrs_[i].attr; |
| result[i].ids = event_ids_for_file_attrs_[i]; |
| } |
| return result; |
| } |
| |
| const std::map<int, PerfFileFormat::SectionDesc>& FeatureSectionDescriptors() const { |
| return feature_section_descriptors_; |
| } |
| bool HasFeature(int feature) const { |
| return feature_section_descriptors_.find(feature) != feature_section_descriptors_.end(); |
| } |
| bool ReadFeatureSection(int feature, std::vector<char>* data); |
| |
| // There are two ways to read records in data section: one is by calling |
| // ReadDataSection(), and [callback] is called for each Record. the other |
| // is by calling ReadRecord() in a loop. |
| |
| // If sorted is true, sort records before passing them to callback function. |
| bool ReadDataSection(const std::function<bool(std::unique_ptr<Record>)>& callback); |
| |
| // Read next record. If read successfully, set [record] and return true. |
| // If there is no more records, set [record] to nullptr and return true. |
| // Otherwise return false. |
| bool ReadRecord(std::unique_ptr<Record>& record); |
| |
| size_t GetAttrIndexOfRecord(const Record* record); |
| |
| std::vector<std::string> ReadCmdlineFeature(); |
| std::vector<BuildIdRecord> ReadBuildIdFeature(); |
| std::string ReadFeatureString(int feature); |
| |
| // File feature section contains many file information. This function reads |
| // one file information located at [read_pos]. [read_pos] is 0 at the first |
| // call, and is updated to point to the next file information. Return true |
| // if read successfully, and return false if there is no more file |
| // information. |
| bool ReadFileFeature(size_t& read_pos, std::string* file_path, uint32_t* file_type, |
| uint64_t* min_vaddr, uint64_t* file_offset_of_min_vaddr, |
| std::vector<Symbol>* symbols, std::vector<uint64_t>* dex_file_offsets); |
| bool ReadMetaInfoFeature(std::unordered_map<std::string, std::string>* info_map); |
| |
| void LoadBuildIdAndFileFeatures(ThreadTree& thread_tree); |
| |
| bool Close(); |
| |
| // For testing only. |
| std::vector<std::unique_ptr<Record>> DataSection(); |
| |
| private: |
| RecordFileReader(const std::string& filename, FILE* fp); |
| bool ReadHeader(); |
| bool ReadAttrSection(); |
| bool ReadIdsForAttr(const PerfFileFormat::FileAttr& attr, std::vector<uint64_t>* ids); |
| bool ReadFeatureSectionDescriptors(); |
| std::unique_ptr<Record> ReadRecord(uint64_t* nbytes_read); |
| bool Read(void* buf, size_t len); |
| void ProcessEventIdRecord(const EventIdRecord& r); |
| |
| const std::string filename_; |
| FILE* record_fp_; |
| |
| PerfFileFormat::FileHeader header_; |
| std::vector<PerfFileFormat::FileAttr> file_attrs_; |
| std::vector<std::vector<uint64_t>> event_ids_for_file_attrs_; |
| std::unordered_map<uint64_t, size_t> event_id_to_attr_map_; |
| std::map<int, PerfFileFormat::SectionDesc> feature_section_descriptors_; |
| |
| size_t event_id_pos_in_sample_records_; |
| size_t event_id_reverse_pos_in_non_sample_records_; |
| |
| uint64_t read_record_size_; |
| |
| DISALLOW_COPY_AND_ASSIGN(RecordFileReader); |
| }; |
| |
| #endif // SIMPLE_PERF_RECORD_FILE_H_ |