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 #include <inttypes.h> 18 19 #include <map> 20 #include <string> 21 #include <vector> 22 23 #include <android-base/logging.h> 24 #include <android-base/stringprintf.h> 25 #include <android-base/strings.h> 26 27 #include "command.h" 28 #include "event_attr.h" 29 #include "event_type.h" 30 #include "perf_regs.h" 31 #include "record.h" 32 #include "record_file.h" 33 #include "utils.h" 34 35 using namespace PerfFileFormat; 36 37 class DumpRecordCommand : public Command { 38 public: 39 DumpRecordCommand() 40 : Command("dump", "dump perf record file", 41 "Usage: simpleperf dumprecord [options] [perf_record_file]\n" 42 " Dump different parts of a perf record file. Default file is perf.data.\n"), 43 record_filename_("perf.data"), record_file_arch_(GetBuildArch()) { 44 } 45 46 bool Run(const std::vector<std::string>& args); 47 48 private: 49 bool ParseOptions(const std::vector<std::string>& args); 50 void DumpFileHeader(); 51 void DumpAttrSection(); 52 bool DumpDataSection(); 53 bool DumpFeatureSection(); 54 55 std::string record_filename_; 56 std::unique_ptr<RecordFileReader> record_file_reader_; 57 ArchType record_file_arch_; 58 }; 59 60 bool DumpRecordCommand::Run(const std::vector<std::string>& args) { 61 if (!ParseOptions(args)) { 62 return false; 63 } 64 record_file_reader_ = RecordFileReader::CreateInstance(record_filename_); 65 if (record_file_reader_ == nullptr) { 66 return false; 67 } 68 std::string arch = record_file_reader_->ReadFeatureString(FEAT_ARCH); 69 if (!arch.empty()) { 70 record_file_arch_ = GetArchType(arch); 71 if (record_file_arch_ == ARCH_UNSUPPORTED) { 72 return false; 73 } 74 } 75 ScopedCurrentArch scoped_arch(record_file_arch_); 76 std::unique_ptr<ScopedEventTypes> scoped_event_types; 77 if (record_file_reader_->HasFeature(PerfFileFormat::FEAT_META_INFO)) { 78 std::unordered_map<std::string, std::string> meta_info; 79 if (!record_file_reader_->ReadMetaInfoFeature(&meta_info)) { 80 return false; 81 } 82 auto it = meta_info.find("event_type_info"); 83 if (it != meta_info.end()) { 84 scoped_event_types.reset(new ScopedEventTypes(it->second)); 85 } 86 } 87 DumpFileHeader(); 88 DumpAttrSection(); 89 if (!DumpDataSection()) { 90 return false; 91 } 92 return DumpFeatureSection(); 93 } 94 95 bool DumpRecordCommand::ParseOptions(const std::vector<std::string>& args) { 96 if (args.size() == 1) { 97 record_filename_ = args[0]; 98 } else if (args.size() > 1) { 99 ReportUnknownOption(args, 1); 100 return false; 101 } 102 return true; 103 } 104 105 static const std::string GetFeatureNameOrUnknown(int feature) { 106 std::string name = GetFeatureName(feature); 107 return name.empty() ? android::base::StringPrintf("unknown_feature(%d)", feature) : name; 108 } 109 110 void DumpRecordCommand::DumpFileHeader() { 111 const FileHeader& header = record_file_reader_->FileHeader(); 112 printf("magic: "); 113 for (size_t i = 0; i < 8; ++i) { 114 printf("%c", header.magic[i]); 115 } 116 printf("\n"); 117 printf("header_size: %" PRId64 "\n", header.header_size); 118 if (header.header_size != sizeof(header)) { 119 PLOG(WARNING) << "record file header size " << header.header_size 120 << "doesn't match expected header size " << sizeof(header); 121 } 122 printf("attr_size: %" PRId64 "\n", header.attr_size); 123 if (header.attr_size != sizeof(FileAttr)) { 124 PLOG(WARNING) << "record file attr size " << header.attr_size 125 << " doesn't match expected attr size " << sizeof(FileAttr); 126 } 127 printf("attrs[file section]: offset %" PRId64 ", size %" PRId64 "\n", header.attrs.offset, 128 header.attrs.size); 129 printf("data[file section]: offset %" PRId64 ", size %" PRId64 "\n", header.data.offset, 130 header.data.size); 131 printf("event_types[file section]: offset %" PRId64 ", size %" PRId64 "\n", 132 header.event_types.offset, header.event_types.size); 133 134 std::vector<int> features; 135 for (size_t i = 0; i < FEAT_MAX_NUM; ++i) { 136 size_t j = i / 8; 137 size_t k = i % 8; 138 if ((header.features[j] & (1 << k)) != 0) { 139 features.push_back(i); 140 } 141 } 142 for (auto& feature : features) { 143 printf("feature: %s\n", GetFeatureNameOrUnknown(feature).c_str()); 144 } 145 } 146 147 void DumpRecordCommand::DumpAttrSection() { 148 std::vector<EventAttrWithId> attrs = record_file_reader_->AttrSection(); 149 for (size_t i = 0; i < attrs.size(); ++i) { 150 const auto& attr = attrs[i]; 151 printf("attr %zu:\n", i + 1); 152 DumpPerfEventAttr(*attr.attr, 1); 153 if (!attr.ids.empty()) { 154 printf(" ids:"); 155 for (const auto& id : attr.ids) { 156 printf(" %" PRId64, id); 157 } 158 printf("\n"); 159 } 160 } 161 } 162 163 bool DumpRecordCommand::DumpDataSection() { 164 ThreadTree thread_tree; 165 thread_tree.ShowIpForUnknownSymbol(); 166 record_file_reader_->LoadBuildIdAndFileFeatures(thread_tree); 167 168 auto get_symbol_function = [&](uint32_t pid, uint32_t tid, uint64_t ip, std::string& dso_name, 169 std::string& symbol_name, uint64_t& vaddr_in_file) { 170 ThreadEntry* thread = thread_tree.FindThreadOrNew(pid, tid); 171 const MapEntry* map = thread_tree.FindMap(thread, ip); 172 Dso* dso; 173 const Symbol* symbol = thread_tree.FindSymbol(map, ip, &vaddr_in_file, &dso); 174 dso_name = dso->Path(); 175 symbol_name = symbol->DemangledName(); 176 }; 177 178 auto record_callback = [&](std::unique_ptr<Record> r) { 179 r->Dump(); 180 thread_tree.Update(*r); 181 if (r->type() == PERF_RECORD_SAMPLE) { 182 SampleRecord& sr = *static_cast<SampleRecord*>(r.get()); 183 if (sr.sample_type & PERF_SAMPLE_CALLCHAIN) { 184 PrintIndented(1, "callchain:\n"); 185 for (size_t i = 0; i < sr.callchain_data.ip_nr; ++i) { 186 std::string dso_name; 187 std::string symbol_name; 188 uint64_t vaddr_in_file; 189 get_symbol_function(sr.tid_data.pid, sr.tid_data.tid, sr.callchain_data.ips[i], 190 dso_name, symbol_name, vaddr_in_file); 191 PrintIndented(2, "%s (%s[+%" PRIx64 "])\n", symbol_name.c_str(), dso_name.c_str(), 192 vaddr_in_file); 193 } 194 } 195 } else if (r->type() == SIMPLE_PERF_RECORD_CALLCHAIN) { 196 CallChainRecord& cr = *static_cast<CallChainRecord*>(r.get()); 197 PrintIndented(1, "callchain:\n"); 198 for (size_t i = 0; i < cr.ip_nr; ++i) { 199 std::string dso_name; 200 std::string symbol_name; 201 uint64_t vaddr_in_file; 202 get_symbol_function(cr.pid, cr.tid, cr.ips[i], dso_name, symbol_name, vaddr_in_file); 203 PrintIndented(2, "%s (%s[+%" PRIx64 "])\n", symbol_name.c_str(), dso_name.c_str(), 204 vaddr_in_file); 205 } 206 } 207 return true; 208 }; 209 return record_file_reader_->ReadDataSection(record_callback, false); 210 } 211 212 bool DumpRecordCommand::DumpFeatureSection() { 213 std::map<int, SectionDesc> section_map = record_file_reader_->FeatureSectionDescriptors(); 214 for (const auto& pair : section_map) { 215 int feature = pair.first; 216 const auto& section = pair.second; 217 printf("feature section for %s: offset %" PRId64 ", size %" PRId64 "\n", 218 GetFeatureNameOrUnknown(feature).c_str(), section.offset, section.size); 219 if (feature == FEAT_BUILD_ID) { 220 std::vector<BuildIdRecord> records = record_file_reader_->ReadBuildIdFeature(); 221 for (auto& r : records) { 222 r.Dump(1); 223 } 224 } else if (feature == FEAT_OSRELEASE) { 225 std::string s = record_file_reader_->ReadFeatureString(feature); 226 PrintIndented(1, "osrelease: %s\n", s.c_str()); 227 } else if (feature == FEAT_ARCH) { 228 std::string s = record_file_reader_->ReadFeatureString(feature); 229 PrintIndented(1, "arch: %s\n", s.c_str()); 230 } else if (feature == FEAT_CMDLINE) { 231 std::vector<std::string> cmdline = record_file_reader_->ReadCmdlineFeature(); 232 PrintIndented(1, "cmdline: %s\n", android::base::Join(cmdline, ' ').c_str()); 233 } else if (feature == FEAT_FILE) { 234 std::string file_path; 235 uint32_t file_type; 236 uint64_t min_vaddr; 237 std::vector<Symbol> symbols; 238 size_t read_pos = 0; 239 PrintIndented(1, "file:\n"); 240 while (record_file_reader_->ReadFileFeature(read_pos, &file_path, 241 &file_type, &min_vaddr, 242 &symbols)) { 243 PrintIndented(2, "file_path %s\n", file_path.c_str()); 244 PrintIndented(2, "file_type %s\n", DsoTypeToString(static_cast<DsoType>(file_type))); 245 PrintIndented(2, "min_vaddr 0x%" PRIx64 "\n", min_vaddr); 246 PrintIndented(2, "symbols:\n"); 247 for (const auto& symbol : symbols) { 248 PrintIndented(3, "%s [0x%" PRIx64 "-0x%" PRIx64 "]\n", symbol.DemangledName(), 249 symbol.addr, symbol.addr + symbol.len); 250 } 251 } 252 } else if (feature == FEAT_META_INFO) { 253 std::unordered_map<std::string, std::string> info_map; 254 if (!record_file_reader_->ReadMetaInfoFeature(&info_map)) { 255 return false; 256 } 257 PrintIndented(1, "meta_info:\n"); 258 for (auto& pair : info_map) { 259 PrintIndented(2, "%s = %s\n", pair.first.c_str(), pair.second.c_str()); 260 } 261 } 262 } 263 return true; 264 } 265 266 void RegisterDumpRecordCommand() { 267 RegisterCommand("dump", [] { return std::unique_ptr<Command>(new DumpRecordCommand); }); 268 } 269
