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 #include <algorithm> 19 #include <functional> 20 #include <map> 21 #include <set> 22 #include <string> 23 #include <unordered_map> 24 #include <unordered_set> 25 #include <vector> 26 27 #include <android-base/file.h> 28 #include <android-base/logging.h> 29 #include <android-base/parsedouble.h> 30 #include <android-base/parseint.h> 31 #include <android-base/stringprintf.h> 32 #include <android-base/strings.h> 33 34 #include "command.h" 35 #include "dwarf_unwind.h" 36 #include "event_attr.h" 37 #include "event_type.h" 38 #include "perf_regs.h" 39 #include "record.h" 40 #include "record_file.h" 41 #include "sample_tree.h" 42 #include "thread_tree.h" 43 #include "tracing.h" 44 #include "utils.h" 45 46 namespace { 47 48 static std::set<std::string> branch_sort_keys = { 49 "dso_from", "dso_to", "symbol_from", "symbol_to", 50 }; 51 struct BranchFromEntry { 52 const MapEntry* map; 53 const Symbol* symbol; 54 uint64_t vaddr_in_file; 55 uint64_t flags; 56 57 BranchFromEntry() 58 : map(nullptr), symbol(nullptr), vaddr_in_file(0), flags(0) {} 59 }; 60 61 struct SampleEntry { 62 uint64_t time; 63 uint64_t period; 64 // accumuated when appearing in other sample's callchain 65 uint64_t accumulated_period; 66 uint64_t sample_count; 67 const ThreadEntry* thread; 68 const char* thread_comm; 69 const MapEntry* map; 70 const Symbol* symbol; 71 uint64_t vaddr_in_file; 72 BranchFromEntry branch_from; 73 // a callchain tree representing all callchains in the sample 74 CallChainRoot<SampleEntry> callchain; 75 76 SampleEntry(uint64_t time, uint64_t period, uint64_t accumulated_period, 77 uint64_t sample_count, const ThreadEntry* thread, 78 const MapEntry* map, const Symbol* symbol, uint64_t vaddr_in_file) 79 : time(time), 80 period(period), 81 accumulated_period(accumulated_period), 82 sample_count(sample_count), 83 thread(thread), 84 thread_comm(thread->comm), 85 map(map), 86 symbol(symbol), 87 vaddr_in_file(vaddr_in_file) {} 88 89 // The data member 'callchain' can only move, not copy. 90 SampleEntry(SampleEntry&&) = default; 91 SampleEntry(SampleEntry&) = delete; 92 93 uint64_t GetPeriod() const { 94 return period; 95 } 96 }; 97 98 struct SampleTree { 99 std::vector<SampleEntry*> samples; 100 uint64_t total_samples; 101 uint64_t total_period; 102 uint64_t total_error_callchains; 103 }; 104 105 BUILD_COMPARE_VALUE_FUNCTION(CompareVaddrInFile, vaddr_in_file); 106 BUILD_DISPLAY_HEX64_FUNCTION(DisplayVaddrInFile, vaddr_in_file); 107 108 class ReportCmdSampleTreeBuilder 109 : public SampleTreeBuilder<SampleEntry, uint64_t> { 110 public: 111 ReportCmdSampleTreeBuilder(SampleComparator<SampleEntry> sample_comparator, 112 ThreadTree* thread_tree) 113 : SampleTreeBuilder(sample_comparator), 114 thread_tree_(thread_tree), 115 total_samples_(0), 116 total_period_(0), 117 total_error_callchains_(0) {} 118 119 void SetFilters(const std::unordered_set<int>& pid_filter, 120 const std::unordered_set<int>& tid_filter, 121 const std::unordered_set<std::string>& comm_filter, 122 const std::unordered_set<std::string>& dso_filter, 123 const std::unordered_set<std::string>& symbol_filter) { 124 pid_filter_ = pid_filter; 125 tid_filter_ = tid_filter; 126 comm_filter_ = comm_filter; 127 dso_filter_ = dso_filter; 128 symbol_filter_ = symbol_filter; 129 } 130 131 SampleTree GetSampleTree() { 132 AddCallChainDuplicateInfo(); 133 SampleTree sample_tree; 134 sample_tree.samples = GetSamples(); 135 sample_tree.total_samples = total_samples_; 136 sample_tree.total_period = total_period_; 137 sample_tree.total_error_callchains = total_error_callchains_; 138 return sample_tree; 139 } 140 141 protected: 142 SampleEntry* CreateSample(const SampleRecord& r, bool in_kernel, 143 uint64_t* acc_info) override { 144 const ThreadEntry* thread = 145 thread_tree_->FindThreadOrNew(r.tid_data.pid, r.tid_data.tid); 146 const MapEntry* map = 147 thread_tree_->FindMap(thread, r.ip_data.ip, in_kernel); 148 uint64_t vaddr_in_file; 149 const Symbol* symbol = 150 thread_tree_->FindSymbol(map, r.ip_data.ip, &vaddr_in_file); 151 *acc_info = r.period_data.period; 152 return InsertSample(std::unique_ptr<SampleEntry>( 153 new SampleEntry(r.time_data.time, r.period_data.period, 0, 1, thread, 154 map, symbol, vaddr_in_file))); 155 } 156 157 SampleEntry* CreateBranchSample(const SampleRecord& r, 158 const BranchStackItemType& item) override { 159 const ThreadEntry* thread = 160 thread_tree_->FindThreadOrNew(r.tid_data.pid, r.tid_data.tid); 161 const MapEntry* from_map = thread_tree_->FindMap(thread, item.from); 162 uint64_t from_vaddr_in_file; 163 const Symbol* from_symbol = 164 thread_tree_->FindSymbol(from_map, item.from, &from_vaddr_in_file); 165 const MapEntry* to_map = thread_tree_->FindMap(thread, item.to); 166 uint64_t to_vaddr_in_file; 167 const Symbol* to_symbol = 168 thread_tree_->FindSymbol(to_map, item.to, &to_vaddr_in_file); 169 std::unique_ptr<SampleEntry> sample( 170 new SampleEntry(r.time_data.time, r.period_data.period, 0, 1, thread, 171 to_map, to_symbol, to_vaddr_in_file)); 172 sample->branch_from.map = from_map; 173 sample->branch_from.symbol = from_symbol; 174 sample->branch_from.vaddr_in_file = from_vaddr_in_file; 175 sample->branch_from.flags = item.flags; 176 return InsertSample(std::move(sample)); 177 } 178 179 SampleEntry* CreateCallChainSample(const SampleEntry* sample, uint64_t ip, 180 bool in_kernel, 181 const std::vector<SampleEntry*>& callchain, 182 const uint64_t& acc_info) override { 183 const ThreadEntry* thread = sample->thread; 184 const MapEntry* map = thread_tree_->FindMap(thread, ip, in_kernel); 185 if (thread_tree_->IsUnknownDso(map->dso)) { 186 // The unwinders can give wrong ip addresses, which can't map to a valid dso. Skip them. 187 total_error_callchains_++; 188 return nullptr; 189 } 190 uint64_t vaddr_in_file; 191 const Symbol* symbol = thread_tree_->FindSymbol(map, ip, &vaddr_in_file); 192 std::unique_ptr<SampleEntry> callchain_sample(new SampleEntry( 193 sample->time, 0, acc_info, 0, thread, map, symbol, vaddr_in_file)); 194 callchain_sample->thread_comm = sample->thread_comm; 195 return InsertCallChainSample(std::move(callchain_sample), callchain); 196 } 197 198 const ThreadEntry* GetThreadOfSample(SampleEntry* sample) override { 199 return sample->thread; 200 } 201 202 uint64_t GetPeriodForCallChain(const uint64_t& acc_info) override { 203 return acc_info; 204 } 205 206 bool FilterSample(const SampleEntry* sample) override { 207 if (!pid_filter_.empty() && 208 pid_filter_.find(sample->thread->pid) == pid_filter_.end()) { 209 return false; 210 } 211 if (!tid_filter_.empty() && 212 tid_filter_.find(sample->thread->tid) == tid_filter_.end()) { 213 return false; 214 } 215 if (!comm_filter_.empty() && 216 comm_filter_.find(sample->thread_comm) == comm_filter_.end()) { 217 return false; 218 } 219 if (!dso_filter_.empty() && 220 dso_filter_.find(sample->map->dso->Path()) == dso_filter_.end()) { 221 return false; 222 } 223 if (!symbol_filter_.empty() && 224 symbol_filter_.find(sample->symbol->DemangledName()) == 225 symbol_filter_.end()) { 226 return false; 227 } 228 return true; 229 } 230 231 void UpdateSummary(const SampleEntry* sample) override { 232 total_samples_ += sample->sample_count; 233 total_period_ += sample->period; 234 } 235 236 void MergeSample(SampleEntry* sample1, SampleEntry* sample2) override { 237 sample1->period += sample2->period; 238 sample1->accumulated_period += sample2->accumulated_period; 239 sample1->sample_count += sample2->sample_count; 240 } 241 242 private: 243 ThreadTree* thread_tree_; 244 245 std::unordered_set<int> pid_filter_; 246 std::unordered_set<int> tid_filter_; 247 std::unordered_set<std::string> comm_filter_; 248 std::unordered_set<std::string> dso_filter_; 249 std::unordered_set<std::string> symbol_filter_; 250 251 uint64_t total_samples_; 252 uint64_t total_period_; 253 uint64_t total_error_callchains_; 254 }; 255 256 struct SampleTreeBuilderOptions { 257 SampleComparator<SampleEntry> comparator; 258 ThreadTree* thread_tree; 259 std::unordered_set<std::string> comm_filter; 260 std::unordered_set<std::string> dso_filter; 261 std::unordered_set<std::string> symbol_filter; 262 std::unordered_set<int> pid_filter; 263 std::unordered_set<int> tid_filter; 264 bool use_branch_address; 265 bool accumulate_callchain; 266 bool build_callchain; 267 bool use_caller_as_callchain_root; 268 bool strict_unwind_arch_check; 269 270 std::unique_ptr<ReportCmdSampleTreeBuilder> CreateSampleTreeBuilder() { 271 std::unique_ptr<ReportCmdSampleTreeBuilder> builder( 272 new ReportCmdSampleTreeBuilder(comparator, thread_tree)); 273 builder->SetFilters(pid_filter, tid_filter, comm_filter, dso_filter, symbol_filter); 274 builder->SetBranchSampleOption(use_branch_address); 275 builder->SetCallChainSampleOptions(accumulate_callchain, build_callchain, 276 use_caller_as_callchain_root, strict_unwind_arch_check); 277 return builder; 278 } 279 }; 280 281 using ReportCmdSampleTreeSorter = SampleTreeSorter<SampleEntry>; 282 using ReportCmdSampleTreeDisplayer = 283 SampleTreeDisplayer<SampleEntry, SampleTree>; 284 285 using ReportCmdCallgraphDisplayer = 286 CallgraphDisplayer<SampleEntry, CallChainNode<SampleEntry>>; 287 288 class ReportCmdCallgraphDisplayerWithVaddrInFile 289 : public ReportCmdCallgraphDisplayer { 290 protected: 291 std::string PrintSampleName(const SampleEntry* sample) override { 292 return android::base::StringPrintf("%s [+0x%" PRIx64 "]", 293 sample->symbol->DemangledName(), 294 sample->vaddr_in_file); 295 } 296 }; 297 298 struct EventAttrWithName { 299 perf_event_attr attr; 300 std::string name; 301 }; 302 303 class ReportCommand : public Command { 304 public: 305 ReportCommand() 306 : Command( 307 "report", "report sampling information in perf.data", 308 // clang-format off 309 "Usage: simpleperf report [options]\n" 310 "The default options are: -i perf.data --sort comm,pid,tid,dso,symbol.\n" 311 "-b Use the branch-to addresses in sampled take branches instead of the\n" 312 " instruction addresses. Only valid for perf.data recorded with -b/-j\n" 313 " option.\n" 314 "--children Print the overhead accumulated by appearing in the callchain.\n" 315 "--comms comm1,comm2,... Report only for selected comms.\n" 316 "--dsos dso1,dso2,... Report only for selected dsos.\n" 317 "--full-callgraph Print full call graph. Used with -g option. By default,\n" 318 " brief call graph is printed.\n" 319 "-g [callee|caller] Print call graph. If callee mode is used, the graph\n" 320 " shows how functions are called from others. Otherwise,\n" 321 " the graph shows how functions call others.\n" 322 " Default is caller mode.\n" 323 "-i <file> Specify path of record file, default is perf.data.\n" 324 "--kallsyms <file> Set the file to read kernel symbols.\n" 325 "--max-stack <frames> Set max stack frames shown when printing call graph.\n" 326 "-n Print the sample count for each item.\n" 327 "--no-demangle Don't demangle symbol names.\n" 328 "--no-show-ip Don't show vaddr in file for unknown symbols.\n" 329 "-o report_file_name Set report file name, default is stdout.\n" 330 "--percent-limit <percent> Set min percentage shown when printing call graph.\n" 331 "--pids pid1,pid2,... Report only for selected pids.\n" 332 "--raw-period Report period count instead of period percentage.\n" 333 "--sort key1,key2,... Select keys used to sort and print the report. The\n" 334 " appearance order of keys decides the order of keys used\n" 335 " to sort and print the report.\n" 336 " Possible keys include:\n" 337 " pid -- process id\n" 338 " tid -- thread id\n" 339 " comm -- thread name (can be changed during\n" 340 " the lifetime of a thread)\n" 341 " dso -- shared library\n" 342 " symbol -- function name in the shared library\n" 343 " vaddr_in_file -- virtual address in the shared\n" 344 " library\n" 345 " Keys can only be used with -b option:\n" 346 " dso_from -- shared library branched from\n" 347 " dso_to -- shared library branched to\n" 348 " symbol_from -- name of function branched from\n" 349 " symbol_to -- name of function branched to\n" 350 " The default sort keys are:\n" 351 " comm,pid,tid,dso,symbol\n" 352 "--symbols symbol1;symbol2;... Report only for selected symbols.\n" 353 "--symfs <dir> Look for files with symbols relative to this directory.\n" 354 "--tids tid1,tid2,... Report only for selected tids.\n" 355 "--vmlinux <file> Parse kernel symbols from <file>.\n" 356 // clang-format on 357 ), 358 record_filename_("perf.data"), 359 record_file_arch_(GetBuildArch()), 360 use_branch_address_(false), 361 system_wide_collection_(false), 362 accumulate_callchain_(false), 363 print_callgraph_(false), 364 callgraph_show_callee_(false), 365 callgraph_max_stack_(UINT32_MAX), 366 callgraph_percent_limit_(0), 367 raw_period_(false), 368 brief_callgraph_(true) {} 369 370 bool Run(const std::vector<std::string>& args); 371 372 private: 373 bool ParseOptions(const std::vector<std::string>& args); 374 bool ReadEventAttrFromRecordFile(); 375 bool ReadFeaturesFromRecordFile(); 376 bool ReadSampleTreeFromRecordFile(); 377 bool ProcessRecord(std::unique_ptr<Record> record); 378 bool ProcessTracingData(const std::vector<char>& data); 379 bool PrintReport(); 380 void PrintReportContext(FILE* fp); 381 382 std::string record_filename_; 383 ArchType record_file_arch_; 384 std::unique_ptr<RecordFileReader> record_file_reader_; 385 std::vector<EventAttrWithName> event_attrs_; 386 ThreadTree thread_tree_; 387 // Create a SampleTreeBuilder and SampleTree for each event_attr. 388 std::vector<SampleTree> sample_tree_; 389 SampleTreeBuilderOptions sample_tree_builder_options_; 390 std::vector<std::unique_ptr<ReportCmdSampleTreeBuilder>> sample_tree_builder_; 391 392 std::unique_ptr<ReportCmdSampleTreeSorter> sample_tree_sorter_; 393 std::unique_ptr<ReportCmdSampleTreeDisplayer> sample_tree_displayer_; 394 bool use_branch_address_; 395 std::string record_cmdline_; 396 bool system_wide_collection_; 397 bool accumulate_callchain_; 398 bool print_callgraph_; 399 bool callgraph_show_callee_; 400 uint32_t callgraph_max_stack_; 401 double callgraph_percent_limit_; 402 bool raw_period_; 403 bool brief_callgraph_; 404 405 std::string report_filename_; 406 }; 407 408 bool ReportCommand::Run(const std::vector<std::string>& args) { 409 // 1. Parse options. 410 if (!ParseOptions(args)) { 411 return false; 412 } 413 414 // 2. Read record file and build SampleTree. 415 record_file_reader_ = RecordFileReader::CreateInstance(record_filename_); 416 if (record_file_reader_ == nullptr) { 417 return false; 418 } 419 if (!ReadEventAttrFromRecordFile()) { 420 return false; 421 } 422 // Read features first to prepare build ids used when building SampleTree. 423 if (!ReadFeaturesFromRecordFile()) { 424 return false; 425 } 426 ScopedCurrentArch scoped_arch(record_file_arch_); 427 if (!ReadSampleTreeFromRecordFile()) { 428 return false; 429 } 430 431 // 3. Show collected information. 432 if (!PrintReport()) { 433 return false; 434 } 435 436 return true; 437 } 438 439 bool ReportCommand::ParseOptions(const std::vector<std::string>& args) { 440 bool demangle = true; 441 bool show_ip_for_unknown_symbol = true; 442 std::string symfs_dir; 443 std::string vmlinux; 444 bool print_sample_count = false; 445 std::vector<std::string> sort_keys = {"comm", "pid", "tid", "dso", "symbol"}; 446 447 for (size_t i = 0; i < args.size(); ++i) { 448 if (args[i] == "-b") { 449 use_branch_address_ = true; 450 } else if (args[i] == "--children") { 451 accumulate_callchain_ = true; 452 } else if (args[i] == "--comms" || args[i] == "--dsos") { 453 std::unordered_set<std::string>& filter = 454 (args[i] == "--comms" ? sample_tree_builder_options_.comm_filter 455 : sample_tree_builder_options_.dso_filter); 456 if (!NextArgumentOrError(args, &i)) { 457 return false; 458 } 459 std::vector<std::string> strs = android::base::Split(args[i], ","); 460 filter.insert(strs.begin(), strs.end()); 461 } else if (args[i] == "--full-callgraph") { 462 brief_callgraph_ = false; 463 } else if (args[i] == "-g") { 464 print_callgraph_ = true; 465 accumulate_callchain_ = true; 466 if (i + 1 < args.size() && args[i + 1][0] != '-') { 467 ++i; 468 if (args[i] == "callee") { 469 callgraph_show_callee_ = true; 470 } else if (args[i] == "caller") { 471 callgraph_show_callee_ = false; 472 } else { 473 LOG(ERROR) << "Unknown argument with -g option: " << args[i]; 474 return false; 475 } 476 } 477 } else if (args[i] == "-i") { 478 if (!NextArgumentOrError(args, &i)) { 479 return false; 480 } 481 record_filename_ = args[i]; 482 483 } else if (args[i] == "--kallsyms") { 484 if (!NextArgumentOrError(args, &i)) { 485 return false; 486 } 487 std::string kallsyms; 488 if (!android::base::ReadFileToString(args[i], &kallsyms)) { 489 LOG(ERROR) << "Can't read kernel symbols from " << args[i]; 490 return false; 491 } 492 Dso::SetKallsyms(kallsyms); 493 } else if (args[i] == "--max-stack") { 494 if (!NextArgumentOrError(args, &i)) { 495 return false; 496 } 497 if (!android::base::ParseUint(args[i].c_str(), &callgraph_max_stack_)) { 498 LOG(ERROR) << "invalid arg for --max-stack: " << args[i]; 499 return false; 500 } 501 } else if (args[i] == "-n") { 502 print_sample_count = true; 503 504 } else if (args[i] == "--no-demangle") { 505 demangle = false; 506 } else if (args[i] == "--no-show-ip") { 507 show_ip_for_unknown_symbol = false; 508 } else if (args[i] == "-o") { 509 if (!NextArgumentOrError(args, &i)) { 510 return false; 511 } 512 report_filename_ = args[i]; 513 } else if (args[i] == "--percent-limit") { 514 if (!NextArgumentOrError(args, &i)) { 515 return false; 516 } 517 if (!android::base::ParseDouble(args[i].c_str(), 518 &callgraph_percent_limit_, 0.0)) { 519 LOG(ERROR) << "invalid arg for --percent-limit: " << args[i]; 520 } 521 } else if (args[i] == "--pids" || args[i] == "--tids") { 522 const std::string& option = args[i]; 523 std::unordered_set<int>& filter = 524 (option == "--pids" ? sample_tree_builder_options_.pid_filter 525 : sample_tree_builder_options_.tid_filter); 526 if (!NextArgumentOrError(args, &i)) { 527 return false; 528 } 529 std::vector<std::string> strs = android::base::Split(args[i], ","); 530 for (const auto& s : strs) { 531 int id; 532 if (!android::base::ParseInt(s.c_str(), &id, 0)) { 533 LOG(ERROR) << "invalid id in " << option << " option: " << s; 534 return false; 535 } 536 filter.insert(id); 537 } 538 } else if (args[i] == "--raw-period") { 539 raw_period_ = true; 540 } else if (args[i] == "--sort") { 541 if (!NextArgumentOrError(args, &i)) { 542 return false; 543 } 544 sort_keys = android::base::Split(args[i], ","); 545 } else if (args[i] == "--symbols") { 546 if (!NextArgumentOrError(args, &i)) { 547 return false; 548 } 549 std::vector<std::string> strs = android::base::Split(args[i], ";"); 550 sample_tree_builder_options_.symbol_filter.insert(strs.begin(), strs.end()); 551 } else if (args[i] == "--symfs") { 552 if (!NextArgumentOrError(args, &i)) { 553 return false; 554 } 555 symfs_dir = args[i]; 556 557 } else if (args[i] == "--vmlinux") { 558 if (!NextArgumentOrError(args, &i)) { 559 return false; 560 } 561 vmlinux = args[i]; 562 } else { 563 ReportUnknownOption(args, i); 564 return false; 565 } 566 } 567 568 Dso::SetDemangle(demangle); 569 if (!Dso::SetSymFsDir(symfs_dir)) { 570 return false; 571 } 572 if (!vmlinux.empty()) { 573 Dso::SetVmlinux(vmlinux); 574 } 575 576 if (show_ip_for_unknown_symbol) { 577 thread_tree_.ShowIpForUnknownSymbol(); 578 } 579 580 SampleDisplayer<SampleEntry, SampleTree> displayer; 581 SampleComparator<SampleEntry> comparator; 582 583 if (accumulate_callchain_) { 584 if (raw_period_) { 585 displayer.AddDisplayFunction("Children", DisplayAccumulatedPeriod); 586 displayer.AddDisplayFunction("Self", DisplaySelfPeriod); 587 } else { 588 displayer.AddDisplayFunction("Children", DisplayAccumulatedOverhead); 589 displayer.AddDisplayFunction("Self", DisplaySelfOverhead); 590 } 591 } else { 592 if (raw_period_) { 593 displayer.AddDisplayFunction("Overhead", DisplaySelfPeriod); 594 } else { 595 displayer.AddDisplayFunction("Overhead", DisplaySelfOverhead); 596 } 597 } 598 if (print_sample_count) { 599 displayer.AddDisplayFunction("Sample", DisplaySampleCount); 600 } 601 602 for (auto& key : sort_keys) { 603 if (!use_branch_address_ && 604 branch_sort_keys.find(key) != branch_sort_keys.end()) { 605 LOG(ERROR) << "sort key '" << key << "' can only be used with -b option."; 606 return false; 607 } 608 if (key == "pid") { 609 comparator.AddCompareFunction(ComparePid); 610 displayer.AddDisplayFunction("Pid", DisplayPid); 611 } else if (key == "tid") { 612 comparator.AddCompareFunction(CompareTid); 613 displayer.AddDisplayFunction("Tid", DisplayTid); 614 } else if (key == "comm") { 615 comparator.AddCompareFunction(CompareComm); 616 displayer.AddDisplayFunction("Command", DisplayComm); 617 } else if (key == "dso") { 618 comparator.AddCompareFunction(CompareDso); 619 displayer.AddDisplayFunction("Shared Object", DisplayDso); 620 } else if (key == "symbol") { 621 comparator.AddCompareFunction(CompareSymbol); 622 displayer.AddDisplayFunction("Symbol", DisplaySymbol); 623 } else if (key == "vaddr_in_file") { 624 comparator.AddCompareFunction(CompareVaddrInFile); 625 displayer.AddDisplayFunction("VaddrInFile", DisplayVaddrInFile); 626 } else if (key == "dso_from") { 627 comparator.AddCompareFunction(CompareDsoFrom); 628 displayer.AddDisplayFunction("Source Shared Object", DisplayDsoFrom); 629 } else if (key == "dso_to") { 630 comparator.AddCompareFunction(CompareDso); 631 displayer.AddDisplayFunction("Target Shared Object", DisplayDso); 632 } else if (key == "symbol_from") { 633 comparator.AddCompareFunction(CompareSymbolFrom); 634 displayer.AddDisplayFunction("Source Symbol", DisplaySymbolFrom); 635 } else if (key == "symbol_to") { 636 comparator.AddCompareFunction(CompareSymbol); 637 displayer.AddDisplayFunction("Target Symbol", DisplaySymbol); 638 } else { 639 LOG(ERROR) << "Unknown sort key: " << key; 640 return false; 641 } 642 } 643 if (print_callgraph_) { 644 bool has_symbol_key = false; 645 bool has_vaddr_in_file_key = false; 646 for (const auto& key : sort_keys) { 647 if (key == "symbol") { 648 has_symbol_key = true; 649 } else if (key == "vaddr_in_file") { 650 has_vaddr_in_file_key = true; 651 } 652 } 653 if (has_symbol_key) { 654 if (has_vaddr_in_file_key) { 655 displayer.AddExclusiveDisplayFunction( 656 ReportCmdCallgraphDisplayerWithVaddrInFile()); 657 } else { 658 displayer.AddExclusiveDisplayFunction(ReportCmdCallgraphDisplayer( 659 callgraph_max_stack_, callgraph_percent_limit_, brief_callgraph_)); 660 } 661 } 662 } 663 664 sample_tree_builder_options_.comparator = comparator; 665 sample_tree_builder_options_.thread_tree = &thread_tree_; 666 667 SampleComparator<SampleEntry> sort_comparator; 668 sort_comparator.AddCompareFunction(CompareTotalPeriod); 669 if (print_callgraph_) { 670 sort_comparator.AddCompareFunction(CompareCallGraphDuplicated); 671 } 672 sort_comparator.AddCompareFunction(ComparePeriod); 673 sort_comparator.AddComparator(comparator); 674 sample_tree_sorter_.reset(new ReportCmdSampleTreeSorter(sort_comparator)); 675 sample_tree_displayer_.reset(new ReportCmdSampleTreeDisplayer(displayer)); 676 return true; 677 } 678 679 bool ReportCommand::ReadEventAttrFromRecordFile() { 680 std::vector<EventAttrWithId> attrs = record_file_reader_->AttrSection(); 681 for (const auto& attr_with_id : attrs) { 682 EventAttrWithName attr; 683 attr.attr = *attr_with_id.attr; 684 attr.name = GetEventNameByAttr(attr.attr); 685 event_attrs_.push_back(attr); 686 } 687 if (use_branch_address_) { 688 bool has_branch_stack = true; 689 for (const auto& attr : event_attrs_) { 690 if ((attr.attr.sample_type & PERF_SAMPLE_BRANCH_STACK) == 0) { 691 has_branch_stack = false; 692 break; 693 } 694 } 695 if (!has_branch_stack) { 696 LOG(ERROR) << record_filename_ 697 << " is not recorded with branch stack sampling option."; 698 return false; 699 } 700 } 701 return true; 702 } 703 704 bool ReportCommand::ReadFeaturesFromRecordFile() { 705 record_file_reader_->LoadBuildIdAndFileFeatures(thread_tree_); 706 707 std::string arch = 708 record_file_reader_->ReadFeatureString(PerfFileFormat::FEAT_ARCH); 709 if (!arch.empty()) { 710 record_file_arch_ = GetArchType(arch); 711 if (record_file_arch_ == ARCH_UNSUPPORTED) { 712 return false; 713 } 714 } 715 716 std::vector<std::string> cmdline = record_file_reader_->ReadCmdlineFeature(); 717 if (!cmdline.empty()) { 718 record_cmdline_ = android::base::Join(cmdline, ' '); 719 // TODO: the code to detect system wide collection option is fragile, remove 720 // it once we can do cross unwinding. 721 for (size_t i = 0; i < cmdline.size(); i++) { 722 std::string& s = cmdline[i]; 723 if (s == "-a") { 724 system_wide_collection_ = true; 725 break; 726 } else if (s == "--call-graph" || s == "--cpu" || s == "-e" || 727 s == "-f" || s == "-F" || s == "-j" || s == "-m" || 728 s == "-o" || s == "-p" || s == "-t") { 729 i++; 730 } else if (!s.empty() && s[0] != '-') { 731 break; 732 } 733 } 734 } 735 if (record_file_reader_->HasFeature(PerfFileFormat::FEAT_TRACING_DATA)) { 736 std::vector<char> tracing_data; 737 if (!record_file_reader_->ReadFeatureSection( 738 PerfFileFormat::FEAT_TRACING_DATA, &tracing_data)) { 739 return false; 740 } 741 if (!ProcessTracingData(tracing_data)) { 742 return false; 743 } 744 } 745 return true; 746 } 747 748 bool ReportCommand::ReadSampleTreeFromRecordFile() { 749 sample_tree_builder_options_.use_branch_address = use_branch_address_; 750 // Normally do strict arch check when unwinding stack. But allow unwinding 751 // 32-bit processes on 64-bit devices for system wide profiling. 752 sample_tree_builder_options_.strict_unwind_arch_check = !system_wide_collection_; 753 sample_tree_builder_options_.accumulate_callchain = accumulate_callchain_; 754 sample_tree_builder_options_.build_callchain = print_callgraph_; 755 sample_tree_builder_options_.use_caller_as_callchain_root = !callgraph_show_callee_; 756 757 for (size_t i = 0; i < event_attrs_.size(); ++i) { 758 sample_tree_builder_.push_back(sample_tree_builder_options_.CreateSampleTreeBuilder()); 759 } 760 761 if (!record_file_reader_->ReadDataSection( 762 [this](std::unique_ptr<Record> record) { 763 return ProcessRecord(std::move(record)); 764 })) { 765 return false; 766 } 767 for (size_t i = 0; i < sample_tree_builder_.size(); ++i) { 768 sample_tree_.push_back(sample_tree_builder_[i]->GetSampleTree()); 769 sample_tree_sorter_->Sort(sample_tree_.back().samples, print_callgraph_); 770 } 771 return true; 772 } 773 774 bool ReportCommand::ProcessRecord(std::unique_ptr<Record> record) { 775 thread_tree_.Update(*record); 776 if (record->type() == PERF_RECORD_SAMPLE) { 777 size_t attr_id = record_file_reader_->GetAttrIndexOfRecord(record.get()); 778 sample_tree_builder_[attr_id]->ProcessSampleRecord( 779 *static_cast<const SampleRecord*>(record.get())); 780 } else if (record->type() == PERF_RECORD_TRACING_DATA) { 781 const auto& r = *static_cast<TracingDataRecord*>(record.get()); 782 if (!ProcessTracingData(std::vector<char>(r.data, r.data + r.data_size))) { 783 return false; 784 } 785 } 786 return true; 787 } 788 789 bool ReportCommand::ProcessTracingData(const std::vector<char>& data) { 790 Tracing tracing(data); 791 for (auto& attr : event_attrs_) { 792 if (attr.attr.type == PERF_TYPE_TRACEPOINT) { 793 uint64_t trace_event_id = attr.attr.config; 794 attr.name = tracing.GetTracingEventNameHavingId(trace_event_id); 795 } 796 } 797 return true; 798 } 799 800 bool ReportCommand::PrintReport() { 801 std::unique_ptr<FILE, decltype(&fclose)> file_handler(nullptr, fclose); 802 FILE* report_fp = stdout; 803 if (!report_filename_.empty()) { 804 report_fp = fopen(report_filename_.c_str(), "w"); 805 if (report_fp == nullptr) { 806 PLOG(ERROR) << "failed to open file " << report_filename_; 807 return false; 808 } 809 file_handler.reset(report_fp); 810 } 811 PrintReportContext(report_fp); 812 for (size_t i = 0; i < event_attrs_.size(); ++i) { 813 if (i != 0) { 814 fprintf(report_fp, "\n"); 815 } 816 EventAttrWithName& attr = event_attrs_[i]; 817 SampleTree& sample_tree = sample_tree_[i]; 818 fprintf(report_fp, "Event: %s (type %u, config %llu)\n", attr.name.c_str(), 819 attr.attr.type, attr.attr.config); 820 fprintf(report_fp, "Samples: %" PRIu64 "\n", sample_tree.total_samples); 821 if (sample_tree.total_error_callchains != 0) { 822 fprintf(report_fp, "Error Callchains: %" PRIu64 ", %f%%\n", 823 sample_tree.total_error_callchains, 824 sample_tree.total_error_callchains * 100.0 / sample_tree.total_samples); 825 } 826 fprintf(report_fp, "Event count: %" PRIu64 "\n\n", sample_tree.total_period); 827 sample_tree_displayer_->DisplaySamples(report_fp, sample_tree.samples, &sample_tree); 828 } 829 fflush(report_fp); 830 if (ferror(report_fp) != 0) { 831 PLOG(ERROR) << "print report failed"; 832 return false; 833 } 834 return true; 835 } 836 837 void ReportCommand::PrintReportContext(FILE* report_fp) { 838 if (!record_cmdline_.empty()) { 839 fprintf(report_fp, "Cmdline: %s\n", record_cmdline_.c_str()); 840 } 841 fprintf(report_fp, "Arch: %s\n", GetArchString(record_file_arch_).c_str()); 842 } 843 844 } // namespace 845 846 void RegisterReportCommand() { 847 RegisterCommand("report", 848 [] { return std::unique_ptr<Command>(new ReportCommand()); }); 849 } 850
