tools/perf/builtin-report.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * builtin-report.c
   4  *
   5  * Builtin report command: Analyze the perf.data input file,
   6  * look up and read DSOs and symbol information and display
   7  * a histogram of results, along various sorting keys.
   8  */
   9 #include "builtin.h"
  10
  11 #include "util/util.h"
  12 #include "util/config.h"
  13
  14 #include "util/annotate.h"
  15 #include "util/color.h"
  16 #include <linux/list.h>
  17 #include <linux/rbtree.h>
  18 #include <linux/err.h>
  19 #include "util/map.h"
  20 #include "util/symbol.h"
  21 #include "util/callchain.h"
  22 #include "util/values.h"
  23
  24 #include "perf.h"
  25 #include "util/debug.h"
  26 #include "util/evlist.h"
  27 #include "util/evsel.h"
  28 #include "util/header.h"
  29 #include "util/session.h"
  30 #include "util/tool.h"
  31
  32 #include <subcmd/parse-options.h>
  33 #include <subcmd/exec-cmd.h>
  34 #include "util/parse-events.h"
  35
  36 #include "util/thread.h"
  37 #include "util/sort.h"
  38 #include "util/hist.h"
  39 #include "util/data.h"
  40 #include "arch/common.h"
  41 #include "util/time-utils.h"
  42 #include "util/auxtrace.h"
  43 #include "util/units.h"
  44 #include "util/branch.h"
  45
  46 #include <dlfcn.h>
  47 #include <errno.h>
  48 #include <inttypes.h>
  49 #include <regex.h>
  50 #include "sane_ctype.h"
  51 #include <signal.h>
  52 #include <linux/bitmap.h>
  53 #include <linux/stringify.h>
  54 #include <linux/time64.h>
  55 #include <sys/types.h>
  56 #include <sys/stat.h>
  57 #include <unistd.h>
  58 #include <linux/mman.h>
  59
  60 struct report {
  61         struct perf_tool        tool;
  62         struct perf_session     *session;
  63         bool                    use_tui, use_gtk, use_stdio;
  64         bool                    show_full_info;
  65         bool                    show_threads;
  66         bool                    inverted_callchain;
  67         bool                    mem_mode;
  68         bool                    stats_mode;
  69         bool                    tasks_mode;
  70         bool                    mmaps_mode;
  71         bool                    header;
  72         bool                    header_only;
  73         bool                    nonany_branch_mode;
  74         bool                    group_set;
  75         int                     max_stack;
  76         struct perf_read_values show_threads_values;
  77         struct annotation_options annotation_opts;
  78         const char              *pretty_printing_style;
  79         const char              *cpu_list;
  80         const char              *symbol_filter_str;
  81         const char              *time_str;
  82         struct perf_time_interval *ptime_range;
  83         int                     range_size;
  84         int                     range_num;
  85         float                   min_percent;
  86         u64                     nr_entries;
  87         u64                     queue_size;
  88         int                     socket_filter;
  89         DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
  90         struct branch_type_stat brtype_stat;
  91         bool                    symbol_ipc;
  92 };
  93
  94 static int report__config(const char *var, const char *value, void *cb)
  95 {
  96         struct report *rep = cb;
  97
  98         if (!strcmp(var, "report.group")) {
  99                 symbol_conf.event_group = perf_config_bool(var, value);
 100                 return 0;
 101         }
 102         if (!strcmp(var, "report.percent-limit")) {
 103                 double pcnt = strtof(value, NULL);
 104
 105                 rep->min_percent = pcnt;
 106                 callchain_param.min_percent = pcnt;
 107                 return 0;
 108         }
 109         if (!strcmp(var, "report.children")) {
 110                 symbol_conf.cumulate_callchain = perf_config_bool(var, value);
 111                 return 0;
 112         }
 113         if (!strcmp(var, "report.queue-size"))
 114                 return perf_config_u64(&rep->queue_size, var, value);
 115
 116         if (!strcmp(var, "report.sort_order")) {
 117                 default_sort_order = strdup(value);
 118                 return 0;
 119         }
 120
 121         return 0;
 122 }
 123
 124 static int hist_iter__report_callback(struct hist_entry_iter *iter,
 125                                       struct addr_location *al, bool single,
 126                                       void *arg)
 127 {
 128         int err = 0;
 129         struct report *rep = arg;
 130         struct hist_entry *he = iter->he;
 131         struct perf_evsel *evsel = iter->evsel;
 132         struct perf_sample *sample = iter->sample;
 133         struct mem_info *mi;
 134         struct branch_info *bi;
 135
 136         if (!ui__has_annotation() && !rep->symbol_ipc)
 137                 return 0;
 138
 139         hist__account_cycles(sample->branch_stack, al, sample,
 140                              rep->nonany_branch_mode);
 141
 142         if (sort__mode == SORT_MODE__BRANCH) {
 143                 bi = he->branch_info;
 144                 err = addr_map_symbol__inc_samples(&bi->from, sample, evsel);
 145                 if (err)
 146                         goto out;
 147
 148                 err = addr_map_symbol__inc_samples(&bi->to, sample, evsel);
 149
 150         } else if (rep->mem_mode) {
 151                 mi = he->mem_info;
 152                 err = addr_map_symbol__inc_samples(&mi->daddr, sample, evsel);
 153                 if (err)
 154                         goto out;
 155
 156                 err = hist_entry__inc_addr_samples(he, sample, evsel, al->addr);
 157
 158         } else if (symbol_conf.cumulate_callchain) {
 159                 if (single)
 160                         err = hist_entry__inc_addr_samples(he, sample, evsel, al->addr);
 161         } else {
 162                 err = hist_entry__inc_addr_samples(he, sample, evsel, al->addr);
 163         }
 164
 165 out:
 166         return err;
 167 }
 168
 169 static int hist_iter__branch_callback(struct hist_entry_iter *iter,
 170                                       struct addr_location *al __maybe_unused,
 171                                       bool single __maybe_unused,
 172                                       void *arg)
 173 {
 174         struct hist_entry *he = iter->he;
 175         struct report *rep = arg;
 176         struct branch_info *bi;
 177         struct perf_sample *sample = iter->sample;
 178         struct perf_evsel *evsel = iter->evsel;
 179         int err;
 180
 181         if (!ui__has_annotation() && !rep->symbol_ipc)
 182                 return 0;
 183
 184         hist__account_cycles(sample->branch_stack, al, sample,
 185                              rep->nonany_branch_mode);
 186
 187         bi = he->branch_info;
 188         err = addr_map_symbol__inc_samples(&bi->from, sample, evsel);
 189         if (err)
 190                 goto out;
 191
 192         err = addr_map_symbol__inc_samples(&bi->to, sample, evsel);
 193
 194         branch_type_count(&rep->brtype_stat, &bi->flags,
 195                           bi->from.addr, bi->to.addr);
 196
 197 out:
 198         return err;
 199 }
 200
 201 static void setup_forced_leader(struct report *report,
 202                                 struct perf_evlist *evlist)
 203 {
 204         if (report->group_set)
 205                 perf_evlist__force_leader(evlist);
 206 }
 207
 208 static int process_feature_event(struct perf_session *session,
 209                                  union perf_event *event)
 210 {
 211         struct report *rep = container_of(session->tool, struct report, tool);
 212
 213         if (event->feat.feat_id < HEADER_LAST_FEATURE)
 214                 return perf_event__process_feature(session, event);
 215
 216         if (event->feat.feat_id != HEADER_LAST_FEATURE) {
 217                 pr_err("failed: wrong feature ID: %" PRIu64 "\n",
 218                        event->feat.feat_id);
 219                 return -1;
 220         }
 221
 222         /*
 223          * (feat_id = HEADER_LAST_FEATURE) is the end marker which
 224          * means all features are received, now we can force the
 225          * group if needed.
 226          */
 227         setup_forced_leader(rep, session->evlist);
 228         return 0;
 229 }
 230
 231 static int process_sample_event(struct perf_tool *tool,
 232                                 union perf_event *event,
 233                                 struct perf_sample *sample,
 234                                 struct perf_evsel *evsel,
 235                                 struct machine *machine)
 236 {
 237         struct report *rep = container_of(tool, struct report, tool);
 238         struct addr_location al;
 239         struct hist_entry_iter iter = {
 240                 .evsel                  = evsel,
 241                 .sample                 = sample,
 242                 .hide_unresolved        = symbol_conf.hide_unresolved,
 243                 .add_entry_cb           = hist_iter__report_callback,
 244         };
 245         int ret = 0;
 246
 247         if (perf_time__ranges_skip_sample(rep->ptime_range, rep->range_num,
 248                                           sample->time)) {
 249                 return 0;
 250         }
 251
 252         if (machine__resolve(machine, &al, sample) < 0) {
 253                 pr_debug("problem processing %d event, skipping it.\n",
 254                          event->header.type);
 255                 return -1;
 256         }
 257
 258         if (symbol_conf.hide_unresolved && al.sym == NULL)
 259                 goto out_put;
 260
 261         if (rep->cpu_list && !test_bit(sample->cpu, rep->cpu_bitmap))
 262                 goto out_put;
 263
 264         if (sort__mode == SORT_MODE__BRANCH) {
 265                 /*
 266                  * A non-synthesized event might not have a branch stack if
 267                  * branch stacks have been synthesized (using itrace options).
 268                  */
 269                 if (!sample->branch_stack)
 270                         goto out_put;
 271
 272                 iter.add_entry_cb = hist_iter__branch_callback;
 273                 iter.ops = &hist_iter_branch;
 274         } else if (rep->mem_mode) {
 275                 iter.ops = &hist_iter_mem;
 276         } else if (symbol_conf.cumulate_callchain) {
 277                 iter.ops = &hist_iter_cumulative;
 278         } else {
 279                 iter.ops = &hist_iter_normal;
 280         }
 281
 282         if (al.map != NULL)
 283                 al.map->dso->hit = 1;
 284
 285         ret = hist_entry_iter__add(&iter, &al, rep->max_stack, rep);
 286         if (ret < 0)
 287                 pr_debug("problem adding hist entry, skipping event\n");
 288 out_put:
 289         addr_location__put(&al);
 290         return ret;
 291 }
 292
 293 static int process_read_event(struct perf_tool *tool,
 294                               union perf_event *event,
 295                               struct perf_sample *sample __maybe_unused,
 296                               struct perf_evsel *evsel,
 297                               struct machine *machine __maybe_unused)
 298 {
 299         struct report *rep = container_of(tool, struct report, tool);
 300
 301         if (rep->show_threads) {
 302                 const char *name = evsel ? perf_evsel__name(evsel) : "unknown";
 303                 int err = perf_read_values_add_value(&rep->show_threads_values,
 304                                            event->read.pid, event->read.tid,
 305                                            evsel->idx,
 306                                            name,
 307                                            event->read.value);
 308
 309                 if (err)
 310                         return err;
 311         }
 312
 313         return 0;
 314 }
 315
 316 /* For pipe mode, sample_type is not currently set */
 317 static int report__setup_sample_type(struct report *rep)
 318 {
 319         struct perf_session *session = rep->session;
 320         u64 sample_type = perf_evlist__combined_sample_type(session->evlist);
 321         bool is_pipe = perf_data__is_pipe(session->data);
 322
 323         if (session->itrace_synth_opts->callchain ||
 324             (!is_pipe &&
 325              perf_header__has_feat(&session->header, HEADER_AUXTRACE) &&
 326              !session->itrace_synth_opts->set))
 327                 sample_type |= PERF_SAMPLE_CALLCHAIN;
 328
 329         if (session->itrace_synth_opts->last_branch)
 330                 sample_type |= PERF_SAMPLE_BRANCH_STACK;
 331
 332         if (!is_pipe && !(sample_type & PERF_SAMPLE_CALLCHAIN)) {
 333                 if (perf_hpp_list.parent) {
 334                         ui__error("Selected --sort parent, but no "
 335                                     "callchain data. Did you call "
 336                                     "'perf record' without -g?\n");
 337                         return -EINVAL;
 338                 }
 339                 if (symbol_conf.use_callchain &&
 340                         !symbol_conf.show_branchflag_count) {
 341                         ui__error("Selected -g or --branch-history.\n"
 342                                   "But no callchain or branch data.\n"
 343                                   "Did you call 'perf record' without -g or -b?\n");
 344                         return -1;
 345                 }
 346         } else if (!callchain_param.enabled &&
 347                    callchain_param.mode != CHAIN_NONE &&
 348                    !symbol_conf.use_callchain) {
 349                         symbol_conf.use_callchain = true;
 350                         if (callchain_register_param(&callchain_param) < 0) {
 351                                 ui__error("Can't register callchain params.\n");
 352                                 return -EINVAL;
 353                         }
 354         }
 355
 356         if (symbol_conf.cumulate_callchain) {
 357                 /* Silently ignore if callchain is missing */
 358                 if (!(sample_type & PERF_SAMPLE_CALLCHAIN)) {
 359                         symbol_conf.cumulate_callchain = false;
 360                         perf_hpp__cancel_cumulate();
 361                 }
 362         }
 363
 364         if (sort__mode == SORT_MODE__BRANCH) {
 365                 if (!is_pipe &&
 366                     !(sample_type & PERF_SAMPLE_BRANCH_STACK)) {
 367                         ui__error("Selected -b but no branch data. "
 368                                   "Did you call perf record without -b?\n");
 369                         return -1;
 370                 }
 371         }
 372
 373         if (symbol_conf.use_callchain || symbol_conf.cumulate_callchain) {
 374                 if ((sample_type & PERF_SAMPLE_REGS_USER) &&
 375                     (sample_type & PERF_SAMPLE_STACK_USER)) {
 376                         callchain_param.record_mode = CALLCHAIN_DWARF;
 377                         dwarf_callchain_users = true;
 378                 } else if (sample_type & PERF_SAMPLE_BRANCH_STACK)
 379                         callchain_param.record_mode = CALLCHAIN_LBR;
 380                 else
 381                         callchain_param.record_mode = CALLCHAIN_FP;
 382         }
 383
 384         /* ??? handle more cases than just ANY? */
 385         if (!(perf_evlist__combined_branch_type(session->evlist) &
 386                                 PERF_SAMPLE_BRANCH_ANY))
 387                 rep->nonany_branch_mode = true;
 388
 389         return 0;
 390 }
 391
 392 static void sig_handler(int sig __maybe_unused)
 393 {
 394         session_done = 1;
 395 }
 396
 397 static size_t hists__fprintf_nr_sample_events(struct hists *hists, struct report *rep,
 398                                               const char *evname, FILE *fp)
 399 {
 400         size_t ret;
 401         char unit;
 402         unsigned long nr_samples = hists->stats.nr_events[PERF_RECORD_SAMPLE];
 403         u64 nr_events = hists->stats.total_period;
 404         struct perf_evsel *evsel = hists_to_evsel(hists);
 405         char buf[512];
 406         size_t size = sizeof(buf);
 407         int socked_id = hists->socket_filter;
 408
 409         if (quiet)
 410                 return 0;
 411
 412         if (symbol_conf.filter_relative) {
 413                 nr_samples = hists->stats.nr_non_filtered_samples;
 414                 nr_events = hists->stats.total_non_filtered_period;
 415         }
 416
 417         if (perf_evsel__is_group_event(evsel)) {
 418                 struct perf_evsel *pos;
 419
 420                 perf_evsel__group_desc(evsel, buf, size);
 421                 evname = buf;
 422
 423                 for_each_group_member(pos, evsel) {
 424                         const struct hists *pos_hists = evsel__hists(pos);
 425
 426                         if (symbol_conf.filter_relative) {
 427                                 nr_samples += pos_hists->stats.nr_non_filtered_samples;
 428                                 nr_events += pos_hists->stats.total_non_filtered_period;
 429                         } else {
 430                                 nr_samples += pos_hists->stats.nr_events[PERF_RECORD_SAMPLE];
 431                                 nr_events += pos_hists->stats.total_period;
 432                         }
 433                 }
 434         }
 435
 436         nr_samples = convert_unit(nr_samples, &unit);
 437         ret = fprintf(fp, "# Samples: %lu%c", nr_samples, unit);
 438         if (evname != NULL) {
 439                 ret += fprintf(fp, " of event%s '%s'",
 440                                evsel->nr_members > 1 ? "s" : "", evname);
 441         }
 442
 443         if (rep->time_str)
 444                 ret += fprintf(fp, " (time slices: %s)", rep->time_str);
 445
 446         if (symbol_conf.show_ref_callgraph &&
 447             strstr(evname, "call-graph=no")) {
 448                 ret += fprintf(fp, ", show reference callgraph");
 449         }
 450
 451         if (rep->mem_mode) {
 452                 ret += fprintf(fp, "\n# Total weight : %" PRIu64, nr_events);
 453                 ret += fprintf(fp, "\n# Sort order   : %s", sort_order ? : default_mem_sort_order);
 454         } else
 455                 ret += fprintf(fp, "\n# Event count (approx.): %" PRIu64, nr_events);
 456
 457         if (socked_id > -1)
 458                 ret += fprintf(fp, "\n# Processor Socket: %d", socked_id);
 459
 460         return ret + fprintf(fp, "\n#\n");
 461 }
 462
 463 static int perf_evlist__tty_browse_hists(struct perf_evlist *evlist,
 464                                          struct report *rep,
 465                                          const char *help)
 466 {
 467         struct perf_evsel *pos;
 468
 469         if (!quiet) {
 470                 fprintf(stdout, "#\n# Total Lost Samples: %" PRIu64 "\n#\n",
 471                         evlist->stats.total_lost_samples);
 472         }
 473
 474         evlist__for_each_entry(evlist, pos) {
 475                 struct hists *hists = evsel__hists(pos);
 476                 const char *evname = perf_evsel__name(pos);
 477
 478                 if (symbol_conf.event_group &&
 479                     !perf_evsel__is_group_leader(pos))
 480                         continue;
 481
 482                 hists__fprintf_nr_sample_events(hists, rep, evname, stdout);
 483                 hists__fprintf(hists, !quiet, 0, 0, rep->min_percent, stdout,
 484                                !(symbol_conf.use_callchain ||
 485                                  symbol_conf.show_branchflag_count));
 486                 fprintf(stdout, "\n\n");
 487         }
 488
 489         if (!quiet)
 490                 fprintf(stdout, "#\n# (%s)\n#\n", help);
 491
 492         if (rep->show_threads) {
 493                 bool style = !strcmp(rep->pretty_printing_style, "raw");
 494                 perf_read_values_display(stdout, &rep->show_threads_values,
 495                                          style);
 496                 perf_read_values_destroy(&rep->show_threads_values);
 497         }
 498
 499         if (sort__mode == SORT_MODE__BRANCH)
 500                 branch_type_stat_display(stdout, &rep->brtype_stat);
 501
 502         return 0;
 503 }
 504
 505 static void report__warn_kptr_restrict(const struct report *rep)
 506 {
 507         struct map *kernel_map = machine__kernel_map(&rep->session->machines.host);
 508         struct kmap *kernel_kmap = kernel_map ? map__kmap(kernel_map) : NULL;
 509
 510         if (perf_evlist__exclude_kernel(rep->session->evlist))
 511                 return;
 512
 513         if (kernel_map == NULL ||
 514             (kernel_map->dso->hit &&
 515              (kernel_kmap->ref_reloc_sym == NULL ||
 516               kernel_kmap->ref_reloc_sym->addr == 0))) {
 517                 const char *desc =
 518                     "As no suitable kallsyms nor vmlinux was found, kernel samples\n"
 519                     "can't be resolved.";
 520
 521                 if (kernel_map && map__has_symbols(kernel_map)) {
 522                         desc = "If some relocation was applied (e.g. "
 523                                "kexec) symbols may be misresolved.";
 524                 }
 525
 526                 ui__warning(
 527 "Kernel address maps (/proc/{kallsyms,modules}) were restricted.\n\n"
 528 "Check /proc/sys/kernel/kptr_restrict before running 'perf record'.\n\n%s\n\n"
 529 "Samples in kernel modules can't be resolved as well.\n\n",
 530                 desc);
 531         }
 532 }
 533
 534 static int report__gtk_browse_hists(struct report *rep, const char *help)
 535 {
 536         int (*hist_browser)(struct perf_evlist *evlist, const char *help,
 537                             struct hist_browser_timer *timer, float min_pcnt);
 538
 539         hist_browser = dlsym(perf_gtk_handle, "perf_evlist__gtk_browse_hists");
 540
 541         if (hist_browser == NULL) {
 542                 ui__error("GTK browser not found!\n");
 543                 return -1;
 544         }
 545
 546         return hist_browser(rep->session->evlist, help, NULL, rep->min_percent);
 547 }
 548
 549 static int report__browse_hists(struct report *rep)
 550 {
 551         int ret;
 552         struct perf_session *session = rep->session;
 553         struct perf_evlist *evlist = session->evlist;
 554         const char *help = perf_tip(system_path(TIPDIR));
 555
 556         if (help == NULL) {
 557                 /* fallback for people who don't install perf ;-) */
 558                 help = perf_tip(DOCDIR);
 559                 if (help == NULL)
 560                         help = "Cannot load tips.txt file, please install perf!";
 561         }
 562
 563         switch (use_browser) {
 564         case 1:
 565                 ret = perf_evlist__tui_browse_hists(evlist, help, NULL,
 566                                                     rep->min_percent,
 567                                                     &session->header.env,
 568                                                     true, &rep->annotation_opts);
 569                 /*
 570                  * Usually "ret" is the last pressed key, and we only
 571                  * care if the key notifies us to switch data file.
 572                  */
 573                 if (ret != K_SWITCH_INPUT_DATA)
 574                         ret = 0;
 575                 break;
 576         case 2:
 577                 ret = report__gtk_browse_hists(rep, help);
 578                 break;
 579         default:
 580                 ret = perf_evlist__tty_browse_hists(evlist, rep, help);
 581                 break;
 582         }
 583
 584         return ret;
 585 }
 586
 587 static int report__collapse_hists(struct report *rep)
 588 {
 589         struct ui_progress prog;
 590         struct perf_evsel *pos;
 591         int ret = 0;
 592
 593         ui_progress__init(&prog, rep->nr_entries, "Merging related events...");
 594
 595         evlist__for_each_entry(rep->session->evlist, pos) {
 596                 struct hists *hists = evsel__hists(pos);
 597
 598                 if (pos->idx == 0)
 599                         hists->symbol_filter_str = rep->symbol_filter_str;
 600
 601                 hists->socket_filter = rep->socket_filter;
 602
 603                 ret = hists__collapse_resort(hists, &prog);
 604                 if (ret < 0)
 605                         break;
 606
 607                 /* Non-group events are considered as leader */
 608                 if (symbol_conf.event_group &&
 609                     !perf_evsel__is_group_leader(pos)) {
 610                         struct hists *leader_hists = evsel__hists(pos->leader);
 611
 612                         hists__match(leader_hists, hists);
 613                         hists__link(leader_hists, hists);
 614                 }
 615         }
 616
 617         ui_progress__finish();
 618         return ret;
 619 }
 620
 621 static int hists__resort_cb(struct hist_entry *he, void *arg)
 622 {
 623         struct report *rep = arg;
 624         struct symbol *sym = he->ms.sym;
 625
 626         if (rep->symbol_ipc && sym && !sym->annotate2) {
 627                 struct perf_evsel *evsel = hists_to_evsel(he->hists);
 628
 629                 symbol__annotate2(sym, he->ms.map, evsel,
 630                                   &annotation__default_options, NULL);
 631         }
 632
 633         return 0;
 634 }
 635
 636 static void report__output_resort(struct report *rep)
 637 {
 638         struct ui_progress prog;
 639         struct perf_evsel *pos;
 640
 641         ui_progress__init(&prog, rep->nr_entries, "Sorting events for output...");
 642
 643         evlist__for_each_entry(rep->session->evlist, pos) {
 644                 perf_evsel__output_resort_cb(pos, &prog,
 645                                              hists__resort_cb, rep);
 646         }
 647
 648         ui_progress__finish();
 649 }
 650
 651 static void stats_setup(struct report *rep)
 652 {
 653         memset(&rep->tool, 0, sizeof(rep->tool));
 654         rep->tool.no_warn = true;
 655 }
 656
 657 static int stats_print(struct report *rep)
 658 {
 659         struct perf_session *session = rep->session;
 660
 661         perf_session__fprintf_nr_events(session, stdout);
 662         return 0;
 663 }
 664
 665 static void tasks_setup(struct report *rep)
 666 {
 667         memset(&rep->tool, 0, sizeof(rep->tool));
 668         rep->tool.ordered_events = true;
 669         if (rep->mmaps_mode) {
 670                 rep->tool.mmap = perf_event__process_mmap;
 671                 rep->tool.mmap2 = perf_event__process_mmap2;
 672         }
 673         rep->tool.comm = perf_event__process_comm;
 674         rep->tool.exit = perf_event__process_exit;
 675         rep->tool.fork = perf_event__process_fork;
 676         rep->tool.no_warn = true;
 677 }
 678
 679 struct task {
 680         struct thread           *thread;
 681         struct list_head         list;
 682         struct list_head         children;
 683 };
 684
 685 static struct task *tasks_list(struct task *task, struct machine *machine)
 686 {
 687         struct thread *parent_thread, *thread = task->thread;
 688         struct task   *parent_task;
 689
 690         /* Already listed. */
 691         if (!list_empty(&task->list))
 692                 return NULL;
 693
 694         /* Last one in the chain. */
 695         if (thread->ppid == -1)
 696                 return task;
 697
 698         parent_thread = machine__find_thread(machine, -1, thread->ppid);
 699         if (!parent_thread)
 700                 return ERR_PTR(-ENOENT);
 701
 702         parent_task = thread__priv(parent_thread);
 703         list_add_tail(&task->list, &parent_task->children);
 704         return tasks_list(parent_task, machine);
 705 }
 706
 707 static size_t maps__fprintf_task(struct maps *maps, int indent, FILE *fp)
 708 {
 709         size_t printed = 0;
 710         struct rb_node *nd;
 711
 712         for (nd = rb_first(&maps->entries); nd; nd = rb_next(nd)) {
 713                 struct map *map = rb_entry(nd, struct map, rb_node);
 714
 715                 printed += fprintf(fp, "%*s  %" PRIx64 "-%" PRIx64 " %c%c%c%c %08" PRIx64 " %" PRIu64 " %s\n",
 716                                    indent, "", map->start, map->end,
 717                                    map->prot & PROT_READ ? 'r' : '-',
 718                                    map->prot & PROT_WRITE ? 'w' : '-',
 719                                    map->prot & PROT_EXEC ? 'x' : '-',
 720                                    map->flags & MAP_SHARED ? 's' : 'p',
 721                                    map->pgoff,
 722                                    map->ino, map->dso->name);
 723         }
 724
 725         return printed;
 726 }
 727
 728 static int map_groups__fprintf_task(struct map_groups *mg, int indent, FILE *fp)
 729 {
 730         return maps__fprintf_task(&mg->maps, indent, fp);
 731 }
 732
 733 static void task__print_level(struct task *task, FILE *fp, int level)
 734 {
 735         struct thread *thread = task->thread;
 736         struct task *child;
 737         int comm_indent = fprintf(fp, "  %8d %8d %8d |%*s",
 738                                   thread->pid_, thread->tid, thread->ppid,
 739                                   level, "");
 740
 741         fprintf(fp, "%s\n", thread__comm_str(thread));
 742
 743         map_groups__fprintf_task(thread->mg, comm_indent, fp);
 744
 745         if (!list_empty(&task->children)) {
 746                 list_for_each_entry(child, &task->children, list)
 747                         task__print_level(child, fp, level + 1);
 748         }
 749 }
 750
 751 static int tasks_print(struct report *rep, FILE *fp)
 752 {
 753         struct perf_session *session = rep->session;
 754         struct machine      *machine = &session->machines.host;
 755         struct task *tasks, *task;
 756         unsigned int nr = 0, itask = 0, i;
 757         struct rb_node *nd;
 758         LIST_HEAD(list);
 759
 760         /*
 761          * No locking needed while accessing machine->threads,
 762          * because --tasks is single threaded command.
 763          */
 764
 765         /* Count all the threads. */
 766         for (i = 0; i < THREADS__TABLE_SIZE; i++)
 767                 nr += machine->threads[i].nr;
 768
 769         tasks = malloc(sizeof(*tasks) * nr);
 770         if (!tasks)
 771                 return -ENOMEM;
 772
 773         for (i = 0; i < THREADS__TABLE_SIZE; i++) {
 774                 struct threads *threads = &machine->threads[i];
 775
 776                 for (nd = rb_first_cached(&threads->entries); nd;
 777                      nd = rb_next(nd)) {
 778                         task = tasks + itask++;
 779
 780                         task->thread = rb_entry(nd, struct thread, rb_node);
 781                         INIT_LIST_HEAD(&task->children);
 782                         INIT_LIST_HEAD(&task->list);
 783                         thread__set_priv(task->thread, task);
 784                 }
 785         }
 786
 787         /*
 788          * Iterate every task down to the unprocessed parent
 789          * and link all in task children list. Task with no
 790          * parent is added into 'list'.
 791          */
 792         for (itask = 0; itask < nr; itask++) {
 793                 task = tasks + itask;
 794
 795                 if (!list_empty(&task->list))
 796                         continue;
 797
 798                 task = tasks_list(task, machine);
 799                 if (IS_ERR(task)) {
 800                         pr_err("Error: failed to process tasks\n");
 801                         free(tasks);
 802                         return PTR_ERR(task);
 803                 }
 804
 805                 if (task)
 806                         list_add_tail(&task->list, &list);
 807         }
 808
 809         fprintf(fp, "# %8s %8s %8s  %s\n", "pid", "tid", "ppid", "comm");
 810
 811         list_for_each_entry(task, &list, list)
 812                 task__print_level(task, fp, 0);
 813
 814         free(tasks);
 815         return 0;
 816 }
 817
 818 static int __cmd_report(struct report *rep)
 819 {
 820         int ret;
 821         struct perf_session *session = rep->session;
 822         struct perf_evsel *pos;
 823         struct perf_data *data = session->data;
 824
 825         signal(SIGINT, sig_handler);
 826
 827         if (rep->cpu_list) {
 828                 ret = perf_session__cpu_bitmap(session, rep->cpu_list,
 829                                                rep->cpu_bitmap);
 830                 if (ret) {
 831                         ui__error("failed to set cpu bitmap\n");
 832                         return ret;
 833                 }
 834                 session->itrace_synth_opts->cpu_bitmap = rep->cpu_bitmap;
 835         }
 836
 837         if (rep->show_threads) {
 838                 ret = perf_read_values_init(&rep->show_threads_values);
 839                 if (ret)
 840                         return ret;
 841         }
 842
 843         ret = report__setup_sample_type(rep);
 844         if (ret) {
 845                 /* report__setup_sample_type() already showed error message */
 846                 return ret;
 847         }
 848
 849         if (rep->stats_mode)
 850                 stats_setup(rep);
 851
 852         if (rep->tasks_mode)
 853                 tasks_setup(rep);
 854
 855         ret = perf_session__process_events(session);
 856         if (ret) {
 857                 ui__error("failed to process sample\n");
 858                 return ret;
 859         }
 860
 861         if (rep->stats_mode)
 862                 return stats_print(rep);
 863
 864         if (rep->tasks_mode)
 865                 return tasks_print(rep, stdout);
 866
 867         report__warn_kptr_restrict(rep);
 868
 869         evlist__for_each_entry(session->evlist, pos)
 870                 rep->nr_entries += evsel__hists(pos)->nr_entries;
 871
 872         if (use_browser == 0) {
 873                 if (verbose > 3)
 874                         perf_session__fprintf(session, stdout);
 875
 876                 if (verbose > 2)
 877                         perf_session__fprintf_dsos(session, stdout);
 878
 879                 if (dump_trace) {
 880                         perf_session__fprintf_nr_events(session, stdout);
 881                         perf_evlist__fprintf_nr_events(session->evlist, stdout);
 882                         return 0;
 883                 }
 884         }
 885
 886         ret = report__collapse_hists(rep);
 887         if (ret) {
 888                 ui__error("failed to process hist entry\n");
 889                 return ret;
 890         }
 891
 892         if (session_done())
 893                 return 0;
 894
 895         /*
 896          * recalculate number of entries after collapsing since it
 897          * might be changed during the collapse phase.
 898          */
 899         rep->nr_entries = 0;
 900         evlist__for_each_entry(session->evlist, pos)
 901                 rep->nr_entries += evsel__hists(pos)->nr_entries;
 902
 903         if (rep->nr_entries == 0) {
 904                 ui__error("The %s data has no samples!\n", data->path);
 905                 return 0;
 906         }
 907
 908         report__output_resort(rep);
 909
 910         return report__browse_hists(rep);
 911 }
 912
 913 static int
 914 report_parse_callchain_opt(const struct option *opt, const char *arg, int unset)
 915 {
 916         struct callchain_param *callchain = opt->value;
 917
 918         callchain->enabled = !unset;
 919         /*
 920          * --no-call-graph
 921          */
 922         if (unset) {
 923                 symbol_conf.use_callchain = false;
 924                 callchain->mode = CHAIN_NONE;
 925                 return 0;
 926         }
 927
 928         return parse_callchain_report_opt(arg);
 929 }
 930
 931 static int
 932 parse_time_quantum(const struct option *opt, const char *arg,
 933                    int unset __maybe_unused)
 934 {
 935         unsigned long *time_q = opt->value;
 936         char *end;
 937
 938         *time_q = strtoul(arg, &end, 0);
 939         if (end == arg)
 940                 goto parse_err;
 941         if (*time_q == 0) {
 942                 pr_err("time quantum cannot be 0");
 943                 return -1;
 944         }
 945         while (isspace(*end))
 946                 end++;
 947         if (*end == 0)
 948                 return 0;
 949         if (!strcmp(end, "s")) {
 950                 *time_q *= NSEC_PER_SEC;
 951                 return 0;
 952         }
 953         if (!strcmp(end, "ms")) {
 954                 *time_q *= NSEC_PER_MSEC;
 955                 return 0;
 956         }
 957         if (!strcmp(end, "us")) {
 958                 *time_q *= NSEC_PER_USEC;
 959                 return 0;
 960         }
 961         if (!strcmp(end, "ns"))
 962                 return 0;
 963 parse_err:
 964         pr_err("Cannot parse time quantum `%s'\n", arg);
 965         return -1;
 966 }
 967
 968 int
 969 report_parse_ignore_callees_opt(const struct option *opt __maybe_unused,
 970                                 const char *arg, int unset __maybe_unused)
 971 {
 972         if (arg) {
 973                 int err = regcomp(&ignore_callees_regex, arg, REG_EXTENDED);
 974                 if (err) {
 975                         char buf[BUFSIZ];
 976                         regerror(err, &ignore_callees_regex, buf, sizeof(buf));
 977                         pr_err("Invalid --ignore-callees regex: %s\n%s", arg, buf);
 978                         return -1;
 979                 }
 980                 have_ignore_callees = 1;
 981         }
 982
 983         return 0;
 984 }
 985
 986 static int
 987 parse_branch_mode(const struct option *opt,
 988                   const char *str __maybe_unused, int unset)
 989 {
 990         int *branch_mode = opt->value;
 991
 992         *branch_mode = !unset;
 993         return 0;
 994 }
 995
 996 static int
 997 parse_percent_limit(const struct option *opt, const char *str,
 998                     int unset __maybe_unused)
 999 {
1000         struct report *rep = opt->value;
1001         double pcnt = strtof(str, NULL);
1002
1003         rep->min_percent = pcnt;
1004         callchain_param.min_percent = pcnt;
1005         return 0;
1006 }
1007
1008 int cmd_report(int argc, const char **argv)
1009 {
1010         struct perf_session *session;
1011         struct itrace_synth_opts itrace_synth_opts = { .set = 0, };
1012         struct stat st;
1013         bool has_br_stack = false;
1014         int branch_mode = -1;
1015         bool branch_call_mode = false;
1016 #define CALLCHAIN_DEFAULT_OPT  "graph,0.5,caller,function,percent"
1017         static const char report_callchain_help[] = "Display call graph (stack chain/backtrace):\n\n"
1018                                                     CALLCHAIN_REPORT_HELP
1019                                                     "\n\t\t\t\tDefault: " CALLCHAIN_DEFAULT_OPT;
1020         char callchain_default_opt[] = CALLCHAIN_DEFAULT_OPT;
1021         const char * const report_usage[] = {
1022                 "perf report [<options>]",
1023                 NULL
1024         };
1025         struct report report = {
1026                 .tool = {
1027                         .sample          = process_sample_event,
1028                         .mmap            = perf_event__process_mmap,
1029                         .mmap2           = perf_event__process_mmap2,
1030                         .comm            = perf_event__process_comm,
1031                         .namespaces      = perf_event__process_namespaces,
1032                         .exit            = perf_event__process_exit,
1033                         .fork            = perf_event__process_fork,
1034                         .lost            = perf_event__process_lost,
1035                         .read            = process_read_event,
1036                         .attr            = perf_event__process_attr,
1037                         .tracing_data    = perf_event__process_tracing_data,
1038                         .build_id        = perf_event__process_build_id,
1039                         .id_index        = perf_event__process_id_index,
1040                         .auxtrace_info   = perf_event__process_auxtrace_info,
1041                         .auxtrace        = perf_event__process_auxtrace,
1042                         .event_update    = perf_event__process_event_update,
1043                         .feature         = process_feature_event,
1044                         .ordered_events  = true,
1045                         .ordering_requires_timestamps = true,
1046                 },
1047                 .max_stack               = PERF_MAX_STACK_DEPTH,
1048                 .pretty_printing_style   = "normal",
1049                 .socket_filter           = -1,
1050                 .annotation_opts         = annotation__default_options,
1051         };
1052         const struct option options[] = {
1053         OPT_STRING('i', "input", &input_name, "file",
1054                     "input file name"),
1055         OPT_INCR('v', "verbose", &verbose,
1056                     "be more verbose (show symbol address, etc)"),
1057         OPT_BOOLEAN('q', "quiet", &quiet, "Do not show any message"),
1058         OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
1059                     "dump raw trace in ASCII"),
1060         OPT_BOOLEAN(0, "stats", &report.stats_mode, "Display event stats"),
1061         OPT_BOOLEAN(0, "tasks", &report.tasks_mode, "Display recorded tasks"),
1062         OPT_BOOLEAN(0, "mmaps", &report.mmaps_mode, "Display recorded tasks memory maps"),
1063         OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
1064                    "file", "vmlinux pathname"),
1065         OPT_BOOLEAN(0, "ignore-vmlinux", &symbol_conf.ignore_vmlinux,
1066                     "don't load vmlinux even if found"),
1067         OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name,
1068                    "file", "kallsyms pathname"),
1069         OPT_BOOLEAN('f', "force", &symbol_conf.force, "don't complain, do it"),
1070         OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
1071                     "load module symbols - WARNING: use only with -k and LIVE kernel"),
1072         OPT_BOOLEAN('n', "show-nr-samples", &symbol_conf.show_nr_samples,
1073                     "Show a column with the number of samples"),
1074         OPT_BOOLEAN('T', "threads", &report.show_threads,
1075                     "Show per-thread event counters"),
1076         OPT_STRING(0, "pretty", &report.pretty_printing_style, "key",
1077                    "pretty printing style key: normal raw"),
1078         OPT_BOOLEAN(0, "tui", &report.use_tui, "Use the TUI interface"),
1079         OPT_BOOLEAN(0, "gtk", &report.use_gtk, "Use the GTK2 interface"),
1080         OPT_BOOLEAN(0, "stdio", &report.use_stdio,
1081                     "Use the stdio interface"),
1082         OPT_BOOLEAN(0, "header", &report.header, "Show data header."),
1083         OPT_BOOLEAN(0, "header-only", &report.header_only,
1084                     "Show only data header."),
1085         OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
1086                    "sort by key(s): pid, comm, dso, symbol, parent, cpu, srcline, ..."
1087                    " Please refer the man page for the complete list."),
1088         OPT_STRING('F', "fields", &field_order, "key[,keys...]",
1089                    "output field(s): overhead, period, sample plus all of sort keys"),
1090         OPT_BOOLEAN(0, "show-cpu-utilization", &symbol_conf.show_cpu_utilization,
1091                     "Show sample percentage for different cpu modes"),
1092         OPT_BOOLEAN_FLAG(0, "showcpuutilization", &symbol_conf.show_cpu_utilization,
1093                     "Show sample percentage for different cpu modes", PARSE_OPT_HIDDEN),
1094         OPT_STRING('p', "parent", &parent_pattern, "regex",
1095                    "regex filter to identify parent, see: '--sort parent'"),
1096         OPT_BOOLEAN('x', "exclude-other", &symbol_conf.exclude_other,
1097                     "Only display entries with parent-match"),
1098         OPT_CALLBACK_DEFAULT('g', "call-graph", &callchain_param,
1099                              "print_type,threshold[,print_limit],order,sort_key[,branch],value",
1100                              report_callchain_help, &report_parse_callchain_opt,
1101                              callchain_default_opt),
1102         OPT_BOOLEAN(0, "children", &symbol_conf.cumulate_callchain,
1103                     "Accumulate callchains of children and show total overhead as well"),
1104         OPT_INTEGER(0, "max-stack", &report.max_stack,
1105                     "Set the maximum stack depth when parsing the callchain, "
1106                     "anything beyond the specified depth will be ignored. "
1107                     "Default: kernel.perf_event_max_stack or " __stringify(PERF_MAX_STACK_DEPTH)),
1108         OPT_BOOLEAN('G', "inverted", &report.inverted_callchain,
1109                     "alias for inverted call graph"),
1110         OPT_CALLBACK(0, "ignore-callees", NULL, "regex",
1111                    "ignore callees of these functions in call graphs",
1112                    report_parse_ignore_callees_opt),
1113         OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
1114                    "only consider symbols in these dsos"),
1115         OPT_STRING('c', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
1116                    "only consider symbols in these comms"),
1117         OPT_STRING(0, "pid", &symbol_conf.pid_list_str, "pid[,pid...]",
1118                    "only consider symbols in these pids"),
1119         OPT_STRING(0, "tid", &symbol_conf.tid_list_str, "tid[,tid...]",
1120                    "only consider symbols in these tids"),
1121         OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
1122                    "only consider these symbols"),
1123         OPT_STRING(0, "symbol-filter", &report.symbol_filter_str, "filter",
1124                    "only show symbols that (partially) match with this filter"),
1125         OPT_STRING('w', "column-widths", &symbol_conf.col_width_list_str,
1126                    "width[,width...]",
1127                    "don't try to adjust column width, use these fixed values"),
1128         OPT_STRING_NOEMPTY('t', "field-separator", &symbol_conf.field_sep, "separator",
1129                    "separator for columns, no spaces will be added between "
1130                    "columns '.' is reserved."),
1131         OPT_BOOLEAN('U', "hide-unresolved", &symbol_conf.hide_unresolved,
1132                     "Only display entries resolved to a symbol"),
1133         OPT_CALLBACK(0, "symfs", NULL, "directory",
1134                      "Look for files with symbols relative to this directory",
1135                      symbol__config_symfs),
1136         OPT_STRING('C', "cpu", &report.cpu_list, "cpu",
1137                    "list of cpus to profile"),
1138         OPT_BOOLEAN('I', "show-info", &report.show_full_info,
1139                     "Display extended information about perf.data file"),
1140         OPT_BOOLEAN(0, "source", &report.annotation_opts.annotate_src,
1141                     "Interleave source code with assembly code (default)"),
1142         OPT_BOOLEAN(0, "asm-raw", &report.annotation_opts.show_asm_raw,
1143                     "Display raw encoding of assembly instructions (default)"),
1144         OPT_STRING('M', "disassembler-style", &report.annotation_opts.disassembler_style, "disassembler style",
1145                    "Specify disassembler style (e.g. -M intel for intel syntax)"),
1146         OPT_BOOLEAN(0, "show-total-period", &symbol_conf.show_total_period,
1147                     "Show a column with the sum of periods"),
1148         OPT_BOOLEAN_SET(0, "group", &symbol_conf.event_group, &report.group_set,
1149                     "Show event group information together"),
1150         OPT_CALLBACK_NOOPT('b', "branch-stack", &branch_mode, "",
1151                     "use branch records for per branch histogram filling",
1152                     parse_branch_mode),
1153         OPT_BOOLEAN(0, "branch-history", &branch_call_mode,
1154                     "add last branch records to call history"),
1155         OPT_STRING(0, "objdump", &report.annotation_opts.objdump_path, "path",
1156                    "objdump binary to use for disassembly and annotations"),
1157         OPT_BOOLEAN(0, "demangle", &symbol_conf.demangle,
1158                     "Disable symbol demangling"),
1159         OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf.demangle_kernel,
1160                     "Enable kernel symbol demangling"),
1161         OPT_BOOLEAN(0, "mem-mode", &report.mem_mode, "mem access profile"),
1162         OPT_INTEGER(0, "samples", &symbol_conf.res_sample,
1163                     "Number of samples to save per histogram entry for individual browsing"),
1164         OPT_CALLBACK(0, "percent-limit", &report, "percent",
1165                      "Don't show entries under that percent", parse_percent_limit),
1166         OPT_CALLBACK(0, "percentage", NULL, "relative|absolute",
1167                      "how to display percentage of filtered entries", parse_filter_percentage),
1168         OPT_CALLBACK_OPTARG(0, "itrace", &itrace_synth_opts, NULL, "opts",
1169                             "Instruction Tracing options\n" ITRACE_HELP,
1170                             itrace_parse_synth_opts),
1171         OPT_BOOLEAN(0, "full-source-path", &srcline_full_filename,
1172                         "Show full source file name path for source lines"),
1173         OPT_BOOLEAN(0, "show-ref-call-graph", &symbol_conf.show_ref_callgraph,
1174                     "Show callgraph from reference event"),
1175         OPT_INTEGER(0, "socket-filter", &report.socket_filter,
1176                     "only show processor socket that match with this filter"),
1177         OPT_BOOLEAN(0, "raw-trace", &symbol_conf.raw_trace,
1178                     "Show raw trace event output (do not use print fmt or plugins)"),
1179         OPT_BOOLEAN(0, "hierarchy", &symbol_conf.report_hierarchy,
1180                     "Show entries in a hierarchy"),
1181         OPT_CALLBACK_DEFAULT(0, "stdio-color", NULL, "mode",
1182                              "'always' (default), 'never' or 'auto' only applicable to --stdio mode",
1183                              stdio__config_color, "always"),
1184         OPT_STRING(0, "time", &report.time_str, "str",
1185                    "Time span of interest (start,stop)"),
1186         OPT_BOOLEAN(0, "inline", &symbol_conf.inline_name,
1187                     "Show inline function"),
1188         OPT_CALLBACK(0, "percent-type", &report.annotation_opts, "local-period",
1189                      "Set percent type local/global-period/hits",
1190                      annotate_parse_percent_type),
1191         OPT_BOOLEAN(0, "ns", &symbol_conf.nanosecs, "Show times in nanosecs"),
1192         OPT_CALLBACK(0, "time-quantum", &symbol_conf.time_quantum, "time (ms|us|ns|s)",
1193                      "Set time quantum for time sort key (default 100ms)",
1194                      parse_time_quantum),
1195         OPT_END()
1196         };
1197         struct perf_data data = {
1198                 .mode  = PERF_DATA_MODE_READ,
1199         };
1200         int ret = hists__init();
1201         char sort_tmp[128];
1202
1203         if (ret < 0)
1204                 return ret;
1205
1206         ret = perf_config(report__config, &report);
1207         if (ret)
1208                 return ret;
1209
1210         argc = parse_options(argc, argv, options, report_usage, 0);
1211         if (argc) {
1212                 /*
1213                  * Special case: if there's an argument left then assume that
1214                  * it's a symbol filter:
1215                  */
1216                 if (argc > 1)
1217                         usage_with_options(report_usage, options);
1218
1219                 report.symbol_filter_str = argv[0];
1220         }
1221
1222         if (report.mmaps_mode)
1223                 report.tasks_mode = true;
1224
1225         if (quiet)
1226                 perf_quiet_option();
1227
1228         if (symbol_conf.vmlinux_name &&
1229             access(symbol_conf.vmlinux_name, R_OK)) {
1230                 pr_err("Invalid file: %s\n", symbol_conf.vmlinux_name);
1231                 return -EINVAL;
1232         }
1233         if (symbol_conf.kallsyms_name &&
1234             access(symbol_conf.kallsyms_name, R_OK)) {
1235                 pr_err("Invalid file: %s\n", symbol_conf.kallsyms_name);
1236                 return -EINVAL;
1237         }
1238
1239         if (report.inverted_callchain)
1240                 callchain_param.order = ORDER_CALLER;
1241         if (symbol_conf.cumulate_callchain && !callchain_param.order_set)
1242                 callchain_param.order = ORDER_CALLER;
1243
1244         if (itrace_synth_opts.callchain &&
1245             (int)itrace_synth_opts.callchain_sz > report.max_stack)
1246                 report.max_stack = itrace_synth_opts.callchain_sz;
1247
1248         if (!input_name || !strlen(input_name)) {
1249                 if (!fstat(STDIN_FILENO, &st) && S_ISFIFO(st.st_mode))
1250                         input_name = "-";
1251                 else
1252                         input_name = "perf.data";
1253         }
1254
1255         data.path  = input_name;
1256         data.force = symbol_conf.force;
1257
1258 repeat:
1259         session = perf_session__new(&data, false, &report.tool);
1260         if (session == NULL)
1261                 return -1;
1262
1263         if (report.queue_size) {
1264                 ordered_events__set_alloc_size(&session->ordered_events,
1265                                                report.queue_size);
1266         }
1267
1268         session->itrace_synth_opts = &itrace_synth_opts;
1269
1270         report.session = session;
1271
1272         has_br_stack = perf_header__has_feat(&session->header,
1273                                              HEADER_BRANCH_STACK);
1274
1275         setup_forced_leader(&report, session->evlist);
1276
1277         if (itrace_synth_opts.last_branch)
1278                 has_br_stack = true;
1279
1280         if (has_br_stack && branch_call_mode)
1281                 symbol_conf.show_branchflag_count = true;
1282
1283         memset(&report.brtype_stat, 0, sizeof(struct branch_type_stat));
1284
1285         /*
1286          * Branch mode is a tristate:
1287          * -1 means default, so decide based on the file having branch data.
1288          * 0/1 means the user chose a mode.
1289          */
1290         if (((branch_mode == -1 && has_br_stack) || branch_mode == 1) &&
1291             !branch_call_mode) {
1292                 sort__mode = SORT_MODE__BRANCH;
1293                 symbol_conf.cumulate_callchain = false;
1294         }
1295         if (branch_call_mode) {
1296                 callchain_param.key = CCKEY_ADDRESS;
1297                 callchain_param.branch_callstack = 1;
1298                 symbol_conf.use_callchain = true;
1299                 callchain_register_param(&callchain_param);
1300                 if (sort_order == NULL)
1301                         sort_order = "srcline,symbol,dso";
1302         }
1303
1304         if (report.mem_mode) {
1305                 if (sort__mode == SORT_MODE__BRANCH) {
1306                         pr_err("branch and mem mode incompatible\n");
1307                         goto error;
1308                 }
1309                 sort__mode = SORT_MODE__MEMORY;
1310                 symbol_conf.cumulate_callchain = false;
1311         }
1312
1313         if (symbol_conf.report_hierarchy) {
1314                 /* disable incompatible options */
1315                 symbol_conf.cumulate_callchain = false;
1316
1317                 if (field_order) {
1318                         pr_err("Error: --hierarchy and --fields options cannot be used together\n");
1319                         parse_options_usage(report_usage, options, "F", 1);
1320                         parse_options_usage(NULL, options, "hierarchy", 0);
1321                         goto error;
1322                 }
1323
1324                 perf_hpp_list.need_collapse = true;
1325         }
1326
1327         if (report.use_stdio)
1328                 use_browser = 0;
1329         else if (report.use_tui)
1330                 use_browser = 1;
1331         else if (report.use_gtk)
1332                 use_browser = 2;
1333
1334         /* Force tty output for header output and per-thread stat. */
1335         if (report.header || report.header_only || report.show_threads)
1336                 use_browser = 0;
1337         if (report.header || report.header_only)
1338                 report.tool.show_feat_hdr = SHOW_FEAT_HEADER;
1339         if (report.show_full_info)
1340                 report.tool.show_feat_hdr = SHOW_FEAT_HEADER_FULL_INFO;
1341         if (report.stats_mode || report.tasks_mode)
1342                 use_browser = 0;
1343         if (report.stats_mode && report.tasks_mode) {
1344                 pr_err("Error: --tasks and --mmaps can't be used together with --stats\n");
1345                 goto error;
1346         }
1347
1348         if (strcmp(input_name, "-") != 0)
1349                 setup_browser(true);
1350         else
1351                 use_browser = 0;
1352
1353         if (sort_order && strstr(sort_order, "ipc")) {
1354                 parse_options_usage(report_usage, options, "s", 1);
1355                 goto error;
1356         }
1357
1358         if (sort_order && strstr(sort_order, "symbol")) {
1359                 if (sort__mode == SORT_MODE__BRANCH) {
1360                         snprintf(sort_tmp, sizeof(sort_tmp), "%s,%s",
1361                                  sort_order, "ipc_lbr");
1362                         report.symbol_ipc = true;
1363                 } else {
1364                         snprintf(sort_tmp, sizeof(sort_tmp), "%s,%s",
1365                                  sort_order, "ipc_null");
1366                 }
1367
1368                 sort_order = sort_tmp;
1369         }
1370
1371         if (setup_sorting(session->evlist) < 0) {
1372                 if (sort_order)
1373                         parse_options_usage(report_usage, options, "s", 1);
1374                 if (field_order)
1375                         parse_options_usage(sort_order ? NULL : report_usage,
1376                                             options, "F", 1);
1377                 goto error;
1378         }
1379
1380         if ((report.header || report.header_only) && !quiet) {
1381                 perf_session__fprintf_info(session, stdout,
1382                                            report.show_full_info);
1383                 if (report.header_only) {
1384                         ret = 0;
1385                         goto error;
1386                 }
1387         } else if (use_browser == 0 && !quiet &&
1388                    !report.stats_mode && !report.tasks_mode) {
1389                 fputs("# To display the perf.data header info, please use --header/--header-only options.\n#\n",
1390                       stdout);
1391         }
1392
1393         /*
1394          * Only in the TUI browser we are doing integrated annotation,
1395          * so don't allocate extra space that won't be used in the stdio
1396          * implementation.
1397          */
1398         if (ui__has_annotation() || report.symbol_ipc) {
1399                 ret = symbol__annotation_init();
1400                 if (ret < 0)
1401                         goto error;
1402                 /*
1403                  * For searching by name on the "Browse map details".
1404                  * providing it only in verbose mode not to bloat too
1405                  * much struct symbol.
1406                  */
1407                 if (verbose > 0) {
1408                         /*
1409                          * XXX: Need to provide a less kludgy way to ask for
1410                          * more space per symbol, the u32 is for the index on
1411                          * the ui browser.
1412                          * See symbol__browser_index.
1413                          */
1414                         symbol_conf.priv_size += sizeof(u32);
1415                         symbol_conf.sort_by_name = true;
1416                 }
1417                 annotation_config__init();
1418         }
1419
1420         if (symbol__init(&session->header.env) < 0)
1421                 goto error;
1422
1423         if (report.time_str) {
1424                 ret = perf_time__parse_for_ranges(report.time_str, session,
1425                                                   &report.ptime_range,
1426                                                   &report.range_size,
1427                                                   &report.range_num);
1428                 if (ret < 0)
1429                         goto error;
1430         }
1431
1432         if (session->tevent.pevent &&
1433             tep_set_function_resolver(session->tevent.pevent,
1434                                       machine__resolve_kernel_addr,
1435                                       &session->machines.host) < 0) {
1436                 pr_err("%s: failed to set libtraceevent function resolver\n",
1437                        __func__);
1438                 return -1;
1439         }
1440
1441         sort__setup_elide(stdout);
1442
1443         ret = __cmd_report(&report);
1444         if (ret == K_SWITCH_INPUT_DATA) {
1445                 perf_session__delete(session);
1446                 goto repeat;
1447         } else
1448                 ret = 0;
1449
1450 error:
1451         if (report.ptime_range)
1452                 zfree(&report.ptime_range);
1453
1454         perf_session__delete(session);
1455         return ret;
1456 }