| /* |
| * Copyright (C) 2016 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. |
| */ |
| |
| #include <inttypes.h> |
| |
| #include <memory> |
| |
| #include <android-base/strings.h> |
| |
| #include "system/extras/simpleperf/report_sample.pb.h" |
| |
| #include <google/protobuf/io/coded_stream.h> |
| #include <google/protobuf/io/zero_copy_stream_impl_lite.h> |
| |
| #include "command.h" |
| #include "event_attr.h" |
| #include "event_type.h" |
| #include "record_file.h" |
| #include "thread_tree.h" |
| #include "utils.h" |
| |
| namespace proto = simpleperf_report_proto; |
| |
| namespace { |
| |
| static const char PROT_FILE_MAGIC[] = "SIMPLEPERF"; |
| static const uint16_t PROT_FILE_VERSION = 1u; |
| |
| class ProtobufFileWriter : public google::protobuf::io::CopyingOutputStream { |
| public: |
| explicit ProtobufFileWriter(FILE* out_fp) : out_fp_(out_fp) {} |
| |
| bool Write(const void* buffer, int size) override { |
| return fwrite(buffer, size, 1, out_fp_) == 1; |
| } |
| |
| private: |
| FILE* out_fp_; |
| }; |
| |
| class ProtobufFileReader : public google::protobuf::io::CopyingInputStream { |
| public: |
| explicit ProtobufFileReader(FILE* in_fp) : in_fp_(in_fp) {} |
| |
| int Read(void* buffer, int size) override { |
| return fread(buffer, 1, size, in_fp_); |
| } |
| |
| private: |
| FILE* in_fp_; |
| }; |
| |
| struct CallEntry { |
| Dso* dso; |
| const Symbol* symbol; |
| uint64_t vaddr_in_file; |
| }; |
| |
| class ReportSampleCommand : public Command { |
| public: |
| ReportSampleCommand() |
| : Command( |
| "report-sample", "report raw sample information in perf.data", |
| // clang-format off |
| "Usage: simpleperf report-sample [options]\n" |
| "--dump-protobuf-report <file>\n" |
| " Dump report file generated by\n" |
| " `simpleperf report-sample --protobuf -o <file>`.\n" |
| "-i <file> Specify path of record file, default is perf.data.\n" |
| "-o report_file_name Set report file name. Default report file name is\n" |
| " report_sample.trace if --protobuf is used, otherwise\n" |
| " the report is written to stdout.\n" |
| "--protobuf Use protobuf format in report_sample.proto to output samples.\n" |
| " Need to set a report_file_name when using this option.\n" |
| "--show-callchain Print callchain samples.\n" |
| "--remove-unknown-kernel-symbols Remove kernel callchains when kernel symbols\n" |
| " are not available in perf.data.\n" |
| "--show-art-frames Show frames of internal methods in the ART Java interpreter.\n" |
| "--symdir <dir> Look for files with symbols in a directory recursively.\n" |
| // clang-format on |
| ), |
| record_filename_("perf.data"), |
| show_callchain_(false), |
| use_protobuf_(false), |
| report_fp_(nullptr), |
| coded_os_(nullptr), |
| sample_count_(0), |
| lost_count_(0), |
| trace_offcpu_(false), |
| remove_unknown_kernel_symbols_(false), |
| kernel_symbols_available_(false), |
| show_art_frames_(false) {} |
| |
| bool Run(const std::vector<std::string>& args) override; |
| |
| private: |
| bool ParseOptions(const std::vector<std::string>& args); |
| bool DumpProtobufReport(const std::string& filename); |
| bool OpenRecordFile(); |
| bool PrintMetaInfo(); |
| bool ProcessRecord(std::unique_ptr<Record> record); |
| bool ProcessSampleRecord(const SampleRecord& r); |
| bool PrintSampleRecordInProtobuf(const SampleRecord& record, |
| const std::vector<CallEntry>& entries); |
| bool GetCallEntry(const ThreadEntry* thread, bool in_kernel, uint64_t ip, bool omit_unknown_dso, |
| CallEntry* entry); |
| bool WriteRecordInProtobuf(proto::Record& proto_record); |
| bool PrintLostSituationInProtobuf(); |
| bool PrintFileInfoInProtobuf(); |
| bool PrintThreadInfoInProtobuf(); |
| bool PrintSampleRecord(const SampleRecord& record, const std::vector<CallEntry>& entries); |
| void PrintLostSituation(); |
| |
| std::string record_filename_; |
| std::unique_ptr<RecordFileReader> record_file_reader_; |
| std::string dump_protobuf_report_file_; |
| bool show_callchain_; |
| bool use_protobuf_; |
| ThreadTree thread_tree_; |
| std::string report_filename_; |
| FILE* report_fp_; |
| google::protobuf::io::CodedOutputStream* coded_os_; |
| size_t sample_count_; |
| size_t lost_count_; |
| bool trace_offcpu_; |
| std::unique_ptr<ScopedEventTypes> scoped_event_types_; |
| std::vector<std::string> event_types_; |
| std::unordered_map<std::string, std::string> meta_info_; |
| bool remove_unknown_kernel_symbols_; |
| bool kernel_symbols_available_; |
| bool show_art_frames_; |
| }; |
| |
| bool ReportSampleCommand::Run(const std::vector<std::string>& args) { |
| // 1. Parse options. |
| if (!ParseOptions(args)) { |
| return false; |
| } |
| // 2. Prepare report fp. |
| report_fp_ = stdout; |
| std::unique_ptr<FILE, decltype(&fclose)> fp(nullptr, fclose); |
| if (!report_filename_.empty()) { |
| const char* open_mode = use_protobuf_ ? "wb" : "w"; |
| fp.reset(fopen(report_filename_.c_str(), open_mode)); |
| if (fp == nullptr) { |
| PLOG(ERROR) << "failed to open " << report_filename_; |
| return false; |
| } |
| report_fp_ = fp.get(); |
| } |
| |
| // 3. Dump protobuf report. |
| if (!dump_protobuf_report_file_.empty()) { |
| return DumpProtobufReport(dump_protobuf_report_file_); |
| } |
| |
| // 4. Open record file. |
| if (!OpenRecordFile()) { |
| return false; |
| } |
| if (use_protobuf_) { |
| GOOGLE_PROTOBUF_VERIFY_VERSION; |
| } else { |
| thread_tree_.ShowMarkForUnknownSymbol(); |
| thread_tree_.ShowIpForUnknownSymbol(); |
| } |
| |
| // 5. Prepare protobuf output stream. |
| std::unique_ptr<ProtobufFileWriter> protobuf_writer; |
| std::unique_ptr<google::protobuf::io::CopyingOutputStreamAdaptor> protobuf_os; |
| std::unique_ptr<google::protobuf::io::CodedOutputStream> protobuf_coded_os; |
| if (use_protobuf_) { |
| if (fprintf(report_fp_, "%s", PROT_FILE_MAGIC) != 10 || |
| fwrite(&PROT_FILE_VERSION, sizeof(uint16_t), 1, report_fp_) != 1u) { |
| PLOG(ERROR) << "Failed to write magic/version"; |
| return false; |
| } |
| protobuf_writer.reset(new ProtobufFileWriter(report_fp_)); |
| protobuf_os.reset(new google::protobuf::io::CopyingOutputStreamAdaptor( |
| protobuf_writer.get())); |
| protobuf_coded_os.reset( |
| new google::protobuf::io::CodedOutputStream(protobuf_os.get())); |
| coded_os_ = protobuf_coded_os.get(); |
| } |
| |
| // 6. Read record file, and print samples online. |
| if (!PrintMetaInfo()) { |
| return false; |
| } |
| if (!record_file_reader_->ReadDataSection( |
| [this](std::unique_ptr<Record> record) { |
| return ProcessRecord(std::move(record)); |
| })) { |
| return false; |
| } |
| |
| if (use_protobuf_) { |
| if (!PrintLostSituationInProtobuf()) { |
| return false; |
| } |
| if (!PrintFileInfoInProtobuf()) { |
| return false; |
| } |
| if (!PrintThreadInfoInProtobuf()) { |
| return false; |
| } |
| coded_os_->WriteLittleEndian32(0); |
| if (coded_os_->HadError()) { |
| LOG(ERROR) << "print protobuf report failed"; |
| return false; |
| } |
| protobuf_coded_os.reset(nullptr); |
| } else { |
| PrintLostSituation(); |
| fflush(report_fp_); |
| } |
| if (ferror(report_fp_) != 0) { |
| PLOG(ERROR) << "print report failed"; |
| return false; |
| } |
| return true; |
| } |
| |
| bool ReportSampleCommand::ParseOptions(const std::vector<std::string>& args) { |
| for (size_t i = 0; i < args.size(); ++i) { |
| if (args[i] == "--dump-protobuf-report") { |
| if (!NextArgumentOrError(args, &i)) { |
| return false; |
| } |
| dump_protobuf_report_file_ = args[i]; |
| } else if (args[i] == "-i") { |
| if (!NextArgumentOrError(args, &i)) { |
| return false; |
| } |
| record_filename_ = args[i]; |
| } else if (args[i] == "-o") { |
| if (!NextArgumentOrError(args, &i)) { |
| return false; |
| } |
| report_filename_ = args[i]; |
| } else if (args[i] == "--protobuf") { |
| use_protobuf_ = true; |
| } else if (args[i] == "--show-callchain") { |
| show_callchain_ = true; |
| } else if (args[i] == "--remove-unknown-kernel-symbols") { |
| remove_unknown_kernel_symbols_ = true; |
| } else if (args[i] == "--show-art-frames") { |
| show_art_frames_ = true; |
| } else if (args[i] == "--symdir") { |
| if (!NextArgumentOrError(args, &i)) { |
| return false; |
| } |
| if (!Dso::AddSymbolDir(args[i])) { |
| return false; |
| } |
| } else { |
| ReportUnknownOption(args, i); |
| return false; |
| } |
| } |
| |
| if (use_protobuf_ && report_filename_.empty()) { |
| report_filename_ = "report_sample.trace"; |
| } |
| return true; |
| } |
| |
| bool ReportSampleCommand::DumpProtobufReport(const std::string& filename) { |
| GOOGLE_PROTOBUF_VERIFY_VERSION; |
| std::unique_ptr<FILE, decltype(&fclose)> fp(fopen(filename.c_str(), "rb"), |
| fclose); |
| if (fp == nullptr) { |
| PLOG(ERROR) << "failed to open " << filename; |
| return false; |
| } |
| char magic[11] = {}; |
| if (fread(magic, 10, 1, fp.get()) != 1u || memcmp(magic, PROT_FILE_MAGIC, 10) != 0) { |
| PLOG(ERROR) << filename << " isn't a file generated by report-sample command."; |
| return false; |
| } |
| FprintIndented(report_fp_, 0, "magic: %s\n", magic); |
| uint16_t version; |
| if (fread(&version, sizeof(uint16_t), 1, fp.get()) != 1u || version != PROT_FILE_VERSION) { |
| PLOG(ERROR) << filename << " doesn't have the expected version."; |
| return false; |
| } |
| FprintIndented(report_fp_, 0, "version: %u\n", version); |
| |
| ProtobufFileReader protobuf_reader(fp.get()); |
| google::protobuf::io::CopyingInputStreamAdaptor adaptor(&protobuf_reader); |
| google::protobuf::io::CodedInputStream coded_is(&adaptor); |
| // map from file_id to max_symbol_id requested on the file. |
| std::unordered_map<uint32_t, int32_t> max_symbol_id_map; |
| // files[file_id] is the number of symbols in the file. |
| std::vector<uint32_t> files; |
| uint32_t max_message_size = 64 * (1 << 20); |
| uint32_t warning_message_size = 512 * (1 << 20); |
| coded_is.SetTotalBytesLimit(max_message_size, warning_message_size); |
| while (true) { |
| uint32_t size; |
| if (!coded_is.ReadLittleEndian32(&size)) { |
| PLOG(ERROR) << "failed to read " << filename; |
| return false; |
| } |
| if (size == 0) { |
| break; |
| } |
| // Handle files having large symbol table. |
| if (size > max_message_size) { |
| max_message_size = size; |
| coded_is.SetTotalBytesLimit(max_message_size, warning_message_size); |
| } |
| auto limit = coded_is.PushLimit(size); |
| proto::Record proto_record; |
| if (!proto_record.ParseFromCodedStream(&coded_is)) { |
| PLOG(ERROR) << "failed to read " << filename; |
| return false; |
| } |
| coded_is.PopLimit(limit); |
| if (proto_record.has_sample()) { |
| auto& sample = proto_record.sample(); |
| static size_t sample_count = 0; |
| FprintIndented(report_fp_, 0, "sample %zu:\n", ++sample_count); |
| FprintIndented(report_fp_, 1, "event_type_id: %zu\n", sample.event_type_id()); |
| FprintIndented(report_fp_, 1, "time: %" PRIu64 "\n", sample.time()); |
| FprintIndented(report_fp_, 1, "event_count: %" PRIu64 "\n", sample.event_count()); |
| FprintIndented(report_fp_, 1, "thread_id: %d\n", sample.thread_id()); |
| FprintIndented(report_fp_, 1, "callchain:\n"); |
| for (int i = 0; i < sample.callchain_size(); ++i) { |
| const proto::Sample_CallChainEntry& callchain = sample.callchain(i); |
| FprintIndented(report_fp_, 2, "vaddr_in_file: %" PRIx64 "\n", |
| callchain.vaddr_in_file()); |
| FprintIndented(report_fp_, 2, "file_id: %u\n", callchain.file_id()); |
| int32_t symbol_id = callchain.symbol_id(); |
| FprintIndented(report_fp_, 2, "symbol_id: %d\n", symbol_id); |
| if (symbol_id < -1) { |
| LOG(ERROR) << "unexpected symbol_id " << symbol_id; |
| return false; |
| } |
| if (symbol_id != -1) { |
| max_symbol_id_map[callchain.file_id()] = |
| std::max(max_symbol_id_map[callchain.file_id()], symbol_id); |
| } |
| } |
| } else if (proto_record.has_lost()) { |
| auto& lost = proto_record.lost(); |
| FprintIndented(report_fp_, 0, "lost_situation:\n"); |
| FprintIndented(report_fp_, 1, "sample_count: %" PRIu64 "\n", |
| lost.sample_count()); |
| FprintIndented(report_fp_, 1, "lost_count: %" PRIu64 "\n", |
| lost.lost_count()); |
| } else if (proto_record.has_file()) { |
| auto& file = proto_record.file(); |
| FprintIndented(report_fp_, 0, "file:\n"); |
| FprintIndented(report_fp_, 1, "id: %u\n", file.id()); |
| FprintIndented(report_fp_, 1, "path: %s\n", file.path().c_str()); |
| for (int i = 0; i < file.symbol_size(); ++i) { |
| FprintIndented(report_fp_, 1, "symbol: %s\n", file.symbol(i).c_str()); |
| } |
| for (int i = 0; i < file.mangled_symbol_size(); ++i) { |
| FprintIndented(report_fp_, 1, "mangled_symbol: %s\n", file.mangled_symbol(i).c_str()); |
| } |
| if (file.id() != files.size()) { |
| LOG(ERROR) << "file id doesn't increase orderly, expected " |
| << files.size() << ", really " << file.id(); |
| return false; |
| } |
| files.push_back(file.symbol_size()); |
| } else if (proto_record.has_thread()) { |
| auto& thread = proto_record.thread(); |
| FprintIndented(report_fp_, 0, "thread:\n"); |
| FprintIndented(report_fp_, 1, "thread_id: %u\n", thread.thread_id()); |
| FprintIndented(report_fp_, 1, "process_id: %u\n", thread.process_id()); |
| FprintIndented(report_fp_, 1, "thread_name: %s\n", thread.thread_name().c_str()); |
| } else if (proto_record.has_meta_info()) { |
| auto& meta_info = proto_record.meta_info(); |
| FprintIndented(report_fp_, 0, "meta_info:\n"); |
| for (int i = 0; i < meta_info.event_type_size(); ++i) { |
| FprintIndented(report_fp_, 1, "event_type: %s\n", meta_info.event_type(i).c_str()); |
| } |
| if (meta_info.has_app_package_name()) { |
| FprintIndented(report_fp_, 0, "app_package_name: %s\n", |
| meta_info.app_package_name().c_str()); |
| } |
| } else { |
| LOG(ERROR) << "unexpected record type "; |
| return false; |
| } |
| } |
| for (auto pair : max_symbol_id_map) { |
| if (pair.first >= files.size()) { |
| LOG(ERROR) << "file_id(" << pair.first << ") >= file count (" |
| << files.size() << ")"; |
| return false; |
| } |
| if (static_cast<uint32_t>(pair.second) >= files[pair.first]) { |
| LOG(ERROR) << "symbol_id(" << pair.second << ") >= symbol count (" |
| << files[pair.first] << ") in file_id( " << pair.first << ")"; |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| bool ReportSampleCommand::OpenRecordFile() { |
| record_file_reader_ = RecordFileReader::CreateInstance(record_filename_); |
| if (record_file_reader_ == nullptr) { |
| return false; |
| } |
| record_file_reader_->LoadBuildIdAndFileFeatures(thread_tree_); |
| if (record_file_reader_->HasFeature(PerfFileFormat::FEAT_META_INFO)) { |
| if (!record_file_reader_->ReadMetaInfoFeature(&meta_info_)) { |
| return false; |
| } |
| auto it = meta_info_.find("event_type_info"); |
| if (it != meta_info_.end()) { |
| scoped_event_types_.reset(new ScopedEventTypes(it->second)); |
| } |
| it = meta_info_.find("trace_offcpu"); |
| if (it != meta_info_.end()) { |
| trace_offcpu_ = it->second == "true"; |
| } |
| it = meta_info_.find("kernel_symbols_available"); |
| if (it != meta_info_.end()) { |
| kernel_symbols_available_ = it->second == "true"; |
| } |
| } |
| for (EventAttrWithId& attr : record_file_reader_->AttrSection()) { |
| event_types_.push_back(GetEventNameByAttr(*attr.attr)); |
| } |
| return true; |
| } |
| |
| bool ReportSampleCommand::PrintMetaInfo() { |
| auto it = meta_info_.find("app_package_name"); |
| std::string app_package_name = it != meta_info_.end() ? it->second : ""; |
| if (use_protobuf_) { |
| proto::Record proto_record; |
| proto::MetaInfo* meta_info = proto_record.mutable_meta_info(); |
| for (auto& event_type : event_types_) { |
| *(meta_info->add_event_type()) = event_type; |
| } |
| if (!app_package_name.empty()) { |
| meta_info->set_app_package_name(app_package_name); |
| } |
| return WriteRecordInProtobuf(proto_record); |
| } |
| FprintIndented(report_fp_, 0, "meta_info:\n"); |
| FprintIndented(report_fp_, 1, "trace_offcpu: %s\n", trace_offcpu_ ? "true" : "false"); |
| for (auto& event_type : event_types_) { |
| FprintIndented(report_fp_, 1, "event_type: %s\n", event_type.c_str()); |
| } |
| if (!app_package_name.empty()) { |
| FprintIndented(report_fp_, 1, "app_package_name: %s\n", app_package_name.c_str()); |
| } |
| return true; |
| } |
| |
| bool ReportSampleCommand::ProcessRecord(std::unique_ptr<Record> record) { |
| thread_tree_.Update(*record); |
| if (record->type() == PERF_RECORD_SAMPLE) { |
| return ProcessSampleRecord(*static_cast<SampleRecord*>(record.get())); |
| } |
| if (record->type() == PERF_RECORD_LOST) { |
| lost_count_ += static_cast<const LostRecord*>(record.get())->lost; |
| } |
| return true; |
| } |
| |
| bool ReportSampleCommand::ProcessSampleRecord(const SampleRecord& r) { |
| size_t kernel_ip_count; |
| std::vector<uint64_t> ips = r.GetCallChain(&kernel_ip_count); |
| if (kernel_ip_count > 0u && remove_unknown_kernel_symbols_ && !kernel_symbols_available_) { |
| ips.erase(ips.begin(), ips.begin() + kernel_ip_count); |
| kernel_ip_count = 0; |
| } |
| if (ips.empty()) { |
| return true; |
| } |
| if (!show_callchain_) { |
| ips.resize(1); |
| kernel_ip_count = std::min(kernel_ip_count, static_cast<size_t>(1u)); |
| } |
| sample_count_++; |
| std::vector<CallEntry> entries; |
| bool near_java_method = false; |
| auto is_entry_for_interpreter = [](const CallEntry& entry) { |
| return android::base::EndsWith(entry.dso->Path(), "/libart.so"); |
| }; |
| const ThreadEntry* thread = thread_tree_.FindThreadOrNew(r.tid_data.pid, r.tid_data.tid); |
| for (size_t i = 0; i < ips.size(); ++i) { |
| bool omit_unknown_dso = i > 0u; |
| CallEntry entry; |
| if (!GetCallEntry(thread, i < kernel_ip_count, ips[i], omit_unknown_dso, &entry)) { |
| break; |
| } |
| if (!show_art_frames_) { |
| // Remove interpreter frames both before and after the Java frame. |
| if (entry.dso->IsForJavaMethod()) { |
| near_java_method = true; |
| while (!entries.empty() && is_entry_for_interpreter(entries.back())) { |
| entries.pop_back(); |
| } |
| } else if (is_entry_for_interpreter(entry)) { |
| if (near_java_method) { |
| continue; |
| } |
| } else { |
| near_java_method = false; |
| } |
| } |
| entries.push_back(entry); |
| } |
| if (use_protobuf_) { |
| return PrintSampleRecordInProtobuf(r, entries); |
| } |
| return PrintSampleRecord(r, entries); |
| } |
| |
| bool ReportSampleCommand::PrintSampleRecordInProtobuf(const SampleRecord& r, |
| const std::vector<CallEntry>& entries) { |
| proto::Record proto_record; |
| proto::Sample* sample = proto_record.mutable_sample(); |
| sample->set_time(r.time_data.time); |
| sample->set_event_count(r.period_data.period); |
| sample->set_thread_id(r.tid_data.tid); |
| sample->set_event_type_id(record_file_reader_->GetAttrIndexOfRecord(&r)); |
| |
| for (const CallEntry& node : entries) { |
| proto::Sample_CallChainEntry* callchain = sample->add_callchain(); |
| uint32_t file_id; |
| if (!node.dso->GetDumpId(&file_id)) { |
| file_id = node.dso->CreateDumpId(); |
| } |
| int32_t symbol_id = -1; |
| if (node.symbol != thread_tree_.UnknownSymbol()) { |
| if (!node.symbol->GetDumpId(reinterpret_cast<uint32_t*>(&symbol_id))) { |
| symbol_id = node.dso->CreateSymbolDumpId(node.symbol); |
| } |
| } |
| callchain->set_vaddr_in_file(node.vaddr_in_file); |
| callchain->set_file_id(file_id); |
| callchain->set_symbol_id(symbol_id); |
| |
| // Android studio wants a clear call chain end to notify whether a call chain is complete. |
| // For the main thread, the call chain ends at __libc_init in libc.so. For other threads, |
| // the call chain ends at __start_thread in libc.so. |
| // The call chain of the main thread can go beyond __libc_init, to _start (<= android O) or |
| // _start_main (> android O). |
| if (node.dso->FileName() == "libc.so" && |
| (strcmp(node.symbol->Name(), "__libc_init") == 0 || |
| strcmp(node.symbol->Name(), "__start_thread") == 0)) { |
| break; |
| } |
| } |
| return WriteRecordInProtobuf(proto_record); |
| } |
| |
| bool ReportSampleCommand::WriteRecordInProtobuf(proto::Record& proto_record) { |
| coded_os_->WriteLittleEndian32(proto_record.ByteSize()); |
| if (!proto_record.SerializeToCodedStream(coded_os_)) { |
| LOG(ERROR) << "failed to write record to protobuf"; |
| return false; |
| } |
| return true; |
| } |
| |
| bool ReportSampleCommand::GetCallEntry(const ThreadEntry* thread, |
| bool in_kernel, uint64_t ip, |
| bool omit_unknown_dso, |
| CallEntry* entry) { |
| const MapEntry* map = thread_tree_.FindMap(thread, ip, in_kernel); |
| if (omit_unknown_dso && thread_tree_.IsUnknownDso(map->dso)) { |
| return false; |
| } |
| entry->symbol = thread_tree_.FindSymbol(map, ip, &(entry->vaddr_in_file), &(entry->dso)); |
| // If we can't find symbol, use the dso shown in the map. |
| if (entry->symbol == thread_tree_.UnknownSymbol()) { |
| entry->dso = map->dso; |
| } |
| return true; |
| } |
| |
| bool ReportSampleCommand::PrintLostSituationInProtobuf() { |
| proto::Record proto_record; |
| proto::LostSituation* lost = proto_record.mutable_lost(); |
| lost->set_sample_count(sample_count_); |
| lost->set_lost_count(lost_count_); |
| return WriteRecordInProtobuf(proto_record); |
| } |
| |
| static bool CompareDsoByDumpId(Dso* d1, Dso* d2) { |
| uint32_t id1 = UINT_MAX; |
| d1->GetDumpId(&id1); |
| uint32_t id2 = UINT_MAX; |
| d2->GetDumpId(&id2); |
| return id1 < id2; |
| } |
| |
| bool ReportSampleCommand::PrintFileInfoInProtobuf() { |
| std::vector<Dso*> dsos = thread_tree_.GetAllDsos(); |
| std::sort(dsos.begin(), dsos.end(), CompareDsoByDumpId); |
| for (Dso* dso : dsos) { |
| uint32_t file_id; |
| if (!dso->GetDumpId(&file_id)) { |
| continue; |
| } |
| proto::Record proto_record; |
| proto::File* file = proto_record.mutable_file(); |
| file->set_id(file_id); |
| file->set_path(dso->Path()); |
| const std::vector<Symbol>& symbols = dso->GetSymbols(); |
| std::vector<const Symbol*> dump_symbols; |
| for (const auto& sym : symbols) { |
| if (sym.HasDumpId()) { |
| dump_symbols.push_back(&sym); |
| } |
| } |
| std::sort(dump_symbols.begin(), dump_symbols.end(), |
| Symbol::CompareByDumpId); |
| |
| for (const auto& sym : dump_symbols) { |
| std::string* symbol = file->add_symbol(); |
| *symbol = sym->DemangledName(); |
| std::string* mangled_symbol = file->add_mangled_symbol(); |
| *mangled_symbol = sym->Name(); |
| } |
| if (!WriteRecordInProtobuf(proto_record)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| bool ReportSampleCommand::PrintThreadInfoInProtobuf() { |
| std::vector<const ThreadEntry*> threads = thread_tree_.GetAllThreads(); |
| auto compare_thread_id = [](const ThreadEntry* t1, const ThreadEntry* t2) { |
| return t1->tid < t2->tid; |
| }; |
| std::sort(threads.begin(), threads.end(), compare_thread_id); |
| for (auto& thread : threads) { |
| proto::Record proto_record; |
| proto::Thread* proto_thread = proto_record.mutable_thread(); |
| proto_thread->set_thread_id(thread->tid); |
| proto_thread->set_process_id(thread->pid); |
| proto_thread->set_thread_name(thread->comm); |
| if (!WriteRecordInProtobuf(proto_record)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| bool ReportSampleCommand::PrintSampleRecord(const SampleRecord& r, |
| const std::vector<CallEntry>& entries) { |
| FprintIndented(report_fp_, 0, "sample:\n"); |
| FprintIndented(report_fp_, 1, "event_type: %s\n", |
| event_types_[record_file_reader_->GetAttrIndexOfRecord(&r)].c_str()); |
| FprintIndented(report_fp_, 1, "time: %" PRIu64 "\n", r.time_data.time); |
| FprintIndented(report_fp_, 1, "event_count: %" PRIu64 "\n", r.period_data.period); |
| FprintIndented(report_fp_, 1, "thread_id: %d\n", r.tid_data.tid); |
| const char* thread_name = thread_tree_.FindThreadOrNew(r.tid_data.pid, r.tid_data.tid)->comm; |
| FprintIndented(report_fp_, 1, "thread_name: %s\n", thread_name); |
| CHECK(!entries.empty()); |
| FprintIndented(report_fp_, 1, "vaddr_in_file: %" PRIx64 "\n", entries[0].vaddr_in_file); |
| FprintIndented(report_fp_, 1, "file: %s\n", entries[0].dso->Path().c_str()); |
| FprintIndented(report_fp_, 1, "symbol: %s\n", entries[0].symbol->DemangledName()); |
| |
| if (entries.size() > 1u) { |
| FprintIndented(report_fp_, 1, "callchain:\n"); |
| for (size_t i = 1u; i < entries.size(); ++i) { |
| FprintIndented(report_fp_, 2, "vaddr_in_file: %" PRIx64 "\n", entries[i].vaddr_in_file); |
| FprintIndented(report_fp_, 2, "file: %s\n", entries[i].dso->Path().c_str()); |
| FprintIndented(report_fp_, 2, "symbol: %s\n", entries[i].symbol->DemangledName()); |
| } |
| } |
| return true; |
| } |
| |
| void ReportSampleCommand::PrintLostSituation() { |
| FprintIndented(report_fp_, 0, "lost_situation:\n"); |
| FprintIndented(report_fp_, 1, "sample_count: %" PRIu64 "\n", sample_count_); |
| FprintIndented(report_fp_, 1, "lost_count: %" PRIu64 "\n", lost_count_); |
| } |
| |
| } // namespace |
| |
| void RegisterReportSampleCommand() { |
| RegisterCommand("report-sample", [] { |
| return std::unique_ptr<Command>(new ReportSampleCommand()); |
| }); |
| } |
