1853 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * builtin-report.c4 *5 * Builtin report command: Analyze the perf.data input file,6 * look up and read DSOs and symbol information and display7 * a histogram of results, along various sorting keys.8 */9#include "builtin.h"10 11#include "util/config.h"12 13#include "util/annotate.h"14#include "util/color.h"15#include "util/dso.h"16#include <linux/list.h>17#include <linux/rbtree.h>18#include <linux/err.h>19#include <linux/zalloc.h>20#include "util/map.h"21#include "util/symbol.h"22#include "util/map_symbol.h"23#include "util/mem-events.h"24#include "util/branch.h"25#include "util/callchain.h"26#include "util/values.h"27 28#include "perf.h"29#include "util/debug.h"30#include "util/evlist.h"31#include "util/evsel.h"32#include "util/evswitch.h"33#include "util/header.h"34#include "util/mem-info.h"35#include "util/session.h"36#include "util/srcline.h"37#include "util/tool.h"38 39#include <subcmd/parse-options.h>40#include <subcmd/exec-cmd.h>41#include "util/parse-events.h"42 43#include "util/thread.h"44#include "util/sort.h"45#include "util/hist.h"46#include "util/data.h"47#include "arch/common.h"48#include "util/time-utils.h"49#include "util/auxtrace.h"50#include "util/units.h"51#include "util/util.h" // perf_tip()52#include "ui/ui.h"53#include "ui/progress.h"54#include "util/block-info.h"55 56#include <dlfcn.h>57#include <errno.h>58#include <inttypes.h>59#include <regex.h>60#include <linux/ctype.h>61#include <signal.h>62#include <linux/bitmap.h>63#include <linux/list_sort.h>64#include <linux/string.h>65#include <linux/stringify.h>66#include <linux/time64.h>67#include <sys/types.h>68#include <sys/stat.h>69#include <unistd.h>70#include <linux/mman.h>71 72#ifdef HAVE_LIBTRACEEVENT73#include <traceevent/event-parse.h>74#endif75 76struct report {77 struct perf_tool tool;78 struct perf_session *session;79 struct evswitch evswitch;80#ifdef HAVE_SLANG_SUPPORT81 bool use_tui;82#endif83#ifdef HAVE_GTK2_SUPPORT84 bool use_gtk;85#endif86 bool use_stdio;87 bool show_full_info;88 bool show_threads;89 bool inverted_callchain;90 bool mem_mode;91 bool stats_mode;92 bool tasks_mode;93 bool mmaps_mode;94 bool header;95 bool header_only;96 bool nonany_branch_mode;97 bool group_set;98 bool stitch_lbr;99 bool disable_order;100 bool skip_empty;101 bool data_type;102 int max_stack;103 struct perf_read_values show_threads_values;104 const char *pretty_printing_style;105 const char *cpu_list;106 const char *symbol_filter_str;107 const char *time_str;108 struct perf_time_interval *ptime_range;109 int range_size;110 int range_num;111 float min_percent;112 u64 nr_entries;113 u64 queue_size;114 u64 total_cycles;115 int socket_filter;116 DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);117 struct branch_type_stat brtype_stat;118 bool symbol_ipc;119 bool total_cycles_mode;120 struct block_report *block_reports;121 int nr_block_reports;122};123 124static int report__config(const char *var, const char *value, void *cb)125{126 struct report *rep = cb;127 128 if (!strcmp(var, "report.group")) {129 symbol_conf.event_group = perf_config_bool(var, value);130 return 0;131 }132 if (!strcmp(var, "report.percent-limit")) {133 double pcnt = strtof(value, NULL);134 135 rep->min_percent = pcnt;136 callchain_param.min_percent = pcnt;137 return 0;138 }139 if (!strcmp(var, "report.children")) {140 symbol_conf.cumulate_callchain = perf_config_bool(var, value);141 return 0;142 }143 if (!strcmp(var, "report.queue-size"))144 return perf_config_u64(&rep->queue_size, var, value);145 146 if (!strcmp(var, "report.sort_order")) {147 default_sort_order = strdup(value);148 if (!default_sort_order) {149 pr_err("Not enough memory for report.sort_order\n");150 return -1;151 }152 return 0;153 }154 155 if (!strcmp(var, "report.skip-empty")) {156 rep->skip_empty = perf_config_bool(var, value);157 return 0;158 }159 160 pr_debug("%s variable unknown, ignoring...", var);161 return 0;162}163 164static int hist_iter__report_callback(struct hist_entry_iter *iter,165 struct addr_location *al, bool single,166 void *arg)167{168 int err = 0;169 struct report *rep = arg;170 struct hist_entry *he = iter->he;171 struct evsel *evsel = iter->evsel;172 struct perf_sample *sample = iter->sample;173 struct mem_info *mi;174 struct branch_info *bi;175 176 if (!ui__has_annotation() && !rep->symbol_ipc)177 return 0;178 179 if (sort__mode == SORT_MODE__BRANCH) {180 bi = he->branch_info;181 err = addr_map_symbol__inc_samples(&bi->from, sample, evsel);182 if (err)183 goto out;184 185 err = addr_map_symbol__inc_samples(&bi->to, sample, evsel);186 187 } else if (rep->mem_mode) {188 mi = he->mem_info;189 err = addr_map_symbol__inc_samples(mem_info__daddr(mi), sample, evsel);190 if (err)191 goto out;192 193 err = hist_entry__inc_addr_samples(he, sample, evsel, al->addr);194 195 } else if (symbol_conf.cumulate_callchain) {196 if (single)197 err = hist_entry__inc_addr_samples(he, sample, evsel, al->addr);198 } else {199 err = hist_entry__inc_addr_samples(he, sample, evsel, al->addr);200 }201 202out:203 return err;204}205 206static int hist_iter__branch_callback(struct hist_entry_iter *iter,207 struct addr_location *al __maybe_unused,208 bool single __maybe_unused,209 void *arg)210{211 struct hist_entry *he = iter->he;212 struct report *rep = arg;213 struct branch_info *bi = he->branch_info;214 struct perf_sample *sample = iter->sample;215 struct evsel *evsel = iter->evsel;216 int err;217 218 branch_type_count(&rep->brtype_stat, &bi->flags,219 bi->from.addr, bi->to.addr);220 221 if (!ui__has_annotation() && !rep->symbol_ipc)222 return 0;223 224 err = addr_map_symbol__inc_samples(&bi->from, sample, evsel);225 if (err)226 goto out;227 228 err = addr_map_symbol__inc_samples(&bi->to, sample, evsel);229 230out:231 return err;232}233 234static void setup_forced_leader(struct report *report,235 struct evlist *evlist)236{237 if (report->group_set)238 evlist__force_leader(evlist);239}240 241static int process_feature_event(struct perf_session *session,242 union perf_event *event)243{244 struct report *rep = container_of(session->tool, struct report, tool);245 246 if (event->feat.feat_id < HEADER_LAST_FEATURE)247 return perf_event__process_feature(session, event);248 249 if (event->feat.feat_id != HEADER_LAST_FEATURE) {250 pr_err("failed: wrong feature ID: %" PRI_lu64 "\n",251 event->feat.feat_id);252 return -1;253 } else if (rep->header_only) {254 session_done = 1;255 }256 257 /*258 * (feat_id = HEADER_LAST_FEATURE) is the end marker which259 * means all features are received, now we can force the260 * group if needed.261 */262 setup_forced_leader(rep, session->evlist);263 return 0;264}265 266static int process_sample_event(const struct perf_tool *tool,267 union perf_event *event,268 struct perf_sample *sample,269 struct evsel *evsel,270 struct machine *machine)271{272 struct report *rep = container_of(tool, struct report, tool);273 struct addr_location al;274 struct hist_entry_iter iter = {275 .evsel = evsel,276 .sample = sample,277 .hide_unresolved = symbol_conf.hide_unresolved,278 .add_entry_cb = hist_iter__report_callback,279 };280 int ret = 0;281 282 if (perf_time__ranges_skip_sample(rep->ptime_range, rep->range_num,283 sample->time)) {284 return 0;285 }286 287 if (evswitch__discard(&rep->evswitch, evsel))288 return 0;289 290 addr_location__init(&al);291 if (machine__resolve(machine, &al, sample) < 0) {292 pr_debug("problem processing %d event, skipping it.\n",293 event->header.type);294 ret = -1;295 goto out_put;296 }297 298 if (rep->stitch_lbr)299 thread__set_lbr_stitch_enable(al.thread, true);300 301 if (symbol_conf.hide_unresolved && al.sym == NULL)302 goto out_put;303 304 if (rep->cpu_list && !test_bit(sample->cpu, rep->cpu_bitmap))305 goto out_put;306 307 if (sort__mode == SORT_MODE__BRANCH) {308 /*309 * A non-synthesized event might not have a branch stack if310 * branch stacks have been synthesized (using itrace options).311 */312 if (!sample->branch_stack)313 goto out_put;314 315 iter.add_entry_cb = hist_iter__branch_callback;316 iter.ops = &hist_iter_branch;317 } else if (rep->mem_mode) {318 iter.ops = &hist_iter_mem;319 } else if (symbol_conf.cumulate_callchain) {320 iter.ops = &hist_iter_cumulative;321 } else {322 iter.ops = &hist_iter_normal;323 }324 325 if (al.map != NULL)326 dso__set_hit(map__dso(al.map));327 328 if (ui__has_annotation() || rep->symbol_ipc || rep->total_cycles_mode) {329 hist__account_cycles(sample->branch_stack, &al, sample,330 rep->nonany_branch_mode,331 &rep->total_cycles, evsel);332 }333 334 ret = hist_entry_iter__add(&iter, &al, rep->max_stack, rep);335 if (ret < 0)336 pr_debug("problem adding hist entry, skipping event\n");337out_put:338 addr_location__exit(&al);339 return ret;340}341 342static int process_read_event(const struct perf_tool *tool,343 union perf_event *event,344 struct perf_sample *sample __maybe_unused,345 struct evsel *evsel,346 struct machine *machine __maybe_unused)347{348 struct report *rep = container_of(tool, struct report, tool);349 350 if (rep->show_threads) {351 const char *name = evsel__name(evsel);352 int err = perf_read_values_add_value(&rep->show_threads_values,353 event->read.pid, event->read.tid,354 evsel->core.idx,355 name,356 event->read.value);357 358 if (err)359 return err;360 }361 362 return 0;363}364 365/* For pipe mode, sample_type is not currently set */366static int report__setup_sample_type(struct report *rep)367{368 struct perf_session *session = rep->session;369 u64 sample_type = evlist__combined_sample_type(session->evlist);370 bool is_pipe = perf_data__is_pipe(session->data);371 struct evsel *evsel;372 373 if (session->itrace_synth_opts->callchain ||374 session->itrace_synth_opts->add_callchain ||375 (!is_pipe &&376 perf_header__has_feat(&session->header, HEADER_AUXTRACE) &&377 !session->itrace_synth_opts->set))378 sample_type |= PERF_SAMPLE_CALLCHAIN;379 380 if (session->itrace_synth_opts->last_branch ||381 session->itrace_synth_opts->add_last_branch)382 sample_type |= PERF_SAMPLE_BRANCH_STACK;383 384 if (!is_pipe && !(sample_type & PERF_SAMPLE_CALLCHAIN)) {385 if (perf_hpp_list.parent) {386 ui__error("Selected --sort parent, but no "387 "callchain data. Did you call "388 "'perf record' without -g?\n");389 return -EINVAL;390 }391 if (symbol_conf.use_callchain &&392 !symbol_conf.show_branchflag_count) {393 ui__error("Selected -g or --branch-history.\n"394 "But no callchain or branch data.\n"395 "Did you call 'perf record' without -g or -b?\n");396 return -1;397 }398 } else if (!callchain_param.enabled &&399 callchain_param.mode != CHAIN_NONE &&400 !symbol_conf.use_callchain) {401 symbol_conf.use_callchain = true;402 if (callchain_register_param(&callchain_param) < 0) {403 ui__error("Can't register callchain params.\n");404 return -EINVAL;405 }406 }407 408 if (symbol_conf.cumulate_callchain) {409 /* Silently ignore if callchain is missing */410 if (!(sample_type & PERF_SAMPLE_CALLCHAIN)) {411 symbol_conf.cumulate_callchain = false;412 perf_hpp__cancel_cumulate();413 }414 }415 416 if (sort__mode == SORT_MODE__BRANCH) {417 if (!is_pipe &&418 !(sample_type & PERF_SAMPLE_BRANCH_STACK)) {419 ui__error("Selected -b but no branch data. "420 "Did you call perf record without -b?\n");421 return -1;422 }423 }424 425 if (sort__mode == SORT_MODE__MEMORY) {426 /*427 * FIXUP: prior to kernel 5.18, Arm SPE missed to set428 * PERF_SAMPLE_DATA_SRC bit in sample type. For backward429 * compatibility, set the bit if it's an old perf data file.430 */431 evlist__for_each_entry(session->evlist, evsel) {432 if (strstr(evsel__name(evsel), "arm_spe") &&433 !(sample_type & PERF_SAMPLE_DATA_SRC)) {434 evsel->core.attr.sample_type |= PERF_SAMPLE_DATA_SRC;435 sample_type |= PERF_SAMPLE_DATA_SRC;436 }437 }438 439 if (!is_pipe && !(sample_type & PERF_SAMPLE_DATA_SRC)) {440 ui__error("Selected --mem-mode but no mem data. "441 "Did you call perf record without -d?\n");442 return -1;443 }444 }445 446 callchain_param_setup(sample_type, perf_env__arch(&rep->session->header.env));447 448 if (rep->stitch_lbr && (callchain_param.record_mode != CALLCHAIN_LBR)) {449 ui__warning("Can't find LBR callchain. Switch off --stitch-lbr.\n"450 "Please apply --call-graph lbr when recording.\n");451 rep->stitch_lbr = false;452 }453 454 /* ??? handle more cases than just ANY? */455 if (!(evlist__combined_branch_type(session->evlist) & PERF_SAMPLE_BRANCH_ANY))456 rep->nonany_branch_mode = true;457 458#if !defined(HAVE_LIBUNWIND_SUPPORT) && !defined(HAVE_DWARF_SUPPORT)459 if (dwarf_callchain_users) {460 ui__warning("Please install libunwind or libdw "461 "development packages during the perf build.\n");462 }463#endif464 465 return 0;466}467 468static void sig_handler(int sig __maybe_unused)469{470 session_done = 1;471}472 473static size_t hists__fprintf_nr_sample_events(struct hists *hists, struct report *rep,474 const char *evname, FILE *fp)475{476 size_t ret;477 char unit;478 unsigned long nr_samples = hists->stats.nr_samples;479 u64 nr_events = hists->stats.total_period;480 struct evsel *evsel = hists_to_evsel(hists);481 char buf[512];482 size_t size = sizeof(buf);483 int socked_id = hists->socket_filter;484 485 if (quiet)486 return 0;487 488 if (symbol_conf.filter_relative) {489 nr_samples = hists->stats.nr_non_filtered_samples;490 nr_events = hists->stats.total_non_filtered_period;491 }492 493 if (evsel__is_group_event(evsel)) {494 struct evsel *pos;495 496 evsel__group_desc(evsel, buf, size);497 evname = buf;498 499 for_each_group_member(pos, evsel) {500 const struct hists *pos_hists = evsel__hists(pos);501 502 if (symbol_conf.filter_relative) {503 nr_samples += pos_hists->stats.nr_non_filtered_samples;504 nr_events += pos_hists->stats.total_non_filtered_period;505 } else {506 nr_samples += pos_hists->stats.nr_samples;507 nr_events += pos_hists->stats.total_period;508 }509 }510 }511 512 nr_samples = convert_unit(nr_samples, &unit);513 ret = fprintf(fp, "# Samples: %lu%c", nr_samples, unit);514 if (evname != NULL) {515 ret += fprintf(fp, " of event%s '%s'",516 evsel->core.nr_members > 1 ? "s" : "", evname);517 }518 519 if (rep->time_str)520 ret += fprintf(fp, " (time slices: %s)", rep->time_str);521 522 if (symbol_conf.show_ref_callgraph && evname && strstr(evname, "call-graph=no")) {523 ret += fprintf(fp, ", show reference callgraph");524 }525 526 if (rep->mem_mode) {527 ret += fprintf(fp, "\n# Total weight : %" PRIu64, nr_events);528 ret += fprintf(fp, "\n# Sort order : %s", sort_order ? : default_mem_sort_order);529 } else530 ret += fprintf(fp, "\n# Event count (approx.): %" PRIu64, nr_events);531 532 if (socked_id > -1)533 ret += fprintf(fp, "\n# Processor Socket: %d", socked_id);534 535 return ret + fprintf(fp, "\n#\n");536}537 538static int evlist__tui_block_hists_browse(struct evlist *evlist, struct report *rep)539{540 struct evsel *pos;541 int i = 0, ret;542 543 evlist__for_each_entry(evlist, pos) {544 ret = report__browse_block_hists(&rep->block_reports[i++].hist,545 rep->min_percent, pos,546 &rep->session->header.env);547 if (ret != 0)548 return ret;549 }550 551 return 0;552}553 554static int evlist__tty_browse_hists(struct evlist *evlist, struct report *rep, const char *help)555{556 struct evsel *pos;557 int i = 0;558 559 if (!quiet) {560 fprintf(stdout, "#\n# Total Lost Samples: %" PRIu64 "\n#\n",561 evlist->stats.total_lost_samples);562 }563 564 evlist__for_each_entry(evlist, pos) {565 struct hists *hists = evsel__hists(pos);566 const char *evname = evsel__name(pos);567 568 i++;569 if (symbol_conf.event_group && !evsel__is_group_leader(pos))570 continue;571 572 if (rep->skip_empty && !hists->stats.nr_samples)573 continue;574 575 hists__fprintf_nr_sample_events(hists, rep, evname, stdout);576 577 if (rep->total_cycles_mode) {578 char *buf;579 580 if (!annotation_br_cntr_abbr_list(&buf, pos, true)) {581 fprintf(stdout, "%s", buf);582 fprintf(stdout, "#\n");583 free(buf);584 }585 report__browse_block_hists(&rep->block_reports[i - 1].hist,586 rep->min_percent, pos, NULL);587 continue;588 }589 590 hists__fprintf(hists, !quiet, 0, 0, rep->min_percent, stdout,591 !(symbol_conf.use_callchain ||592 symbol_conf.show_branchflag_count));593 fprintf(stdout, "\n\n");594 }595 596 if (!quiet)597 fprintf(stdout, "#\n# (%s)\n#\n", help);598 599 if (rep->show_threads) {600 bool style = !strcmp(rep->pretty_printing_style, "raw");601 perf_read_values_display(stdout, &rep->show_threads_values,602 style);603 perf_read_values_destroy(&rep->show_threads_values);604 }605 606 if (sort__mode == SORT_MODE__BRANCH)607 branch_type_stat_display(stdout, &rep->brtype_stat);608 609 return 0;610}611 612static void report__warn_kptr_restrict(const struct report *rep)613{614 struct map *kernel_map = machine__kernel_map(&rep->session->machines.host);615 struct kmap *kernel_kmap = kernel_map ? map__kmap(kernel_map) : NULL;616 617 if (evlist__exclude_kernel(rep->session->evlist))618 return;619 620 if (kernel_map == NULL ||621 (dso__hit(map__dso(kernel_map)) &&622 (kernel_kmap->ref_reloc_sym == NULL ||623 kernel_kmap->ref_reloc_sym->addr == 0))) {624 const char *desc =625 "As no suitable kallsyms nor vmlinux was found, kernel samples\n"626 "can't be resolved.";627 628 if (kernel_map && map__has_symbols(kernel_map)) {629 desc = "If some relocation was applied (e.g. "630 "kexec) symbols may be misresolved.";631 }632 633 ui__warning(634"Kernel address maps (/proc/{kallsyms,modules}) were restricted.\n\n"635"Check /proc/sys/kernel/kptr_restrict before running 'perf record'.\n\n%s\n\n"636"Samples in kernel modules can't be resolved as well.\n\n",637 desc);638 }639}640 641static int report__gtk_browse_hists(struct report *rep, const char *help)642{643 int (*hist_browser)(struct evlist *evlist, const char *help,644 struct hist_browser_timer *timer, float min_pcnt);645 646 hist_browser = dlsym(perf_gtk_handle, "evlist__gtk_browse_hists");647 648 if (hist_browser == NULL) {649 ui__error("GTK browser not found!\n");650 return -1;651 }652 653 return hist_browser(rep->session->evlist, help, NULL, rep->min_percent);654}655 656static int report__browse_hists(struct report *rep)657{658 int ret;659 struct perf_session *session = rep->session;660 struct evlist *evlist = session->evlist;661 char *help = NULL, *path = NULL;662 663 path = system_path(TIPDIR);664 if (perf_tip(&help, path) || help == NULL) {665 /* fallback for people who don't install perf ;-) */666 free(path);667 path = system_path(DOCDIR);668 if (perf_tip(&help, path) || help == NULL)669 help = strdup("Cannot load tips.txt file, please install perf!");670 }671 free(path);672 673 switch (use_browser) {674 case 1:675 if (rep->total_cycles_mode) {676 ret = evlist__tui_block_hists_browse(evlist, rep);677 break;678 }679 680 ret = evlist__tui_browse_hists(evlist, help, NULL, rep->min_percent,681 &session->header.env, true);682 /*683 * Usually "ret" is the last pressed key, and we only684 * care if the key notifies us to switch data file.685 */686 if (ret != K_SWITCH_INPUT_DATA && ret != K_RELOAD)687 ret = 0;688 break;689 case 2:690 ret = report__gtk_browse_hists(rep, help);691 break;692 default:693 ret = evlist__tty_browse_hists(evlist, rep, help);694 break;695 }696 free(help);697 return ret;698}699 700static int report__collapse_hists(struct report *rep)701{702 struct perf_session *session = rep->session;703 struct evlist *evlist = session->evlist;704 struct ui_progress prog;705 struct evsel *pos;706 int ret = 0;707 708 /*709 * The pipe data needs to setup hierarchy hpp formats now, because it710 * cannot know about evsels in the data before reading the data. The711 * normal file data saves the event (attribute) info in the header712 * section, but pipe does not have the luxury.713 */714 if (perf_data__is_pipe(session->data)) {715 if (perf_hpp__setup_hists_formats(&perf_hpp_list, evlist) < 0) {716 ui__error("Failed to setup hierarchy output formats\n");717 return -1;718 }719 }720 721 ui_progress__init(&prog, rep->nr_entries, "Merging related events...");722 723 evlist__for_each_entry(rep->session->evlist, pos) {724 struct hists *hists = evsel__hists(pos);725 726 if (pos->core.idx == 0)727 hists->symbol_filter_str = rep->symbol_filter_str;728 729 hists->socket_filter = rep->socket_filter;730 731 ret = hists__collapse_resort(hists, &prog);732 if (ret < 0)733 break;734 735 /* Non-group events are considered as leader */736 if (symbol_conf.event_group && !evsel__is_group_leader(pos)) {737 struct hists *leader_hists = evsel__hists(evsel__leader(pos));738 739 hists__match(leader_hists, hists);740 hists__link(leader_hists, hists);741 }742 }743 744 ui_progress__finish();745 return ret;746}747 748static int hists__resort_cb(struct hist_entry *he, void *arg)749{750 struct report *rep = arg;751 struct symbol *sym = he->ms.sym;752 753 if (rep->symbol_ipc && sym && !sym->annotate2) {754 struct evsel *evsel = hists_to_evsel(he->hists);755 756 symbol__annotate2(&he->ms, evsel, NULL);757 }758 759 return 0;760}761 762static void report__output_resort(struct report *rep)763{764 struct ui_progress prog;765 struct evsel *pos;766 767 ui_progress__init(&prog, rep->nr_entries, "Sorting events for output...");768 769 evlist__for_each_entry(rep->session->evlist, pos) {770 evsel__output_resort_cb(pos, &prog, hists__resort_cb, rep);771 }772 773 ui_progress__finish();774}775 776static int count_sample_event(const struct perf_tool *tool __maybe_unused,777 union perf_event *event __maybe_unused,778 struct perf_sample *sample __maybe_unused,779 struct evsel *evsel,780 struct machine *machine __maybe_unused)781{782 struct hists *hists = evsel__hists(evsel);783 784 hists__inc_nr_events(hists);785 return 0;786}787 788static int count_lost_samples_event(const struct perf_tool *tool,789 union perf_event *event,790 struct perf_sample *sample,791 struct machine *machine __maybe_unused)792{793 struct report *rep = container_of(tool, struct report, tool);794 struct evsel *evsel;795 796 evsel = evlist__id2evsel(rep->session->evlist, sample->id);797 if (evsel) {798 struct hists *hists = evsel__hists(evsel);799 u32 count = event->lost_samples.lost;800 801 if (event->header.misc & PERF_RECORD_MISC_LOST_SAMPLES_BPF)802 hists__inc_nr_dropped_samples(hists, count);803 else804 hists__inc_nr_lost_samples(hists, count);805 }806 return 0;807}808 809static int process_attr(const struct perf_tool *tool __maybe_unused,810 union perf_event *event,811 struct evlist **pevlist);812 813static void stats_setup(struct report *rep)814{815 perf_tool__init(&rep->tool, /*ordered_events=*/false);816 rep->tool.attr = process_attr;817 rep->tool.sample = count_sample_event;818 rep->tool.lost_samples = count_lost_samples_event;819 rep->tool.event_update = perf_event__process_event_update;820 rep->tool.no_warn = true;821}822 823static int stats_print(struct report *rep)824{825 struct perf_session *session = rep->session;826 827 perf_session__fprintf_nr_events(session, stdout);828 evlist__fprintf_nr_events(session->evlist, stdout);829 return 0;830}831 832static void tasks_setup(struct report *rep)833{834 perf_tool__init(&rep->tool, /*ordered_events=*/true);835 if (rep->mmaps_mode) {836 rep->tool.mmap = perf_event__process_mmap;837 rep->tool.mmap2 = perf_event__process_mmap2;838 }839 rep->tool.attr = process_attr;840 rep->tool.comm = perf_event__process_comm;841 rep->tool.exit = perf_event__process_exit;842 rep->tool.fork = perf_event__process_fork;843 rep->tool.no_warn = true;844}845 846struct maps__fprintf_task_args {847 int indent;848 FILE *fp;849 size_t printed;850};851 852static int maps__fprintf_task_cb(struct map *map, void *data)853{854 struct maps__fprintf_task_args *args = data;855 const struct dso *dso = map__dso(map);856 u32 prot = map__prot(map);857 int ret;858 859 ret = fprintf(args->fp,860 "%*s %" PRIx64 "-%" PRIx64 " %c%c%c%c %08" PRIx64 " %" PRIu64 " %s\n",861 args->indent, "", map__start(map), map__end(map),862 prot & PROT_READ ? 'r' : '-',863 prot & PROT_WRITE ? 'w' : '-',864 prot & PROT_EXEC ? 'x' : '-',865 map__flags(map) ? 's' : 'p',866 map__pgoff(map),867 dso__id_const(dso)->ino, dso__name(dso));868 869 if (ret < 0)870 return ret;871 872 args->printed += ret;873 return 0;874}875 876static size_t maps__fprintf_task(struct maps *maps, int indent, FILE *fp)877{878 struct maps__fprintf_task_args args = {879 .indent = indent,880 .fp = fp,881 .printed = 0,882 };883 884 maps__for_each_map(maps, maps__fprintf_task_cb, &args);885 886 return args.printed;887}888 889static int thread_level(struct machine *machine, const struct thread *thread)890{891 struct thread *parent_thread;892 int res;893 894 if (thread__tid(thread) <= 0)895 return 0;896 897 if (thread__ppid(thread) <= 0)898 return 1;899 900 parent_thread = machine__find_thread(machine, -1, thread__ppid(thread));901 if (!parent_thread) {902 pr_err("Missing parent thread of %d\n", thread__tid(thread));903 return 0;904 }905 res = 1 + thread_level(machine, parent_thread);906 thread__put(parent_thread);907 return res;908}909 910static void task__print_level(struct machine *machine, struct thread *thread, FILE *fp)911{912 int level = thread_level(machine, thread);913 int comm_indent = fprintf(fp, " %8d %8d %8d |%*s",914 thread__pid(thread), thread__tid(thread),915 thread__ppid(thread), level, "");916 917 fprintf(fp, "%s\n", thread__comm_str(thread));918 919 maps__fprintf_task(thread__maps(thread), comm_indent, fp);920}921 922/*923 * Sort two thread list nodes such that they form a tree. The first node is the924 * root of the tree, its children are ordered numerically after it. If a child925 * has children itself then they appear immediately after their parent. For926 * example, the 4 threads in the order they'd appear in the list:927 * - init with a TID 1 and a parent of 0928 * - systemd with a TID 3000 and a parent of init/1929 * - systemd child thread with TID 4000, the parent is 3000930 * - NetworkManager is a child of init with a TID of 3500.931 */932static int task_list_cmp(void *priv, const struct list_head *la, const struct list_head *lb)933{934 struct machine *machine = priv;935 struct thread_list *task_a = list_entry(la, struct thread_list, list);936 struct thread_list *task_b = list_entry(lb, struct thread_list, list);937 struct thread *a = task_a->thread;938 struct thread *b = task_b->thread;939 int level_a, level_b, res;940 941 /* Same thread? */942 if (thread__tid(a) == thread__tid(b))943 return 0;944 945 /* Compare a and b to root. */946 if (thread__tid(a) == 0)947 return -1;948 949 if (thread__tid(b) == 0)950 return 1;951 952 /* If parents match sort by tid. */953 if (thread__ppid(a) == thread__ppid(b))954 return thread__tid(a) < thread__tid(b) ? -1 : 1;955 956 /*957 * Find a and b such that if they are a child of each other a and b's958 * tid's match, otherwise a and b have a common parent and distinct959 * tid's to sort by. First make the depths of the threads match.960 */961 level_a = thread_level(machine, a);962 level_b = thread_level(machine, b);963 a = thread__get(a);964 b = thread__get(b);965 for (int i = level_a; i > level_b; i--) {966 struct thread *parent = machine__find_thread(machine, -1, thread__ppid(a));967 968 thread__put(a);969 if (!parent) {970 pr_err("Missing parent thread of %d\n", thread__tid(a));971 thread__put(b);972 return -1;973 }974 a = parent;975 }976 for (int i = level_b; i > level_a; i--) {977 struct thread *parent = machine__find_thread(machine, -1, thread__ppid(b));978 979 thread__put(b);980 if (!parent) {981 pr_err("Missing parent thread of %d\n", thread__tid(b));982 thread__put(a);983 return 1;984 }985 b = parent;986 }987 /* Search up to a common parent. */988 while (thread__ppid(a) != thread__ppid(b)) {989 struct thread *parent;990 991 parent = machine__find_thread(machine, -1, thread__ppid(a));992 thread__put(a);993 if (!parent)994 pr_err("Missing parent thread of %d\n", thread__tid(a));995 a = parent;996 parent = machine__find_thread(machine, -1, thread__ppid(b));997 thread__put(b);998 if (!parent)999 pr_err("Missing parent thread of %d\n", thread__tid(b));1000 b = parent;1001 if (!a || !b) {1002 /* Handle missing parent (unexpected) with some sanity. */1003 thread__put(a);1004 thread__put(b);1005 return !a && !b ? 0 : (!a ? -1 : 1);1006 }1007 }1008 if (thread__tid(a) == thread__tid(b)) {1009 /* a is a child of b or vice-versa, deeper levels appear later. */1010 res = level_a < level_b ? -1 : (level_a > level_b ? 1 : 0);1011 } else {1012 /* Sort by tid now the parent is the same. */1013 res = thread__tid(a) < thread__tid(b) ? -1 : 1;1014 }1015 thread__put(a);1016 thread__put(b);1017 return res;1018}1019 1020static int tasks_print(struct report *rep, FILE *fp)1021{1022 struct machine *machine = &rep->session->machines.host;1023 LIST_HEAD(tasks);1024 int ret;1025 1026 ret = machine__thread_list(machine, &tasks);1027 if (!ret) {1028 struct thread_list *task;1029 1030 list_sort(machine, &tasks, task_list_cmp);1031 1032 fprintf(fp, "# %8s %8s %8s %s\n", "pid", "tid", "ppid", "comm");1033 1034 list_for_each_entry(task, &tasks, list)1035 task__print_level(machine, task->thread, fp);1036 }1037 thread_list__delete(&tasks);1038 return ret;1039}1040 1041static int __cmd_report(struct report *rep)1042{1043 int ret;1044 struct perf_session *session = rep->session;1045 struct evsel *pos;1046 struct perf_data *data = session->data;1047 1048 signal(SIGINT, sig_handler);1049 1050 if (rep->cpu_list) {1051 ret = perf_session__cpu_bitmap(session, rep->cpu_list,1052 rep->cpu_bitmap);1053 if (ret) {1054 ui__error("failed to set cpu bitmap\n");1055 return ret;1056 }1057 session->itrace_synth_opts->cpu_bitmap = rep->cpu_bitmap;1058 }1059 1060 if (rep->show_threads) {1061 ret = perf_read_values_init(&rep->show_threads_values);1062 if (ret)1063 return ret;1064 }1065 1066 ret = report__setup_sample_type(rep);1067 if (ret) {1068 /* report__setup_sample_type() already showed error message */1069 return ret;1070 }1071 1072 if (rep->stats_mode)1073 stats_setup(rep);1074 1075 if (rep->tasks_mode)1076 tasks_setup(rep);1077 1078 ret = perf_session__process_events(session);1079 if (ret) {1080 ui__error("failed to process sample\n");1081 return ret;1082 }1083 1084 evlist__check_mem_load_aux(session->evlist);1085 1086 if (rep->stats_mode)1087 return stats_print(rep);1088 1089 if (rep->tasks_mode)1090 return tasks_print(rep, stdout);1091 1092 report__warn_kptr_restrict(rep);1093 1094 evlist__for_each_entry(session->evlist, pos)1095 rep->nr_entries += evsel__hists(pos)->nr_entries;1096 1097 if (use_browser == 0) {1098 if (verbose > 3)1099 perf_session__fprintf(session, stdout);1100 1101 if (verbose > 2)1102 perf_session__fprintf_dsos(session, stdout);1103 1104 if (dump_trace) {1105 stats_print(rep);1106 return 0;1107 }1108 }1109 1110 ret = report__collapse_hists(rep);1111 if (ret) {1112 ui__error("failed to process hist entry\n");1113 return ret;1114 }1115 1116 if (session_done())1117 return 0;1118 1119 /*1120 * recalculate number of entries after collapsing since it1121 * might be changed during the collapse phase.1122 */1123 rep->nr_entries = 0;1124 evlist__for_each_entry(session->evlist, pos)1125 rep->nr_entries += evsel__hists(pos)->nr_entries;1126 1127 if (rep->nr_entries == 0) {1128 ui__error("The %s data has no samples!\n", data->path);1129 return 0;1130 }1131 1132 report__output_resort(rep);1133 1134 if (rep->total_cycles_mode) {1135 int nr_hpps = 4;1136 int block_hpps[PERF_HPP_REPORT__BLOCK_MAX_INDEX] = {1137 PERF_HPP_REPORT__BLOCK_TOTAL_CYCLES_PCT,1138 PERF_HPP_REPORT__BLOCK_LBR_CYCLES,1139 PERF_HPP_REPORT__BLOCK_CYCLES_PCT,1140 PERF_HPP_REPORT__BLOCK_AVG_CYCLES,1141 };1142 1143 if (session->evlist->nr_br_cntr > 0)1144 block_hpps[nr_hpps++] = PERF_HPP_REPORT__BLOCK_BRANCH_COUNTER;1145 1146 block_hpps[nr_hpps++] = PERF_HPP_REPORT__BLOCK_RANGE;1147 block_hpps[nr_hpps++] = PERF_HPP_REPORT__BLOCK_DSO;1148 1149 rep->block_reports = block_info__create_report(session->evlist,1150 rep->total_cycles,1151 block_hpps, nr_hpps,1152 &rep->nr_block_reports);1153 if (!rep->block_reports)1154 return -1;1155 }1156 1157 return report__browse_hists(rep);1158}1159 1160static int1161report_parse_callchain_opt(const struct option *opt, const char *arg, int unset)1162{1163 struct callchain_param *callchain = opt->value;1164 1165 callchain->enabled = !unset;1166 /*1167 * --no-call-graph1168 */1169 if (unset) {1170 symbol_conf.use_callchain = false;1171 callchain->mode = CHAIN_NONE;1172 return 0;1173 }1174 1175 return parse_callchain_report_opt(arg);1176}1177 1178static int1179parse_time_quantum(const struct option *opt, const char *arg,1180 int unset __maybe_unused)1181{1182 unsigned long *time_q = opt->value;1183 char *end;1184 1185 *time_q = strtoul(arg, &end, 0);1186 if (end == arg)1187 goto parse_err;1188 if (*time_q == 0) {1189 pr_err("time quantum cannot be 0");1190 return -1;1191 }1192 end = skip_spaces(end);1193 if (*end == 0)1194 return 0;1195 if (!strcmp(end, "s")) {1196 *time_q *= NSEC_PER_SEC;1197 return 0;1198 }1199 if (!strcmp(end, "ms")) {1200 *time_q *= NSEC_PER_MSEC;1201 return 0;1202 }1203 if (!strcmp(end, "us")) {1204 *time_q *= NSEC_PER_USEC;1205 return 0;1206 }1207 if (!strcmp(end, "ns"))1208 return 0;1209parse_err:1210 pr_err("Cannot parse time quantum `%s'\n", arg);1211 return -1;1212}1213 1214int1215report_parse_ignore_callees_opt(const struct option *opt __maybe_unused,1216 const char *arg, int unset __maybe_unused)1217{1218 if (arg) {1219 int err = regcomp(&ignore_callees_regex, arg, REG_EXTENDED);1220 if (err) {1221 char buf[BUFSIZ];1222 regerror(err, &ignore_callees_regex, buf, sizeof(buf));1223 pr_err("Invalid --ignore-callees regex: %s\n%s", arg, buf);1224 return -1;1225 }1226 have_ignore_callees = 1;1227 }1228 1229 return 0;1230}1231 1232static int1233parse_branch_mode(const struct option *opt,1234 const char *str __maybe_unused, int unset)1235{1236 int *branch_mode = opt->value;1237 1238 *branch_mode = !unset;1239 return 0;1240}1241 1242static int1243parse_percent_limit(const struct option *opt, const char *str,1244 int unset __maybe_unused)1245{1246 struct report *rep = opt->value;1247 double pcnt = strtof(str, NULL);1248 1249 rep->min_percent = pcnt;1250 callchain_param.min_percent = pcnt;1251 return 0;1252}1253 1254static int process_attr(const struct perf_tool *tool __maybe_unused,1255 union perf_event *event,1256 struct evlist **pevlist)1257{1258 u64 sample_type;1259 int err;1260 1261 err = perf_event__process_attr(tool, event, pevlist);1262 if (err)1263 return err;1264 1265 /*1266 * Check if we need to enable callchains based1267 * on events sample_type.1268 */1269 sample_type = evlist__combined_sample_type(*pevlist);1270 callchain_param_setup(sample_type, perf_env__arch((*pevlist)->env));1271 return 0;1272}1273 1274int cmd_report(int argc, const char **argv)1275{1276 struct perf_session *session;1277 struct itrace_synth_opts itrace_synth_opts = { .set = 0, };1278 struct stat st;1279 bool has_br_stack = false;1280 int branch_mode = -1;1281 int last_key = 0;1282 bool branch_call_mode = false;1283#define CALLCHAIN_DEFAULT_OPT "graph,0.5,caller,function,percent"1284 static const char report_callchain_help[] = "Display call graph (stack chain/backtrace):\n\n"1285 CALLCHAIN_REPORT_HELP1286 "\n\t\t\t\tDefault: " CALLCHAIN_DEFAULT_OPT;1287 char callchain_default_opt[] = CALLCHAIN_DEFAULT_OPT;1288 const char * const report_usage[] = {1289 "perf report [<options>]",1290 NULL1291 };1292 struct report report = {1293 .max_stack = PERF_MAX_STACK_DEPTH,1294 .pretty_printing_style = "normal",1295 .socket_filter = -1,1296 .skip_empty = true,1297 };1298 char *sort_order_help = sort_help("sort by key(s):", SORT_MODE__NORMAL);1299 char *field_order_help = sort_help("output field(s):", SORT_MODE__NORMAL);1300 const char *disassembler_style = NULL, *objdump_path = NULL, *addr2line_path = NULL;1301 const struct option options[] = {1302 OPT_STRING('i', "input", &input_name, "file",1303 "input file name"),1304 OPT_INCR('v', "verbose", &verbose,1305 "be more verbose (show symbol address, etc)"),1306 OPT_BOOLEAN('q', "quiet", &quiet, "Do not show any warnings or messages"),1307 OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,1308 "dump raw trace in ASCII"),1309 OPT_BOOLEAN(0, "stats", &report.stats_mode, "Display event stats"),1310 OPT_BOOLEAN(0, "tasks", &report.tasks_mode, "Display recorded tasks"),1311 OPT_BOOLEAN(0, "mmaps", &report.mmaps_mode, "Display recorded tasks memory maps"),1312 OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,1313 "file", "vmlinux pathname"),1314 OPT_BOOLEAN(0, "ignore-vmlinux", &symbol_conf.ignore_vmlinux,1315 "don't load vmlinux even if found"),1316 OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name,1317 "file", "kallsyms pathname"),1318 OPT_BOOLEAN('f', "force", &symbol_conf.force, "don't complain, do it"),1319 OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,1320 "load module symbols - WARNING: use only with -k and LIVE kernel"),1321 OPT_BOOLEAN('n', "show-nr-samples", &symbol_conf.show_nr_samples,1322 "Show a column with the number of samples"),1323 OPT_BOOLEAN('T', "threads", &report.show_threads,1324 "Show per-thread event counters"),1325 OPT_STRING(0, "pretty", &report.pretty_printing_style, "key",1326 "pretty printing style key: normal raw"),1327#ifdef HAVE_SLANG_SUPPORT1328 OPT_BOOLEAN(0, "tui", &report.use_tui, "Use the TUI interface"),1329#endif1330#ifdef HAVE_GTK2_SUPPORT1331 OPT_BOOLEAN(0, "gtk", &report.use_gtk, "Use the GTK2 interface"),1332#endif1333 OPT_BOOLEAN(0, "stdio", &report.use_stdio,1334 "Use the stdio interface"),1335 OPT_BOOLEAN(0, "header", &report.header, "Show data header."),1336 OPT_BOOLEAN(0, "header-only", &report.header_only,1337 "Show only data header."),1338 OPT_STRING('s', "sort", &sort_order, "key[,key2...]",1339 sort_order_help),1340 OPT_STRING('F', "fields", &field_order, "key[,keys...]",1341 field_order_help),1342 OPT_BOOLEAN(0, "show-cpu-utilization", &symbol_conf.show_cpu_utilization,1343 "Show sample percentage for different cpu modes"),1344 OPT_BOOLEAN_FLAG(0, "showcpuutilization", &symbol_conf.show_cpu_utilization,1345 "Show sample percentage for different cpu modes", PARSE_OPT_HIDDEN),1346 OPT_STRING('p', "parent", &parent_pattern, "regex",1347 "regex filter to identify parent, see: '--sort parent'"),1348 OPT_BOOLEAN('x', "exclude-other", &symbol_conf.exclude_other,1349 "Only display entries with parent-match"),1350 OPT_CALLBACK_DEFAULT('g', "call-graph", &callchain_param,1351 "print_type,threshold[,print_limit],order,sort_key[,branch],value",1352 report_callchain_help, &report_parse_callchain_opt,1353 callchain_default_opt),1354 OPT_BOOLEAN(0, "children", &symbol_conf.cumulate_callchain,1355 "Accumulate callchains of children and show total overhead as well. "1356 "Enabled by default, use --no-children to disable."),1357 OPT_INTEGER(0, "max-stack", &report.max_stack,1358 "Set the maximum stack depth when parsing the callchain, "1359 "anything beyond the specified depth will be ignored. "1360 "Default: kernel.perf_event_max_stack or " __stringify(PERF_MAX_STACK_DEPTH)),1361 OPT_BOOLEAN('G', "inverted", &report.inverted_callchain,1362 "alias for inverted call graph"),1363 OPT_CALLBACK(0, "ignore-callees", NULL, "regex",1364 "ignore callees of these functions in call graphs",1365 report_parse_ignore_callees_opt),1366 OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",1367 "only consider symbols in these dsos"),1368 OPT_STRING('c', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",1369 "only consider symbols in these comms"),1370 OPT_STRING(0, "pid", &symbol_conf.pid_list_str, "pid[,pid...]",1371 "only consider symbols in these pids"),1372 OPT_STRING(0, "tid", &symbol_conf.tid_list_str, "tid[,tid...]",1373 "only consider symbols in these tids"),1374 OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",1375 "only consider these symbols"),1376 OPT_STRING(0, "symbol-filter", &report.symbol_filter_str, "filter",1377 "only show symbols that (partially) match with this filter"),1378 OPT_STRING('w', "column-widths", &symbol_conf.col_width_list_str,1379 "width[,width...]",1380 "don't try to adjust column width, use these fixed values"),1381 OPT_STRING_NOEMPTY('t', "field-separator", &symbol_conf.field_sep, "separator",1382 "separator for columns, no spaces will be added between "1383 "columns '.' is reserved."),1384 OPT_BOOLEAN('U', "hide-unresolved", &symbol_conf.hide_unresolved,1385 "Only display entries resolved to a symbol"),1386 OPT_CALLBACK(0, "symfs", NULL, "directory",1387 "Look for files with symbols relative to this directory",1388 symbol__config_symfs),1389 OPT_STRING('C', "cpu", &report.cpu_list, "cpu",1390 "list of cpus to profile"),1391 OPT_BOOLEAN('I', "show-info", &report.show_full_info,1392 "Display extended information about perf.data file"),1393 OPT_BOOLEAN(0, "source", &annotate_opts.annotate_src,1394 "Interleave source code with assembly code (default)"),1395 OPT_BOOLEAN(0, "asm-raw", &annotate_opts.show_asm_raw,1396 "Display raw encoding of assembly instructions (default)"),1397 OPT_STRING('M', "disassembler-style", &disassembler_style, "disassembler style",1398 "Specify disassembler style (e.g. -M intel for intel syntax)"),1399 OPT_STRING(0, "prefix", &annotate_opts.prefix, "prefix",1400 "Add prefix to source file path names in programs (with --prefix-strip)"),1401 OPT_STRING(0, "prefix-strip", &annotate_opts.prefix_strip, "N",1402 "Strip first N entries of source file path name in programs (with --prefix)"),1403 OPT_BOOLEAN(0, "show-total-period", &symbol_conf.show_total_period,1404 "Show a column with the sum of periods"),1405 OPT_BOOLEAN_SET(0, "group", &symbol_conf.event_group, &report.group_set,1406 "Show event group information together"),1407 OPT_INTEGER(0, "group-sort-idx", &symbol_conf.group_sort_idx,1408 "Sort the output by the event at the index n in group. "1409 "If n is invalid, sort by the first event. "1410 "WARNING: should be used on grouped events."),1411 OPT_CALLBACK_NOOPT('b', "branch-stack", &branch_mode, "",1412 "use branch records for per branch histogram filling",1413 parse_branch_mode),1414 OPT_BOOLEAN(0, "branch-history", &branch_call_mode,1415 "add last branch records to call history"),1416 OPT_STRING(0, "objdump", &objdump_path, "path",1417 "objdump binary to use for disassembly and annotations"),1418 OPT_STRING(0, "addr2line", &addr2line_path, "path",1419 "addr2line binary to use for line numbers"),1420 OPT_BOOLEAN(0, "demangle", &symbol_conf.demangle,1421 "Disable symbol demangling"),1422 OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf.demangle_kernel,1423 "Enable kernel symbol demangling"),1424 OPT_BOOLEAN(0, "mem-mode", &report.mem_mode, "mem access profile"),1425 OPT_INTEGER(0, "samples", &symbol_conf.res_sample,1426 "Number of samples to save per histogram entry for individual browsing"),1427 OPT_CALLBACK(0, "percent-limit", &report, "percent",1428 "Don't show entries under that percent", parse_percent_limit),1429 OPT_CALLBACK(0, "percentage", NULL, "relative|absolute",1430 "how to display percentage of filtered entries", parse_filter_percentage),1431 OPT_CALLBACK_OPTARG(0, "itrace", &itrace_synth_opts, NULL, "opts",1432 "Instruction Tracing options\n" ITRACE_HELP,1433 itrace_parse_synth_opts),1434 OPT_BOOLEAN(0, "full-source-path", &srcline_full_filename,1435 "Show full source file name path for source lines"),1436 OPT_BOOLEAN(0, "show-ref-call-graph", &symbol_conf.show_ref_callgraph,1437 "Show callgraph from reference event"),1438 OPT_BOOLEAN(0, "stitch-lbr", &report.stitch_lbr,1439 "Enable LBR callgraph stitching approach"),1440 OPT_INTEGER(0, "socket-filter", &report.socket_filter,1441 "only show processor socket that match with this filter"),1442 OPT_BOOLEAN(0, "raw-trace", &symbol_conf.raw_trace,1443 "Show raw trace event output (do not use print fmt or plugins)"),1444 OPT_BOOLEAN('H', "hierarchy", &symbol_conf.report_hierarchy,1445 "Show entries in a hierarchy"),1446 OPT_CALLBACK_DEFAULT(0, "stdio-color", NULL, "mode",1447 "'always' (default), 'never' or 'auto' only applicable to --stdio mode",1448 stdio__config_color, "always"),1449 OPT_STRING(0, "time", &report.time_str, "str",1450 "Time span of interest (start,stop)"),1451 OPT_BOOLEAN(0, "inline", &symbol_conf.inline_name,1452 "Show inline function"),1453 OPT_CALLBACK(0, "percent-type", &annotate_opts, "local-period",1454 "Set percent type local/global-period/hits",1455 annotate_parse_percent_type),1456 OPT_BOOLEAN(0, "ns", &symbol_conf.nanosecs, "Show times in nanosecs"),1457 OPT_CALLBACK(0, "time-quantum", &symbol_conf.time_quantum, "time (ms|us|ns|s)",1458 "Set time quantum for time sort key (default 100ms)",1459 parse_time_quantum),1460 OPTS_EVSWITCH(&report.evswitch),1461 OPT_BOOLEAN(0, "total-cycles", &report.total_cycles_mode,1462 "Sort all blocks by 'Sampled Cycles%'"),1463 OPT_BOOLEAN(0, "disable-order", &report.disable_order,1464 "Disable raw trace ordering"),1465 OPT_BOOLEAN(0, "skip-empty", &report.skip_empty,1466 "Do not display empty (or dummy) events in the output"),1467 OPT_END()1468 };1469 struct perf_data data = {1470 .mode = PERF_DATA_MODE_READ,1471 };1472 int ret = hists__init();1473 char sort_tmp[128];1474 bool ordered_events = true;1475 1476 if (ret < 0)1477 goto exit;1478 1479 /*1480 * tasks_mode require access to exited threads to list those that are in1481 * the data file. Off-cpu events are synthesized after other events and1482 * reference exited threads.1483 */1484 symbol_conf.keep_exited_threads = true;1485 1486 annotation_options__init();1487 1488 ret = perf_config(report__config, &report);1489 if (ret)1490 goto exit;1491 1492 argc = parse_options(argc, argv, options, report_usage, 0);1493 if (argc) {1494 /*1495 * Special case: if there's an argument left then assume that1496 * it's a symbol filter:1497 */1498 if (argc > 1)1499 usage_with_options(report_usage, options);1500 1501 report.symbol_filter_str = argv[0];1502 }1503 1504 if (disassembler_style) {1505 annotate_opts.disassembler_style = strdup(disassembler_style);1506 if (!annotate_opts.disassembler_style)1507 return -ENOMEM;1508 }1509 if (objdump_path) {1510 annotate_opts.objdump_path = strdup(objdump_path);1511 if (!annotate_opts.objdump_path)1512 return -ENOMEM;1513 }1514 if (addr2line_path) {1515 symbol_conf.addr2line_path = strdup(addr2line_path);1516 if (!symbol_conf.addr2line_path)1517 return -ENOMEM;1518 }1519 1520 if (annotate_check_args() < 0) {1521 ret = -EINVAL;1522 goto exit;1523 }1524 1525 if (report.mmaps_mode)1526 report.tasks_mode = true;1527 1528 if (dump_trace && report.disable_order)1529 ordered_events = false;1530 1531 if (quiet)1532 perf_quiet_option();1533 1534 ret = symbol__validate_sym_arguments();1535 if (ret)1536 goto exit;1537 1538 if (report.inverted_callchain)1539 callchain_param.order = ORDER_CALLER;1540 if (symbol_conf.cumulate_callchain && !callchain_param.order_set)1541 callchain_param.order = ORDER_CALLER;1542 1543 if ((itrace_synth_opts.callchain || itrace_synth_opts.add_callchain) &&1544 (int)itrace_synth_opts.callchain_sz > report.max_stack)1545 report.max_stack = itrace_synth_opts.callchain_sz;1546 1547 if (!input_name || !strlen(input_name)) {1548 if (!fstat(STDIN_FILENO, &st) && S_ISFIFO(st.st_mode))1549 input_name = "-";1550 else1551 input_name = "perf.data";1552 }1553 1554 data.path = input_name;1555 data.force = symbol_conf.force;1556 1557 symbol_conf.skip_empty = report.skip_empty;1558 1559repeat:1560 perf_tool__init(&report.tool, ordered_events);1561 report.tool.sample = process_sample_event;1562 report.tool.mmap = perf_event__process_mmap;1563 report.tool.mmap2 = perf_event__process_mmap2;1564 report.tool.comm = perf_event__process_comm;1565 report.tool.namespaces = perf_event__process_namespaces;1566 report.tool.cgroup = perf_event__process_cgroup;1567 report.tool.exit = perf_event__process_exit;1568 report.tool.fork = perf_event__process_fork;1569 report.tool.lost = perf_event__process_lost;1570 report.tool.read = process_read_event;1571 report.tool.attr = process_attr;1572#ifdef HAVE_LIBTRACEEVENT1573 report.tool.tracing_data = perf_event__process_tracing_data;1574#endif1575 report.tool.build_id = perf_event__process_build_id;1576 report.tool.id_index = perf_event__process_id_index;1577 report.tool.auxtrace_info = perf_event__process_auxtrace_info;1578 report.tool.auxtrace = perf_event__process_auxtrace;1579 report.tool.event_update = perf_event__process_event_update;1580 report.tool.feature = process_feature_event;1581 report.tool.ordering_requires_timestamps = true;1582 1583 session = perf_session__new(&data, &report.tool);1584 if (IS_ERR(session)) {1585 ret = PTR_ERR(session);1586 goto exit;1587 }1588 1589 ret = evswitch__init(&report.evswitch, session->evlist, stderr);1590 if (ret)1591 goto exit;1592 1593 if (zstd_init(&(session->zstd_data), 0) < 0)1594 pr_warning("Decompression initialization failed. Reported data may be incomplete.\n");1595 1596 if (report.queue_size) {1597 ordered_events__set_alloc_size(&session->ordered_events,1598 report.queue_size);1599 }1600 1601 session->itrace_synth_opts = &itrace_synth_opts;1602 1603 report.session = session;1604 1605 has_br_stack = perf_header__has_feat(&session->header,1606 HEADER_BRANCH_STACK);1607 if (evlist__combined_sample_type(session->evlist) & PERF_SAMPLE_STACK_USER)1608 has_br_stack = false;1609 1610 setup_forced_leader(&report, session->evlist);1611 1612 if (symbol_conf.group_sort_idx && evlist__nr_groups(session->evlist) == 0) {1613 parse_options_usage(NULL, options, "group-sort-idx", 0);1614 ret = -EINVAL;1615 goto error;1616 }1617 1618 if (itrace_synth_opts.last_branch || itrace_synth_opts.add_last_branch)1619 has_br_stack = true;1620 1621 if (has_br_stack && branch_call_mode)1622 symbol_conf.show_branchflag_count = true;1623 1624 memset(&report.brtype_stat, 0, sizeof(struct branch_type_stat));1625 1626 /*1627 * Branch mode is a tristate:1628 * -1 means default, so decide based on the file having branch data.1629 * 0/1 means the user chose a mode.1630 */1631 if (((branch_mode == -1 && has_br_stack) || branch_mode == 1) &&1632 !branch_call_mode) {1633 sort__mode = SORT_MODE__BRANCH;1634 symbol_conf.cumulate_callchain = false;1635 }1636 if (branch_call_mode) {1637 callchain_param.key = CCKEY_ADDRESS;1638 callchain_param.branch_callstack = true;1639 symbol_conf.use_callchain = true;1640 callchain_register_param(&callchain_param);1641 if (sort_order == NULL)1642 sort_order = "srcline,symbol,dso";1643 }1644 1645 if (report.mem_mode) {1646 if (sort__mode == SORT_MODE__BRANCH) {1647 pr_err("branch and mem mode incompatible\n");1648 goto error;1649 }1650 sort__mode = SORT_MODE__MEMORY;1651 symbol_conf.cumulate_callchain = false;1652 }1653 1654 if (symbol_conf.report_hierarchy) {1655 /* disable incompatible options */1656 symbol_conf.cumulate_callchain = false;1657 1658 if (field_order) {1659 pr_err("Error: --hierarchy and --fields options cannot be used together\n");1660 parse_options_usage(report_usage, options, "F", 1);1661 parse_options_usage(NULL, options, "hierarchy", 0);1662 goto error;1663 }1664 1665 perf_hpp_list.need_collapse = true;1666 }1667 1668 if (report.use_stdio)1669 use_browser = 0;1670#ifdef HAVE_SLANG_SUPPORT1671 else if (report.use_tui)1672 use_browser = 1;1673#endif1674#ifdef HAVE_GTK2_SUPPORT1675 else if (report.use_gtk)1676 use_browser = 2;1677#endif1678 1679 /* Force tty output for header output and per-thread stat. */1680 if (report.header || report.header_only || report.show_threads)1681 use_browser = 0;1682 if (report.header || report.header_only)1683 report.tool.show_feat_hdr = SHOW_FEAT_HEADER;1684 if (report.show_full_info)1685 report.tool.show_feat_hdr = SHOW_FEAT_HEADER_FULL_INFO;1686 if (report.stats_mode || report.tasks_mode)1687 use_browser = 0;1688 if (report.stats_mode && report.tasks_mode) {1689 pr_err("Error: --tasks and --mmaps can't be used together with --stats\n");1690 goto error;1691 }1692 1693 if (report.total_cycles_mode) {1694 if (sort__mode != SORT_MODE__BRANCH)1695 report.total_cycles_mode = false;1696 else1697 sort_order = NULL;1698 }1699 1700 if (sort_order && strstr(sort_order, "type")) {1701 report.data_type = true;1702 annotate_opts.annotate_src = false;1703 1704#ifndef HAVE_DWARF_GETLOCATIONS_SUPPORT1705 pr_err("Error: Data type profiling is disabled due to missing DWARF support\n");1706 goto error;1707#endif1708 }1709 1710 if (strcmp(input_name, "-") != 0)1711 setup_browser(true);1712 else1713 use_browser = 0;1714 1715 if (report.data_type && use_browser == 1) {1716 symbol_conf.annotate_data_member = true;1717 symbol_conf.annotate_data_sample = true;1718 }1719 1720 if (sort_order && strstr(sort_order, "ipc")) {1721 parse_options_usage(report_usage, options, "s", 1);1722 goto error;1723 }1724 1725 if (sort_order && strstr(sort_order, "symbol")) {1726 if (sort__mode == SORT_MODE__BRANCH) {1727 snprintf(sort_tmp, sizeof(sort_tmp), "%s,%s",1728 sort_order, "ipc_lbr");1729 report.symbol_ipc = true;1730 } else {1731 snprintf(sort_tmp, sizeof(sort_tmp), "%s,%s",1732 sort_order, "ipc_null");1733 }1734 1735 sort_order = sort_tmp;1736 }1737 1738 if ((last_key != K_SWITCH_INPUT_DATA && last_key != K_RELOAD) &&1739 (setup_sorting(session->evlist) < 0)) {1740 if (sort_order)1741 parse_options_usage(report_usage, options, "s", 1);1742 if (field_order)1743 parse_options_usage(sort_order ? NULL : report_usage,1744 options, "F", 1);1745 goto error;1746 }1747 1748 if ((report.header || report.header_only) && !quiet) {1749 perf_session__fprintf_info(session, stdout,1750 report.show_full_info);1751 if (report.header_only) {1752 if (data.is_pipe) {1753 /*1754 * we need to process first few records1755 * which contains PERF_RECORD_HEADER_FEATURE.1756 */1757 perf_session__process_events(session);1758 }1759 ret = 0;1760 goto error;1761 }1762 } else if (use_browser == 0 && !quiet &&1763 !report.stats_mode && !report.tasks_mode) {1764 fputs("# To display the perf.data header info, please use --header/--header-only options.\n#\n",1765 stdout);1766 }1767 1768 /*1769 * Only in the TUI browser we are doing integrated annotation,1770 * so don't allocate extra space that won't be used in the stdio1771 * implementation.1772 */1773 if (ui__has_annotation() || report.symbol_ipc || report.data_type ||1774 report.total_cycles_mode) {1775 ret = symbol__annotation_init();1776 if (ret < 0)1777 goto error;1778 /*1779 * For searching by name on the "Browse map details".1780 * providing it only in verbose mode not to bloat too1781 * much struct symbol.1782 */1783 if (verbose > 0) {1784 /*1785 * XXX: Need to provide a less kludgy way to ask for1786 * more space per symbol, the u32 is for the index on1787 * the ui browser.1788 * See symbol__browser_index.1789 */1790 symbol_conf.priv_size += sizeof(u32);1791 }1792 annotation_config__init();1793 }1794 1795 if (symbol__init(&session->header.env) < 0)1796 goto error;1797 1798 if (report.time_str) {1799 ret = perf_time__parse_for_ranges(report.time_str, session,1800 &report.ptime_range,1801 &report.range_size,1802 &report.range_num);1803 if (ret < 0)1804 goto error;1805 1806 itrace_synth_opts__set_time_range(&itrace_synth_opts,1807 report.ptime_range,1808 report.range_num);1809 }1810 1811#ifdef HAVE_LIBTRACEEVENT1812 if (session->tevent.pevent &&1813 tep_set_function_resolver(session->tevent.pevent,1814 machine__resolve_kernel_addr,1815 &session->machines.host) < 0) {1816 pr_err("%s: failed to set libtraceevent function resolver\n",1817 __func__);1818 return -1;1819 }1820#endif1821 sort__setup_elide(stdout);1822 1823 ret = __cmd_report(&report);1824 if (ret == K_SWITCH_INPUT_DATA || ret == K_RELOAD) {1825 perf_session__delete(session);1826 last_key = K_SWITCH_INPUT_DATA;1827 goto repeat;1828 } else1829 ret = 0;1830 1831 if (!use_browser && (verbose > 2 || debug_kmaps))1832 perf_session__dump_kmaps(session);1833error:1834 if (report.ptime_range) {1835 itrace_synth_opts__clear_time_range(&itrace_synth_opts);1836 zfree(&report.ptime_range);1837 }1838 1839 if (report.block_reports) {1840 block_info__free_report(report.block_reports,1841 report.nr_block_reports);1842 report.block_reports = NULL;1843 }1844 1845 zstd_fini(&(session->zstd_data));1846 perf_session__delete(session);1847exit:1848 annotation_options__exit();1849 free(sort_order_help);1850 free(field_order_help);1851 return ret;1852}1853