1 /* 2 * builtin-report.c 3 * 4 * Builtin report command: Analyze the perf.data input file, 5 * look up and read DSOs and symbol information and display 6 * a histogram of results, along various sorting keys. 7 */ 8 #include "builtin.h" 9 10 #include "util/util.h" 11 #include "util/cache.h" 12 13 #include "util/annotate.h" 14 #include "util/color.h" 15 #include <linux/list.h> 16 #include <linux/rbtree.h> 17 #include "util/symbol.h" 18 #include "util/callchain.h" 19 #include "util/strlist.h" 20 #include "util/values.h" 21 22 #include "perf.h" 23 #include "util/debug.h" 24 #include "util/evlist.h" 25 #include "util/evsel.h" 26 #include "util/header.h" 27 #include "util/session.h" 28 #include "util/tool.h" 29 30 #include "util/parse-options.h" 31 #include "util/parse-events.h" 32 33 #include "util/thread.h" 34 #include "util/sort.h" 35 #include "util/hist.h" 36 #include "arch/common.h" 37 38 #include <linux/bitmap.h> 39 40 struct perf_report { 41 struct perf_tool tool; 42 struct perf_session *session; 43 bool force, use_tui, use_gtk, use_stdio; 44 bool hide_unresolved; 45 bool dont_use_callchains; 46 bool show_full_info; 47 bool show_threads; 48 bool inverted_callchain; 49 bool mem_mode; 50 struct perf_read_values show_threads_values; 51 const char *pretty_printing_style; 52 const char *cpu_list; 53 const char *symbol_filter_str; 54 float min_percent; 55 DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS); 56 }; 57 58 static int perf_report_config(const char *var, const char *value, void *cb) 59 { 60 if (!strcmp(var, "report.group")) { 61 symbol_conf.event_group = perf_config_bool(var, value); 62 return 0; 63 } 64 if (!strcmp(var, "report.percent-limit")) { 65 struct perf_report *rep = cb; 66 rep->min_percent = strtof(value, NULL); 67 return 0; 68 } 69 70 return perf_default_config(var, value, cb); 71 } 72 73 static int perf_report__add_mem_hist_entry(struct perf_tool *tool, 74 struct addr_location *al, 75 struct perf_sample *sample, 76 struct perf_evsel *evsel, 77 struct machine *machine, 78 union perf_event *event) 79 { 80 struct perf_report *rep = container_of(tool, struct perf_report, tool); 81 struct symbol *parent = NULL; 82 u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; 83 int err = 0; 84 struct hist_entry *he; 85 struct mem_info *mi, *mx; 86 uint64_t cost; 87 88 if ((sort__has_parent || symbol_conf.use_callchain) && 89 sample->callchain) { 90 err = machine__resolve_callchain(machine, evsel, al->thread, 91 sample, &parent, al); 92 if (err) 93 return err; 94 } 95 96 mi = machine__resolve_mem(machine, al->thread, sample, cpumode); 97 if (!mi) 98 return -ENOMEM; 99 100 if (rep->hide_unresolved && !al->sym) 101 return 0; 102 103 cost = sample->weight; 104 if (!cost) 105 cost = 1; 106 107 /* 108 * must pass period=weight in order to get the correct 109 * sorting from hists__collapse_resort() which is solely 110 * based on periods. We want sorting be done on nr_events * weight 111 * and this is indirectly achieved by passing period=weight here 112 * and the he_stat__add_period() function. 113 */ 114 he = __hists__add_mem_entry(&evsel->hists, al, parent, mi, cost, cost); 115 if (!he) 116 return -ENOMEM; 117 118 /* 119 * In the TUI browser, we are doing integrated annotation, 120 * so we don't allocate the extra space needed because the stdio 121 * code will not use it. 122 */ 123 if (sort__has_sym && he->ms.sym && use_browser > 0) { 124 struct annotation *notes = symbol__annotation(he->ms.sym); 125 126 assert(evsel != NULL); 127 128 if (notes->src == NULL && symbol__alloc_hist(he->ms.sym) < 0) 129 goto out; 130 131 err = hist_entry__inc_addr_samples(he, evsel->idx, al->addr); 132 if (err) 133 goto out; 134 } 135 136 if (sort__has_sym && he->mem_info->daddr.sym && use_browser > 0) { 137 struct annotation *notes; 138 139 mx = he->mem_info; 140 141 notes = symbol__annotation(mx->daddr.sym); 142 if (notes->src == NULL && symbol__alloc_hist(mx->daddr.sym) < 0) 143 goto out; 144 145 err = symbol__inc_addr_samples(mx->daddr.sym, 146 mx->daddr.map, 147 evsel->idx, 148 mx->daddr.al_addr); 149 if (err) 150 goto out; 151 } 152 153 evsel->hists.stats.total_period += cost; 154 hists__inc_nr_events(&evsel->hists, PERF_RECORD_SAMPLE); 155 err = 0; 156 157 if (symbol_conf.use_callchain) { 158 err = callchain_append(he->callchain, 159 &callchain_cursor, 160 sample->period); 161 } 162 out: 163 return err; 164 } 165 166 static int perf_report__add_branch_hist_entry(struct perf_tool *tool, 167 struct addr_location *al, 168 struct perf_sample *sample, 169 struct perf_evsel *evsel, 170 struct machine *machine) 171 { 172 struct perf_report *rep = container_of(tool, struct perf_report, tool); 173 struct symbol *parent = NULL; 174 int err = 0; 175 unsigned i; 176 struct hist_entry *he; 177 struct branch_info *bi, *bx; 178 179 if ((sort__has_parent || symbol_conf.use_callchain) 180 && sample->callchain) { 181 err = machine__resolve_callchain(machine, evsel, al->thread, 182 sample, &parent, al); 183 if (err) 184 return err; 185 } 186 187 bi = machine__resolve_bstack(machine, al->thread, 188 sample->branch_stack); 189 if (!bi) 190 return -ENOMEM; 191 192 for (i = 0; i < sample->branch_stack->nr; i++) { 193 if (rep->hide_unresolved && !(bi[i].from.sym && bi[i].to.sym)) 194 continue; 195 196 err = -ENOMEM; 197 198 /* 199 * The report shows the percentage of total branches captured 200 * and not events sampled. Thus we use a pseudo period of 1. 201 */ 202 he = __hists__add_branch_entry(&evsel->hists, al, parent, 203 &bi[i], 1, 1); 204 if (he) { 205 struct annotation *notes; 206 bx = he->branch_info; 207 if (bx->from.sym && use_browser == 1 && sort__has_sym) { 208 notes = symbol__annotation(bx->from.sym); 209 if (!notes->src 210 && symbol__alloc_hist(bx->from.sym) < 0) 211 goto out; 212 213 err = symbol__inc_addr_samples(bx->from.sym, 214 bx->from.map, 215 evsel->idx, 216 bx->from.al_addr); 217 if (err) 218 goto out; 219 } 220 221 if (bx->to.sym && use_browser == 1 && sort__has_sym) { 222 notes = symbol__annotation(bx->to.sym); 223 if (!notes->src 224 && symbol__alloc_hist(bx->to.sym) < 0) 225 goto out; 226 227 err = symbol__inc_addr_samples(bx->to.sym, 228 bx->to.map, 229 evsel->idx, 230 bx->to.al_addr); 231 if (err) 232 goto out; 233 } 234 evsel->hists.stats.total_period += 1; 235 hists__inc_nr_events(&evsel->hists, PERF_RECORD_SAMPLE); 236 } else 237 goto out; 238 } 239 err = 0; 240 out: 241 free(bi); 242 return err; 243 } 244 245 static int perf_evsel__add_hist_entry(struct perf_evsel *evsel, 246 struct addr_location *al, 247 struct perf_sample *sample, 248 struct machine *machine) 249 { 250 struct symbol *parent = NULL; 251 int err = 0; 252 struct hist_entry *he; 253 254 if ((sort__has_parent || symbol_conf.use_callchain) && sample->callchain) { 255 err = machine__resolve_callchain(machine, evsel, al->thread, 256 sample, &parent, al); 257 if (err) 258 return err; 259 } 260 261 he = __hists__add_entry(&evsel->hists, al, parent, sample->period, 262 sample->weight); 263 if (he == NULL) 264 return -ENOMEM; 265 266 if (symbol_conf.use_callchain) { 267 err = callchain_append(he->callchain, 268 &callchain_cursor, 269 sample->period); 270 if (err) 271 return err; 272 } 273 /* 274 * Only in the TUI browser we are doing integrated annotation, 275 * so we don't allocated the extra space needed because the stdio 276 * code will not use it. 277 */ 278 if (he->ms.sym != NULL && use_browser == 1 && sort__has_sym) { 279 struct annotation *notes = symbol__annotation(he->ms.sym); 280 281 assert(evsel != NULL); 282 283 err = -ENOMEM; 284 if (notes->src == NULL && symbol__alloc_hist(he->ms.sym) < 0) 285 goto out; 286 287 err = hist_entry__inc_addr_samples(he, evsel->idx, al->addr); 288 } 289 290 evsel->hists.stats.total_period += sample->period; 291 hists__inc_nr_events(&evsel->hists, PERF_RECORD_SAMPLE); 292 out: 293 return err; 294 } 295 296 297 static int process_sample_event(struct perf_tool *tool, 298 union perf_event *event, 299 struct perf_sample *sample, 300 struct perf_evsel *evsel, 301 struct machine *machine) 302 { 303 struct perf_report *rep = container_of(tool, struct perf_report, tool); 304 struct addr_location al; 305 int ret; 306 307 if (perf_event__preprocess_sample(event, machine, &al, sample) < 0) { 308 fprintf(stderr, "problem processing %d event, skipping it.\n", 309 event->header.type); 310 return -1; 311 } 312 313 if (al.filtered || (rep->hide_unresolved && al.sym == NULL)) 314 return 0; 315 316 if (rep->cpu_list && !test_bit(sample->cpu, rep->cpu_bitmap)) 317 return 0; 318 319 if (sort__mode == SORT_MODE__BRANCH) { 320 ret = perf_report__add_branch_hist_entry(tool, &al, sample, 321 evsel, machine); 322 if (ret < 0) 323 pr_debug("problem adding lbr entry, skipping event\n"); 324 } else if (rep->mem_mode == 1) { 325 ret = perf_report__add_mem_hist_entry(tool, &al, sample, 326 evsel, machine, event); 327 if (ret < 0) 328 pr_debug("problem adding mem entry, skipping event\n"); 329 } else { 330 if (al.map != NULL) 331 al.map->dso->hit = 1; 332 333 ret = perf_evsel__add_hist_entry(evsel, &al, sample, machine); 334 if (ret < 0) 335 pr_debug("problem incrementing symbol period, skipping event\n"); 336 } 337 return ret; 338 } 339 340 static int process_read_event(struct perf_tool *tool, 341 union perf_event *event, 342 struct perf_sample *sample __maybe_unused, 343 struct perf_evsel *evsel, 344 struct machine *machine __maybe_unused) 345 { 346 struct perf_report *rep = container_of(tool, struct perf_report, tool); 347 348 if (rep->show_threads) { 349 const char *name = evsel ? perf_evsel__name(evsel) : "unknown"; 350 perf_read_values_add_value(&rep->show_threads_values, 351 event->read.pid, event->read.tid, 352 event->read.id, 353 name, 354 event->read.value); 355 } 356 357 dump_printf(": %d %d %s %" PRIu64 "\n", event->read.pid, event->read.tid, 358 evsel ? perf_evsel__name(evsel) : "FAIL", 359 event->read.value); 360 361 return 0; 362 } 363 364 /* For pipe mode, sample_type is not currently set */ 365 static int perf_report__setup_sample_type(struct perf_report *rep) 366 { 367 struct perf_session *self = rep->session; 368 u64 sample_type = perf_evlist__combined_sample_type(self->evlist); 369 370 if (!self->fd_pipe && !(sample_type & PERF_SAMPLE_CALLCHAIN)) { 371 if (sort__has_parent) { 372 ui__error("Selected --sort parent, but no " 373 "callchain data. Did you call " 374 "'perf record' without -g?\n"); 375 return -EINVAL; 376 } 377 if (symbol_conf.use_callchain) { 378 ui__error("Selected -g but no callchain data. Did " 379 "you call 'perf record' without -g?\n"); 380 return -1; 381 } 382 } else if (!rep->dont_use_callchains && 383 callchain_param.mode != CHAIN_NONE && 384 !symbol_conf.use_callchain) { 385 symbol_conf.use_callchain = true; 386 if (callchain_register_param(&callchain_param) < 0) { 387 ui__error("Can't register callchain params.\n"); 388 return -EINVAL; 389 } 390 } 391 392 if (sort__mode == SORT_MODE__BRANCH) { 393 if (!self->fd_pipe && 394 !(sample_type & PERF_SAMPLE_BRANCH_STACK)) { 395 ui__error("Selected -b but no branch data. " 396 "Did you call perf record without -b?\n"); 397 return -1; 398 } 399 } 400 401 return 0; 402 } 403 404 static void sig_handler(int sig __maybe_unused) 405 { 406 session_done = 1; 407 } 408 409 static size_t hists__fprintf_nr_sample_events(struct perf_report *rep, 410 struct hists *self, 411 const char *evname, FILE *fp) 412 { 413 size_t ret; 414 char unit; 415 unsigned long nr_samples = self->stats.nr_events[PERF_RECORD_SAMPLE]; 416 u64 nr_events = self->stats.total_period; 417 struct perf_evsel *evsel = hists_to_evsel(self); 418 char buf[512]; 419 size_t size = sizeof(buf); 420 421 if (perf_evsel__is_group_event(evsel)) { 422 struct perf_evsel *pos; 423 424 perf_evsel__group_desc(evsel, buf, size); 425 evname = buf; 426 427 for_each_group_member(pos, evsel) { 428 nr_samples += pos->hists.stats.nr_events[PERF_RECORD_SAMPLE]; 429 nr_events += pos->hists.stats.total_period; 430 } 431 } 432 433 nr_samples = convert_unit(nr_samples, &unit); 434 ret = fprintf(fp, "# Samples: %lu%c", nr_samples, unit); 435 if (evname != NULL) 436 ret += fprintf(fp, " of event '%s'", evname); 437 438 if (rep->mem_mode) { 439 ret += fprintf(fp, "\n# Total weight : %" PRIu64, nr_events); 440 ret += fprintf(fp, "\n# Sort order : %s", sort_order); 441 } else 442 ret += fprintf(fp, "\n# Event count (approx.): %" PRIu64, nr_events); 443 return ret + fprintf(fp, "\n#\n"); 444 } 445 446 static int perf_evlist__tty_browse_hists(struct perf_evlist *evlist, 447 struct perf_report *rep, 448 const char *help) 449 { 450 struct perf_evsel *pos; 451 452 list_for_each_entry(pos, &evlist->entries, node) { 453 struct hists *hists = &pos->hists; 454 const char *evname = perf_evsel__name(pos); 455 456 if (symbol_conf.event_group && 457 !perf_evsel__is_group_leader(pos)) 458 continue; 459 460 hists__fprintf_nr_sample_events(rep, hists, evname, stdout); 461 hists__fprintf(hists, true, 0, 0, rep->min_percent, stdout); 462 fprintf(stdout, "\n\n"); 463 } 464 465 if (sort_order == default_sort_order && 466 parent_pattern == default_parent_pattern) { 467 fprintf(stdout, "#\n# (%s)\n#\n", help); 468 469 if (rep->show_threads) { 470 bool style = !strcmp(rep->pretty_printing_style, "raw"); 471 perf_read_values_display(stdout, &rep->show_threads_values, 472 style); 473 perf_read_values_destroy(&rep->show_threads_values); 474 } 475 } 476 477 return 0; 478 } 479 480 static int __cmd_report(struct perf_report *rep) 481 { 482 int ret = -EINVAL; 483 u64 nr_samples; 484 struct perf_session *session = rep->session; 485 struct perf_evsel *pos; 486 struct map *kernel_map; 487 struct kmap *kernel_kmap; 488 const char *help = "For a higher level overview, try: perf report --sort comm,dso"; 489 490 signal(SIGINT, sig_handler); 491 492 if (rep->cpu_list) { 493 ret = perf_session__cpu_bitmap(session, rep->cpu_list, 494 rep->cpu_bitmap); 495 if (ret) 496 return ret; 497 } 498 499 if (use_browser <= 0) 500 perf_session__fprintf_info(session, stdout, rep->show_full_info); 501 502 if (rep->show_threads) 503 perf_read_values_init(&rep->show_threads_values); 504 505 ret = perf_report__setup_sample_type(rep); 506 if (ret) 507 return ret; 508 509 ret = perf_session__process_events(session, &rep->tool); 510 if (ret) 511 return ret; 512 513 kernel_map = session->machines.host.vmlinux_maps[MAP__FUNCTION]; 514 kernel_kmap = map__kmap(kernel_map); 515 if (kernel_map == NULL || 516 (kernel_map->dso->hit && 517 (kernel_kmap->ref_reloc_sym == NULL || 518 kernel_kmap->ref_reloc_sym->addr == 0))) { 519 const char *desc = 520 "As no suitable kallsyms nor vmlinux was found, kernel samples\n" 521 "can't be resolved."; 522 523 if (kernel_map) { 524 const struct dso *kdso = kernel_map->dso; 525 if (!RB_EMPTY_ROOT(&kdso->symbols[MAP__FUNCTION])) { 526 desc = "If some relocation was applied (e.g. " 527 "kexec) symbols may be misresolved."; 528 } 529 } 530 531 ui__warning( 532 "Kernel address maps (/proc/{kallsyms,modules}) were restricted.\n\n" 533 "Check /proc/sys/kernel/kptr_restrict before running 'perf record'.\n\n%s\n\n" 534 "Samples in kernel modules can't be resolved as well.\n\n", 535 desc); 536 } 537 538 if (verbose > 3) 539 perf_session__fprintf(session, stdout); 540 541 if (verbose > 2) 542 perf_session__fprintf_dsos(session, stdout); 543 544 if (dump_trace) { 545 perf_session__fprintf_nr_events(session, stdout); 546 return 0; 547 } 548 549 nr_samples = 0; 550 list_for_each_entry(pos, &session->evlist->entries, node) { 551 struct hists *hists = &pos->hists; 552 553 if (pos->idx == 0) 554 hists->symbol_filter_str = rep->symbol_filter_str; 555 556 hists__collapse_resort(hists); 557 nr_samples += hists->stats.nr_events[PERF_RECORD_SAMPLE]; 558 559 /* Non-group events are considered as leader */ 560 if (symbol_conf.event_group && 561 !perf_evsel__is_group_leader(pos)) { 562 struct hists *leader_hists = &pos->leader->hists; 563 564 hists__match(leader_hists, hists); 565 hists__link(leader_hists, hists); 566 } 567 } 568 569 if (session_done()) 570 return 0; 571 572 if (nr_samples == 0) { 573 ui__error("The %s file has no samples!\n", session->filename); 574 return 0; 575 } 576 577 list_for_each_entry(pos, &session->evlist->entries, node) 578 hists__output_resort(&pos->hists); 579 580 if (use_browser > 0) { 581 if (use_browser == 1) { 582 ret = perf_evlist__tui_browse_hists(session->evlist, 583 help, NULL, 584 rep->min_percent, 585 &session->header.env); 586 /* 587 * Usually "ret" is the last pressed key, and we only 588 * care if the key notifies us to switch data file. 589 */ 590 if (ret != K_SWITCH_INPUT_DATA) 591 ret = 0; 592 593 } else if (use_browser == 2) { 594 perf_evlist__gtk_browse_hists(session->evlist, help, 595 NULL, rep->min_percent); 596 } 597 } else 598 perf_evlist__tty_browse_hists(session->evlist, rep, help); 599 600 return ret; 601 } 602 603 static int 604 parse_callchain_opt(const struct option *opt, const char *arg, int unset) 605 { 606 struct perf_report *rep = (struct perf_report *)opt->value; 607 char *tok, *tok2; 608 char *endptr; 609 610 /* 611 * --no-call-graph 612 */ 613 if (unset) { 614 rep->dont_use_callchains = true; 615 return 0; 616 } 617 618 symbol_conf.use_callchain = true; 619 620 if (!arg) 621 return 0; 622 623 tok = strtok((char *)arg, ","); 624 if (!tok) 625 return -1; 626 627 /* get the output mode */ 628 if (!strncmp(tok, "graph", strlen(arg))) 629 callchain_param.mode = CHAIN_GRAPH_ABS; 630 631 else if (!strncmp(tok, "flat", strlen(arg))) 632 callchain_param.mode = CHAIN_FLAT; 633 634 else if (!strncmp(tok, "fractal", strlen(arg))) 635 callchain_param.mode = CHAIN_GRAPH_REL; 636 637 else if (!strncmp(tok, "none", strlen(arg))) { 638 callchain_param.mode = CHAIN_NONE; 639 symbol_conf.use_callchain = false; 640 641 return 0; 642 } 643 644 else 645 return -1; 646 647 /* get the min percentage */ 648 tok = strtok(NULL, ","); 649 if (!tok) 650 goto setup; 651 652 callchain_param.min_percent = strtod(tok, &endptr); 653 if (tok == endptr) 654 return -1; 655 656 /* get the print limit */ 657 tok2 = strtok(NULL, ","); 658 if (!tok2) 659 goto setup; 660 661 if (tok2[0] != 'c') { 662 callchain_param.print_limit = strtoul(tok2, &endptr, 0); 663 tok2 = strtok(NULL, ","); 664 if (!tok2) 665 goto setup; 666 } 667 668 /* get the call chain order */ 669 if (!strncmp(tok2, "caller", strlen("caller"))) 670 callchain_param.order = ORDER_CALLER; 671 else if (!strncmp(tok2, "callee", strlen("callee"))) 672 callchain_param.order = ORDER_CALLEE; 673 else 674 return -1; 675 676 /* Get the sort key */ 677 tok2 = strtok(NULL, ","); 678 if (!tok2) 679 goto setup; 680 if (!strncmp(tok2, "function", strlen("function"))) 681 callchain_param.key = CCKEY_FUNCTION; 682 else if (!strncmp(tok2, "address", strlen("address"))) 683 callchain_param.key = CCKEY_ADDRESS; 684 else 685 return -1; 686 setup: 687 if (callchain_register_param(&callchain_param) < 0) { 688 fprintf(stderr, "Can't register callchain params\n"); 689 return -1; 690 } 691 return 0; 692 } 693 694 int 695 report_parse_ignore_callees_opt(const struct option *opt __maybe_unused, 696 const char *arg, int unset __maybe_unused) 697 { 698 if (arg) { 699 int err = regcomp(&ignore_callees_regex, arg, REG_EXTENDED); 700 if (err) { 701 char buf[BUFSIZ]; 702 regerror(err, &ignore_callees_regex, buf, sizeof(buf)); 703 pr_err("Invalid --ignore-callees regex: %s\n%s", arg, buf); 704 return -1; 705 } 706 have_ignore_callees = 1; 707 } 708 709 return 0; 710 } 711 712 static int 713 parse_branch_mode(const struct option *opt __maybe_unused, 714 const char *str __maybe_unused, int unset) 715 { 716 int *branch_mode = opt->value; 717 718 *branch_mode = !unset; 719 return 0; 720 } 721 722 static int 723 parse_percent_limit(const struct option *opt, const char *str, 724 int unset __maybe_unused) 725 { 726 struct perf_report *rep = opt->value; 727 728 rep->min_percent = strtof(str, NULL); 729 return 0; 730 } 731 732 int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused) 733 { 734 struct perf_session *session; 735 struct stat st; 736 bool has_br_stack = false; 737 int branch_mode = -1; 738 int ret = -1; 739 char callchain_default_opt[] = "fractal,0.5,callee"; 740 const char * const report_usage[] = { 741 "perf report [<options>]", 742 NULL 743 }; 744 struct perf_report report = { 745 .tool = { 746 .sample = process_sample_event, 747 .mmap = perf_event__process_mmap, 748 .mmap2 = perf_event__process_mmap2, 749 .comm = perf_event__process_comm, 750 .exit = perf_event__process_exit, 751 .fork = perf_event__process_fork, 752 .lost = perf_event__process_lost, 753 .read = process_read_event, 754 .attr = perf_event__process_attr, 755 .tracing_data = perf_event__process_tracing_data, 756 .build_id = perf_event__process_build_id, 757 .ordered_samples = true, 758 .ordering_requires_timestamps = true, 759 }, 760 .pretty_printing_style = "normal", 761 }; 762 const struct option options[] = { 763 OPT_STRING('i', "input", &input_name, "file", 764 "input file name"), 765 OPT_INCR('v', "verbose", &verbose, 766 "be more verbose (show symbol address, etc)"), 767 OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace, 768 "dump raw trace in ASCII"), 769 OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name, 770 "file", "vmlinux pathname"), 771 OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name, 772 "file", "kallsyms pathname"), 773 OPT_BOOLEAN('f', "force", &report.force, "don't complain, do it"), 774 OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules, 775 "load module symbols - WARNING: use only with -k and LIVE kernel"), 776 OPT_BOOLEAN('n', "show-nr-samples", &symbol_conf.show_nr_samples, 777 "Show a column with the number of samples"), 778 OPT_BOOLEAN('T', "threads", &report.show_threads, 779 "Show per-thread event counters"), 780 OPT_STRING(0, "pretty", &report.pretty_printing_style, "key", 781 "pretty printing style key: normal raw"), 782 OPT_BOOLEAN(0, "tui", &report.use_tui, "Use the TUI interface"), 783 OPT_BOOLEAN(0, "gtk", &report.use_gtk, "Use the GTK2 interface"), 784 OPT_BOOLEAN(0, "stdio", &report.use_stdio, 785 "Use the stdio interface"), 786 OPT_STRING('s', "sort", &sort_order, "key[,key2...]", 787 "sort by key(s): pid, comm, dso, symbol, parent, cpu, srcline," 788 " dso_to, dso_from, symbol_to, symbol_from, mispredict," 789 " weight, local_weight, mem, symbol_daddr, dso_daddr, tlb, " 790 "snoop, locked"), 791 OPT_BOOLEAN(0, "showcpuutilization", &symbol_conf.show_cpu_utilization, 792 "Show sample percentage for different cpu modes"), 793 OPT_STRING('p', "parent", &parent_pattern, "regex", 794 "regex filter to identify parent, see: '--sort parent'"), 795 OPT_BOOLEAN('x', "exclude-other", &symbol_conf.exclude_other, 796 "Only display entries with parent-match"), 797 OPT_CALLBACK_DEFAULT('g', "call-graph", &report, "output_type,min_percent[,print_limit],call_order", 798 "Display callchains using output_type (graph, flat, fractal, or none) , min percent threshold, optional print limit, callchain order, key (function or address). " 799 "Default: fractal,0.5,callee,function", &parse_callchain_opt, callchain_default_opt), 800 OPT_BOOLEAN('G', "inverted", &report.inverted_callchain, 801 "alias for inverted call graph"), 802 OPT_CALLBACK(0, "ignore-callees", NULL, "regex", 803 "ignore callees of these functions in call graphs", 804 report_parse_ignore_callees_opt), 805 OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]", 806 "only consider symbols in these dsos"), 807 OPT_STRING('c', "comms", &symbol_conf.comm_list_str, "comm[,comm...]", 808 "only consider symbols in these comms"), 809 OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]", 810 "only consider these symbols"), 811 OPT_STRING(0, "symbol-filter", &report.symbol_filter_str, "filter", 812 "only show symbols that (partially) match with this filter"), 813 OPT_STRING('w', "column-widths", &symbol_conf.col_width_list_str, 814 "width[,width...]", 815 "don't try to adjust column width, use these fixed values"), 816 OPT_STRING('t', "field-separator", &symbol_conf.field_sep, "separator", 817 "separator for columns, no spaces will be added between " 818 "columns '.' is reserved."), 819 OPT_BOOLEAN('U', "hide-unresolved", &report.hide_unresolved, 820 "Only display entries resolved to a symbol"), 821 OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory", 822 "Look for files with symbols relative to this directory"), 823 OPT_STRING('C', "cpu", &report.cpu_list, "cpu", 824 "list of cpus to profile"), 825 OPT_BOOLEAN('I', "show-info", &report.show_full_info, 826 "Display extended information about perf.data file"), 827 OPT_BOOLEAN(0, "source", &symbol_conf.annotate_src, 828 "Interleave source code with assembly code (default)"), 829 OPT_BOOLEAN(0, "asm-raw", &symbol_conf.annotate_asm_raw, 830 "Display raw encoding of assembly instructions (default)"), 831 OPT_STRING('M', "disassembler-style", &disassembler_style, "disassembler style", 832 "Specify disassembler style (e.g. -M intel for intel syntax)"), 833 OPT_BOOLEAN(0, "show-total-period", &symbol_conf.show_total_period, 834 "Show a column with the sum of periods"), 835 OPT_BOOLEAN(0, "group", &symbol_conf.event_group, 836 "Show event group information together"), 837 OPT_CALLBACK_NOOPT('b', "branch-stack", &branch_mode, "", 838 "use branch records for histogram filling", parse_branch_mode), 839 OPT_STRING(0, "objdump", &objdump_path, "path", 840 "objdump binary to use for disassembly and annotations"), 841 OPT_BOOLEAN(0, "demangle", &symbol_conf.demangle, 842 "Disable symbol demangling"), 843 OPT_BOOLEAN(0, "mem-mode", &report.mem_mode, "mem access profile"), 844 OPT_CALLBACK(0, "percent-limit", &report, "percent", 845 "Don't show entries under that percent", parse_percent_limit), 846 OPT_END() 847 }; 848 849 perf_config(perf_report_config, &report); 850 851 argc = parse_options(argc, argv, options, report_usage, 0); 852 853 if (report.use_stdio) 854 use_browser = 0; 855 else if (report.use_tui) 856 use_browser = 1; 857 else if (report.use_gtk) 858 use_browser = 2; 859 860 if (report.inverted_callchain) 861 callchain_param.order = ORDER_CALLER; 862 863 if (!input_name || !strlen(input_name)) { 864 if (!fstat(STDIN_FILENO, &st) && S_ISFIFO(st.st_mode)) 865 input_name = "-"; 866 else 867 input_name = "perf.data"; 868 } 869 870 if (strcmp(input_name, "-") != 0) 871 setup_browser(true); 872 else { 873 use_browser = 0; 874 perf_hpp__init(); 875 } 876 877 repeat: 878 session = perf_session__new(input_name, O_RDONLY, 879 report.force, false, &report.tool); 880 if (session == NULL) 881 return -ENOMEM; 882 883 report.session = session; 884 885 has_br_stack = perf_header__has_feat(&session->header, 886 HEADER_BRANCH_STACK); 887 888 if (branch_mode == -1 && has_br_stack) 889 sort__mode = SORT_MODE__BRANCH; 890 891 /* sort__mode could be NORMAL if --no-branch-stack */ 892 if (sort__mode == SORT_MODE__BRANCH) { 893 /* 894 * if no sort_order is provided, then specify 895 * branch-mode specific order 896 */ 897 if (sort_order == default_sort_order) 898 sort_order = "comm,dso_from,symbol_from," 899 "dso_to,symbol_to"; 900 901 } 902 if (report.mem_mode) { 903 if (sort__mode == SORT_MODE__BRANCH) { 904 fprintf(stderr, "branch and mem mode incompatible\n"); 905 goto error; 906 } 907 sort__mode = SORT_MODE__MEMORY; 908 909 /* 910 * if no sort_order is provided, then specify 911 * branch-mode specific order 912 */ 913 if (sort_order == default_sort_order) 914 sort_order = "local_weight,mem,sym,dso,symbol_daddr,dso_daddr,snoop,tlb,locked"; 915 } 916 917 if (setup_sorting() < 0) 918 usage_with_options(report_usage, options); 919 920 /* 921 * Only in the TUI browser we are doing integrated annotation, 922 * so don't allocate extra space that won't be used in the stdio 923 * implementation. 924 */ 925 if (use_browser == 1 && sort__has_sym) { 926 symbol_conf.priv_size = sizeof(struct annotation); 927 machines__set_symbol_filter(&session->machines, 928 symbol__annotate_init); 929 /* 930 * For searching by name on the "Browse map details". 931 * providing it only in verbose mode not to bloat too 932 * much struct symbol. 933 */ 934 if (verbose) { 935 /* 936 * XXX: Need to provide a less kludgy way to ask for 937 * more space per symbol, the u32 is for the index on 938 * the ui browser. 939 * See symbol__browser_index. 940 */ 941 symbol_conf.priv_size += sizeof(u32); 942 symbol_conf.sort_by_name = true; 943 } 944 } 945 946 if (symbol__init() < 0) 947 goto error; 948 949 if (parent_pattern != default_parent_pattern) { 950 if (sort_dimension__add("parent") < 0) 951 goto error; 952 } 953 954 if (argc) { 955 /* 956 * Special case: if there's an argument left then assume that 957 * it's a symbol filter: 958 */ 959 if (argc > 1) 960 usage_with_options(report_usage, options); 961 962 report.symbol_filter_str = argv[0]; 963 } 964 965 sort__setup_elide(stdout); 966 967 ret = __cmd_report(&report); 968 if (ret == K_SWITCH_INPUT_DATA) { 969 perf_session__delete(session); 970 goto repeat; 971 } else 972 ret = 0; 973 974 error: 975 perf_session__delete(session); 976 return ret; 977 } 978
