builtin-report.c 51.3 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
2 3 4 5 6 7 8
/*
 * builtin-report.c
 *
 * Builtin report command: Analyze the perf.data input file,
 * look up and read DSOs and symbol information and display
 * a histogram of results, along various sorting keys.
 */
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 23 24
#include "util/map_symbol.h"
#include "util/mem-events.h"
#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 31
#include "util/evlist.h"
#include "util/evsel.h"
32
#include "util/evswitch.h"
33
#include "util/header.h"
34
#include "util/session.h"
35
#include "util/srcline.h"
36
#include "util/tool.h"
37

38
#include <subcmd/parse-options.h>
39
#include <subcmd/exec-cmd.h>
40 41
#include "util/parse-events.h"

42
#include "util/thread.h"
43
#include "util/sort.h"
44
#include "util/hist.h"
45
#include "util/data.h"
46
#include "arch/common.h"
47
#include "util/time-utils.h"
48
#include "util/auxtrace.h"
49
#include "util/units.h"
50
#include "util/util.h" // perf_tip()
51
#include "ui/ui.h"
52
#include "ui/progress.h"
53
#include "util/block-info.h"
54

55
#include <dlfcn.h>
56
#include <errno.h>
57
#include <inttypes.h>
58
#include <regex.h>
59
#include <linux/ctype.h>
60
#include <signal.h>
61
#include <linux/bitmap.h>
62
#include <linux/list_sort.h>
63
#include <linux/string.h>
64
#include <linux/stringify.h>
65
#include <linux/time64.h>
66 67 68
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
69
#include <linux/mman.h>
70

71 72 73 74
#ifdef HAVE_LIBTRACEEVENT
#include <traceevent/event-parse.h>
#endif

75
struct report {
76
	struct perf_tool	tool;
77
	struct perf_session	*session;
78
	struct evswitch		evswitch;
79 80 81
#ifdef HAVE_SLANG_SUPPORT
	bool			use_tui;
#endif
82
#ifdef HAVE_GTK2_SUPPORT
83
	bool			use_gtk;
84
#endif
85
	bool			use_stdio;
86 87 88
	bool			show_full_info;
	bool			show_threads;
	bool			inverted_callchain;
89
	bool			mem_mode;
90
	bool			stats_mode;
91
	bool			tasks_mode;
92
	bool			mmaps_mode;
93 94
	bool			header;
	bool			header_only;
95
	bool			nonany_branch_mode;
96
	bool			group_set;
97
	bool			stitch_lbr;
98
	bool			disable_order;
99
	bool			skip_empty;
100
	bool			data_type;
101
	int			max_stack;
102 103 104
	struct perf_read_values	show_threads_values;
	const char		*pretty_printing_style;
	const char		*cpu_list;
105
	const char		*symbol_filter_str;
106
	const char		*time_str;
107 108
	struct perf_time_interval *ptime_range;
	int			range_size;
109
	int			range_num;
110
	float			min_percent;
111
	u64			nr_entries;
112
	u64			queue_size;
113
	u64			total_cycles;
114
	int			socket_filter;
115
	DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
116
	struct branch_type_stat	brtype_stat;
117
	bool			symbol_ipc;
118 119
	bool			total_cycles_mode;
	struct block_report	*block_reports;
120
	int			nr_block_reports;
121
};
122

123
static int report__config(const char *var, const char *value, void *cb)
124
{
125 126
	struct report *rep = cb;

127 128 129 130
	if (!strcmp(var, "report.group")) {
		symbol_conf.event_group = perf_config_bool(var, value);
		return 0;
	}
131
	if (!strcmp(var, "report.percent-limit")) {
132 133 134 135
		double pcnt = strtof(value, NULL);

		rep->min_percent = pcnt;
		callchain_param.min_percent = pcnt;
136 137
		return 0;
	}
138 139 140 141
	if (!strcmp(var, "report.children")) {
		symbol_conf.cumulate_callchain = perf_config_bool(var, value);
		return 0;
	}
142 143 144
	if (!strcmp(var, "report.queue-size"))
		return perf_config_u64(&rep->queue_size, var, value);

145 146
	if (!strcmp(var, "report.sort_order")) {
		default_sort_order = strdup(value);
147 148 149 150
		if (!default_sort_order) {
			pr_err("Not enough memory for report.sort_order\n");
			return -1;
		}
151 152
		return 0;
	}
153

154 155 156 157 158
	if (!strcmp(var, "report.skip-empty")) {
		rep->skip_empty = perf_config_bool(var, value);
		return 0;
	}

159
	pr_debug("%s variable unknown, ignoring...", var);
160
	return 0;
161 162
}

163 164 165 166 167 168 169
static int hist_iter__report_callback(struct hist_entry_iter *iter,
				      struct addr_location *al, bool single,
				      void *arg)
{
	int err = 0;
	struct report *rep = arg;
	struct hist_entry *he = iter->he;
170
	struct evsel *evsel = iter->evsel;
171
	struct perf_sample *sample = iter->sample;
172 173 174
	struct mem_info *mi;
	struct branch_info *bi;

175
	if (!ui__has_annotation() && !rep->symbol_ipc && !rep->data_type)
176 177 178 179
		return 0;

	if (sort__mode == SORT_MODE__BRANCH) {
		bi = he->branch_info;
180
		err = addr_map_symbol__inc_samples(&bi->from, sample, evsel);
181 182 183
		if (err)
			goto out;

184
		err = addr_map_symbol__inc_samples(&bi->to, sample, evsel);
185 186 187

	} else if (rep->mem_mode) {
		mi = he->mem_info;
188
		err = addr_map_symbol__inc_samples(&mi->daddr, sample, evsel);
189 190 191
		if (err)
			goto out;

192
		err = hist_entry__inc_addr_samples(he, sample, evsel, al->addr);
193 194 195

	} else if (symbol_conf.cumulate_callchain) {
		if (single)
196
			err = hist_entry__inc_addr_samples(he, sample, evsel, al->addr);
197
	} else {
198
		err = hist_entry__inc_addr_samples(he, sample, evsel, al->addr);
199 200 201 202
	}

out:
	return err;
203 204
}

205 206 207 208 209 210 211
static int hist_iter__branch_callback(struct hist_entry_iter *iter,
				      struct addr_location *al __maybe_unused,
				      bool single __maybe_unused,
				      void *arg)
{
	struct hist_entry *he = iter->he;
	struct report *rep = arg;
212
	struct branch_info *bi = he->branch_info;
213
	struct perf_sample *sample = iter->sample;
214
	struct evsel *evsel = iter->evsel;
215 216
	int err;

217 218 219
	branch_type_count(&rep->brtype_stat, &bi->flags,
			  bi->from.addr, bi->to.addr);

220
	if (!ui__has_annotation() && !rep->symbol_ipc)
221 222
		return 0;

223
	err = addr_map_symbol__inc_samples(&bi->from, sample, evsel);
224 225 226
	if (err)
		goto out;

227
	err = addr_map_symbol__inc_samples(&bi->to, sample, evsel);
228 229 230

out:
	return err;
231 232
}

233
static void setup_forced_leader(struct report *report,
234
				struct evlist *evlist)
235
{
236
	if (report->group_set)
237
		evlist__force_leader(evlist);
238 239
}

240 241
static int process_feature_event(struct perf_session *session,
				 union perf_event *event)
242
{
243
	struct report *rep = container_of(session->tool, struct report, tool);
244 245

	if (event->feat.feat_id < HEADER_LAST_FEATURE)
246
		return perf_event__process_feature(session, event);
247 248

	if (event->feat.feat_id != HEADER_LAST_FEATURE) {
249
		pr_err("failed: wrong feature ID: %" PRI_lu64 "\n",
250 251
		       event->feat.feat_id);
		return -1;
252 253
	} else if (rep->header_only) {
		session_done = 1;
254 255 256
	}

	/*
257 258
	 * (feat_id = HEADER_LAST_FEATURE) is the end marker which
	 * means all features are received, now we can force the
259 260 261 262 263 264
	 * group if needed.
	 */
	setup_forced_leader(rep, session->evlist);
	return 0;
}

265
static int process_sample_event(struct perf_tool *tool,
266
				union perf_event *event,
267
				struct perf_sample *sample,
268
				struct evsel *evsel,
269
				struct machine *machine)
270
{
271
	struct report *rep = container_of(tool, struct report, tool);
272
	struct addr_location al;
273
	struct hist_entry_iter iter = {
274 275
		.evsel 			= evsel,
		.sample 		= sample,
276
		.hide_unresolved 	= symbol_conf.hide_unresolved,
277
		.add_entry_cb 		= hist_iter__report_callback,
278
	};
279
	int ret = 0;
280

281 282
	if (perf_time__ranges_skip_sample(rep->ptime_range, rep->range_num,
					  sample->time)) {
283
		return 0;
284
	}
285

286 287 288
	if (evswitch__discard(&rep->evswitch, evsel))
		return 0;

289
	addr_location__init(&al);
290
	if (machine__resolve(machine, &al, sample) < 0) {
291 292
		pr_debug("problem processing %d event, skipping it.\n",
			 event->header.type);
293 294
		ret = -1;
		goto out_put;
295
	}
296

297
	if (rep->stitch_lbr)
298
		thread__set_lbr_stitch_enable(al.thread, true);
299

300
	if (symbol_conf.hide_unresolved && al.sym == NULL)
301
		goto out_put;
302

303
	if (rep->cpu_list && !test_bit(sample->cpu, rep->cpu_bitmap))
304
		goto out_put;
305

306 307 308 309 310 311 312
	if (sort__mode == SORT_MODE__BRANCH) {
		/*
		 * A non-synthesized event might not have a branch stack if
		 * branch stacks have been synthesized (using itrace options).
		 */
		if (!sample->branch_stack)
			goto out_put;
313 314

		iter.add_entry_cb = hist_iter__branch_callback;
315
		iter.ops = &hist_iter_branch;
316
	} else if (rep->mem_mode) {
317
		iter.ops = &hist_iter_mem;
318
	} else if (symbol_conf.cumulate_callchain) {
319
		iter.ops = &hist_iter_cumulative;
320
	} else {
321
		iter.ops = &hist_iter_normal;
322
	}
323 324

	if (al.map != NULL)
325
		map__dso(al.map)->hit = 1;
326

327
	if (ui__has_annotation() || rep->symbol_ipc || rep->total_cycles_mode) {
328
		hist__account_cycles(sample->branch_stack, &al, sample,
329 330
				     rep->nonany_branch_mode,
				     &rep->total_cycles);
331 332
	}

333
	ret = hist_entry_iter__add(&iter, &al, rep->max_stack, rep);
334 335
	if (ret < 0)
		pr_debug("problem adding hist entry, skipping event\n");
336
out_put:
337
	addr_location__exit(&al);
338
	return ret;
339
}
340

341
static int process_read_event(struct perf_tool *tool,
342
			      union perf_event *event,
343
			      struct perf_sample *sample __maybe_unused,
344
			      struct evsel *evsel,
345
			      struct machine *machine __maybe_unused)
346
{
347
	struct report *rep = container_of(tool, struct report, tool);
348

349
	if (rep->show_threads) {
350
		const char *name = evsel__name(evsel);
351
		int err = perf_read_values_add_value(&rep->show_threads_values,
352
					   event->read.pid, event->read.tid,
353
					   evsel->core.idx,
354 355
					   name,
					   event->read.value);
356 357 358

		if (err)
			return err;
359 360
	}

361 362 363
	return 0;
}

364
/* For pipe mode, sample_type is not currently set */
365
static int report__setup_sample_type(struct report *rep)
366
{
367
	struct perf_session *session = rep->session;
368
	u64 sample_type = evlist__combined_sample_type(session->evlist);
369
	bool is_pipe = perf_data__is_pipe(session->data);
370
	struct evsel *evsel;
371

372
	if (session->itrace_synth_opts->callchain ||
373
	    session->itrace_synth_opts->add_callchain ||
374 375 376 377 378
	    (!is_pipe &&
	     perf_header__has_feat(&session->header, HEADER_AUXTRACE) &&
	     !session->itrace_synth_opts->set))
		sample_type |= PERF_SAMPLE_CALLCHAIN;

379 380
	if (session->itrace_synth_opts->last_branch ||
	    session->itrace_synth_opts->add_last_branch)
381 382
		sample_type |= PERF_SAMPLE_BRANCH_STACK;

383
	if (!is_pipe && !(sample_type & PERF_SAMPLE_CALLCHAIN)) {
384
		if (perf_hpp_list.parent) {
385
			ui__error("Selected --sort parent, but no "
386 387
				    "callchain data. Did you call "
				    "'perf record' without -g?\n");
388
			return -EINVAL;
389
		}
390 391 392 393 394
		if (symbol_conf.use_callchain &&
			!symbol_conf.show_branchflag_count) {
			ui__error("Selected -g or --branch-history.\n"
				  "But no callchain or branch data.\n"
				  "Did you call 'perf record' without -g or -b?\n");
395
			return -1;
396
		}
397
	} else if (!callchain_param.enabled &&
398
		   callchain_param.mode != CHAIN_NONE &&
399
		   !symbol_conf.use_callchain) {
400
			symbol_conf.use_callchain = true;
401
			if (callchain_register_param(&callchain_param) < 0) {
402
				ui__error("Can't register callchain params.\n");
403
				return -EINVAL;
404
			}
405 406
	}

407 408 409 410 411 412 413 414
	if (symbol_conf.cumulate_callchain) {
		/* Silently ignore if callchain is missing */
		if (!(sample_type & PERF_SAMPLE_CALLCHAIN)) {
			symbol_conf.cumulate_callchain = false;
			perf_hpp__cancel_cumulate();
		}
	}

415
	if (sort__mode == SORT_MODE__BRANCH) {
416
		if (!is_pipe &&
417
		    !(sample_type & PERF_SAMPLE_BRANCH_STACK)) {
418 419
			ui__error("Selected -b but no branch data. "
				  "Did you call perf record without -b?\n");
420 421 422 423
			return -1;
		}
	}

424
	if (sort__mode == SORT_MODE__MEMORY) {
425 426 427 428 429 430 431 432 433 434 435 436 437
		/*
		 * FIXUP: prior to kernel 5.18, Arm SPE missed to set
		 * PERF_SAMPLE_DATA_SRC bit in sample type.  For backward
		 * compatibility, set the bit if it's an old perf data file.
		 */
		evlist__for_each_entry(session->evlist, evsel) {
			if (strstr(evsel->name, "arm_spe") &&
				!(sample_type & PERF_SAMPLE_DATA_SRC)) {
				evsel->core.attr.sample_type |= PERF_SAMPLE_DATA_SRC;
				sample_type |= PERF_SAMPLE_DATA_SRC;
			}
		}

438 439 440 441 442 443 444
		if (!is_pipe && !(sample_type & PERF_SAMPLE_DATA_SRC)) {
			ui__error("Selected --mem-mode but no mem data. "
				  "Did you call perf record without -d?\n");
			return -1;
		}
	}

445
	callchain_param_setup(sample_type, perf_env__arch(&rep->session->header.env));
446

447 448 449 450 451 452
	if (rep->stitch_lbr && (callchain_param.record_mode != CALLCHAIN_LBR)) {
		ui__warning("Can't find LBR callchain. Switch off --stitch-lbr.\n"
			    "Please apply --call-graph lbr when recording.\n");
		rep->stitch_lbr = false;
	}

453
	/* ??? handle more cases than just ANY? */
454
	if (!(evlist__combined_branch_type(session->evlist) & PERF_SAMPLE_BRANCH_ANY))
455 456
		rep->nonany_branch_mode = true;

457
#if !defined(HAVE_LIBUNWIND_SUPPORT) && !defined(HAVE_DWARF_SUPPORT)
458
	if (dwarf_callchain_users) {
459 460
		ui__warning("Please install libunwind or libdw "
			    "development packages during the perf build.\n");
461 462 463
	}
#endif

464 465
	return 0;
}
466

467
static void sig_handler(int sig __maybe_unused)
468 469 470 471
{
	session_done = 1;
}

472
static size_t hists__fprintf_nr_sample_events(struct hists *hists, struct report *rep,
473 474 475 476
					      const char *evname, FILE *fp)
{
	size_t ret;
	char unit;
477
	unsigned long nr_samples = hists->stats.nr_samples;
478
	u64 nr_events = hists->stats.total_period;
479
	struct evsel *evsel = hists_to_evsel(hists);
480 481
	char buf[512];
	size_t size = sizeof(buf);
482
	int socked_id = hists->socket_filter;
483

484 485 486
	if (quiet)
		return 0;

487 488 489 490 491
	if (symbol_conf.filter_relative) {
		nr_samples = hists->stats.nr_non_filtered_samples;
		nr_events = hists->stats.total_non_filtered_period;
	}

492
	if (evsel__is_group_event(evsel)) {
493
		struct evsel *pos;
494

495
		evsel__group_desc(evsel, buf, size);
496 497 498
		evname = buf;

		for_each_group_member(pos, evsel) {
499 500
			const struct hists *pos_hists = evsel__hists(pos);

501
			if (symbol_conf.filter_relative) {
502 503
				nr_samples += pos_hists->stats.nr_non_filtered_samples;
				nr_events += pos_hists->stats.total_non_filtered_period;
504
			} else {
505
				nr_samples += pos_hists->stats.nr_samples;
506
				nr_events += pos_hists->stats.total_period;
507
			}
508 509
		}
	}
510

511 512
	nr_samples = convert_unit(nr_samples, &unit);
	ret = fprintf(fp, "# Samples: %lu%c", nr_samples, unit);
513 514
	if (evname != NULL) {
		ret += fprintf(fp, " of event%s '%s'",
515
			       evsel->core.nr_members > 1 ? "s" : "", evname);
516
	}
517

518 519 520
	if (rep->time_str)
		ret += fprintf(fp, " (time slices: %s)", rep->time_str);

521
	if (symbol_conf.show_ref_callgraph && evname && strstr(evname, "call-graph=no")) {
522 523 524
		ret += fprintf(fp, ", show reference callgraph");
	}

525 526
	if (rep->mem_mode) {
		ret += fprintf(fp, "\n# Total weight : %" PRIu64, nr_events);
527
		ret += fprintf(fp, "\n# Sort order   : %s", sort_order ? : default_mem_sort_order);
528 529
	} else
		ret += fprintf(fp, "\n# Event count (approx.): %" PRIu64, nr_events);
530

531 532
	if (socked_id > -1)
		ret += fprintf(fp, "\n# Processor Socket: %d", socked_id);
533

534 535 536
	return ret + fprintf(fp, "\n#\n");
}

537
static int evlist__tui_block_hists_browse(struct evlist *evlist, struct report *rep)
538 539 540 541 542 543
{
	struct evsel *pos;
	int i = 0, ret;

	evlist__for_each_entry(evlist, pos) {
		ret = report__browse_block_hists(&rep->block_reports[i++].hist,
544
						 rep->min_percent, pos,
545
						 &rep->session->header.env);
546 547 548 549 550 551 552
		if (ret != 0)
			return ret;
	}

	return 0;
}

553
static int evlist__tty_browse_hists(struct evlist *evlist, struct report *rep, const char *help)
554
{
555
	struct evsel *pos;
556
	int i = 0;
557

558 559 560 561 562
	if (!quiet) {
		fprintf(stdout, "#\n# Total Lost Samples: %" PRIu64 "\n#\n",
			evlist->stats.total_lost_samples);
	}

563
	evlist__for_each_entry(evlist, pos) {
564
		struct hists *hists = evsel__hists(pos);
565
		const char *evname = evsel__name(pos);
566

567
		if (symbol_conf.event_group && !evsel__is_group_leader(pos))
568 569
			continue;

570 571 572
		if (rep->skip_empty && !hists->stats.nr_samples)
			continue;

573
		hists__fprintf_nr_sample_events(hists, rep, evname, stdout);
574 575 576

		if (rep->total_cycles_mode) {
			report__browse_block_hists(&rep->block_reports[i++].hist,
577
						   rep->min_percent, pos, NULL);
578 579 580
			continue;
		}

581
		hists__fprintf(hists, !quiet, 0, 0, rep->min_percent, stdout,
582 583
			       !(symbol_conf.use_callchain ||
			         symbol_conf.show_branchflag_count));
584 585 586
		fprintf(stdout, "\n\n");
	}

587
	if (!quiet)
588 589
		fprintf(stdout, "#\n# (%s)\n#\n", help);

590 591 592 593 594
	if (rep->show_threads) {
		bool style = !strcmp(rep->pretty_printing_style, "raw");
		perf_read_values_display(stdout, &rep->show_threads_values,
					 style);
		perf_read_values_destroy(&rep->show_threads_values);
595 596
	}

597 598 599
	if (sort__mode == SORT_MODE__BRANCH)
		branch_type_stat_display(stdout, &rep->brtype_stat);

600 601 602
	return 0;
}

603 604
static void report__warn_kptr_restrict(const struct report *rep)
{
605
	struct map *kernel_map = machine__kernel_map(&rep->session->machines.host);
606
	struct kmap *kernel_kmap = kernel_map ? map__kmap(kernel_map) : NULL;
607

608
	if (evlist__exclude_kernel(rep->session->evlist))
609 610
		return;

611
	if (kernel_map == NULL ||
612
	     (map__dso(kernel_map)->hit &&
613 614 615 616 617 618
	     (kernel_kmap->ref_reloc_sym == NULL ||
	      kernel_kmap->ref_reloc_sym->addr == 0))) {
		const char *desc =
		    "As no suitable kallsyms nor vmlinux was found, kernel samples\n"
		    "can't be resolved.";

619 620 621
		if (kernel_map && map__has_symbols(kernel_map)) {
			desc = "If some relocation was applied (e.g. "
			       "kexec) symbols may be misresolved.";
622 623 624 625 626 627 628 629 630 631
		}

		ui__warning(
"Kernel address maps (/proc/{kallsyms,modules}) were restricted.\n\n"
"Check /proc/sys/kernel/kptr_restrict before running 'perf record'.\n\n%s\n\n"
"Samples in kernel modules can't be resolved as well.\n\n",
		desc);
	}
}

632 633
static int report__gtk_browse_hists(struct report *rep, const char *help)
{
634
	int (*hist_browser)(struct evlist *evlist, const char *help,
635 636
			    struct hist_browser_timer *timer, float min_pcnt);

637
	hist_browser = dlsym(perf_gtk_handle, "evlist__gtk_browse_hists");
638 639 640 641 642 643 644 645 646 647 648 649 650

	if (hist_browser == NULL) {
		ui__error("GTK browser not found!\n");
		return -1;
	}

	return hist_browser(rep->session->evlist, help, NULL, rep->min_percent);
}

static int report__browse_hists(struct report *rep)
{
	int ret;
	struct perf_session *session = rep->session;
651
	struct evlist *evlist = session->evlist;
652
	char *help = NULL, *path = NULL;
653

654 655
	path = system_path(TIPDIR);
	if (perf_tip(&help, path) || help == NULL) {
656
		/* fallback for people who don't install perf ;-) */
657 658 659 660
		free(path);
		path = system_path(DOCDIR);
		if (perf_tip(&help, path) || help == NULL)
			help = strdup("Cannot load tips.txt file, please install perf!");
661
	}
662
	free(path);
663 664 665

	switch (use_browser) {
	case 1:
666
		if (rep->total_cycles_mode) {
667
			ret = evlist__tui_block_hists_browse(evlist, rep);
668 669 670
			break;
		}

671
		ret = evlist__tui_browse_hists(evlist, help, NULL, rep->min_percent,
672
					       &session->header.env, true);
673 674 675 676
		/*
		 * Usually "ret" is the last pressed key, and we only
		 * care if the key notifies us to switch data file.
		 */
677
		if (ret != K_SWITCH_INPUT_DATA && ret != K_RELOAD)
678 679 680 681 682 683
			ret = 0;
		break;
	case 2:
		ret = report__gtk_browse_hists(rep, help);
		break;
	default:
684
		ret = evlist__tty_browse_hists(evlist, rep, help);
685 686
		break;
	}
687
	free(help);
688 689 690
	return ret;
}

691
static int report__collapse_hists(struct report *rep)
692
{
693 694
	struct perf_session *session = rep->session;
	struct evlist *evlist = session->evlist;
695
	struct ui_progress prog;
696
	struct evsel *pos;
697
	int ret = 0;
698

699 700 701 702 703 704 705 706
	/*
	 * The pipe data needs to setup hierarchy hpp formats now, because it
	 * cannot know about evsels in the data before reading the data.  The
	 * normal file data saves the event (attribute) info in the header
	 * section, but pipe does not have the luxury.
	 */
	if (perf_data__is_pipe(session->data)) {
		if (perf_hpp__setup_hists_formats(&perf_hpp_list, evlist) < 0) {
707
			ui__error("Failed to setup hierarchy output formats\n");
708 709 710 711
			return -1;
		}
	}

712
	ui_progress__init(&prog, rep->nr_entries, "Merging related events...");
713

714
	evlist__for_each_entry(rep->session->evlist, pos) {
715
		struct hists *hists = evsel__hists(pos);
716

717
		if (pos->core.idx == 0)
718 719
			hists->symbol_filter_str = rep->symbol_filter_str;

720 721
		hists->socket_filter = rep->socket_filter;

722 723 724
		ret = hists__collapse_resort(hists, &prog);
		if (ret < 0)
			break;
725 726

		/* Non-group events are considered as leader */
727
		if (symbol_conf.event_group && !evsel__is_group_leader(pos)) {
728
			struct hists *leader_hists = evsel__hists(evsel__leader(pos));
729 730 731 732 733 734 735

			hists__match(leader_hists, hists);
			hists__link(leader_hists, hists);
		}
	}

	ui_progress__finish();
736
	return ret;
737 738
}

739 740 741 742 743 744
static int hists__resort_cb(struct hist_entry *he, void *arg)
{
	struct report *rep = arg;
	struct symbol *sym = he->ms.sym;

	if (rep->symbol_ipc && sym && !sym->annotate2) {
745
		struct evsel *evsel = hists_to_evsel(he->hists);
746

747
		symbol__annotate2(&he->ms, evsel, NULL);
748 749 750 751 752
	}

	return 0;
}

753 754 755
static void report__output_resort(struct report *rep)
{
	struct ui_progress prog;
756
	struct evsel *pos;
757 758 759

	ui_progress__init(&prog, rep->nr_entries, "Sorting events for output...");

760
	evlist__for_each_entry(rep->session->evlist, pos) {
761
		evsel__output_resort_cb(pos, &prog, hists__resort_cb, rep);
762
	}
763 764 765 766

	ui_progress__finish();
}

767 768 769 770 771 772 773 774 775 776 777 778
static int count_sample_event(struct perf_tool *tool __maybe_unused,
			      union perf_event *event __maybe_unused,
			      struct perf_sample *sample __maybe_unused,
			      struct evsel *evsel,
			      struct machine *machine __maybe_unused)
{
	struct hists *hists = evsel__hists(evsel);

	hists__inc_nr_events(hists);
	return 0;
}

779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794
static int count_lost_samples_event(struct perf_tool *tool,
				    union perf_event *event,
				    struct perf_sample *sample,
				    struct machine *machine __maybe_unused)
{
	struct report *rep = container_of(tool, struct report, tool);
	struct evsel *evsel;

	evsel = evlist__id2evsel(rep->session->evlist, sample->id);
	if (evsel) {
		hists__inc_nr_lost_samples(evsel__hists(evsel),
					   event->lost_samples.lost);
	}
	return 0;
}

795 796 797 798
static int process_attr(struct perf_tool *tool __maybe_unused,
			union perf_event *event,
			struct evlist **pevlist);

799 800 801
static void stats_setup(struct report *rep)
{
	memset(&rep->tool, 0, sizeof(rep->tool));
802
	rep->tool.attr = process_attr;
803
	rep->tool.sample = count_sample_event;
804
	rep->tool.lost_samples = count_lost_samples_event;
805 806 807 808 809 810 811
	rep->tool.no_warn = true;
}

static int stats_print(struct report *rep)
{
	struct perf_session *session = rep->session;

812 813
	perf_session__fprintf_nr_events(session, stdout, rep->skip_empty);
	evlist__fprintf_nr_events(session->evlist, stdout, rep->skip_empty);
814 815 816
	return 0;
}

817 818 819
static void tasks_setup(struct report *rep)
{
	memset(&rep->tool, 0, sizeof(rep->tool));
820
	rep->tool.ordered_events = true;
821 822 823 824
	if (rep->mmaps_mode) {
		rep->tool.mmap = perf_event__process_mmap;
		rep->tool.mmap2 = perf_event__process_mmap2;
	}
825
	rep->tool.attr = process_attr;
826 827 828 829 830 831
	rep->tool.comm = perf_event__process_comm;
	rep->tool.exit = perf_event__process_exit;
	rep->tool.fork = perf_event__process_fork;
	rep->tool.no_warn = true;
}

832 833 834 835 836 837 838
struct maps__fprintf_task_args {
	int indent;
	FILE *fp;
	size_t printed;
};

static int maps__fprintf_task_cb(struct map *map, void *data)
839
{
840 841 842 843
	struct maps__fprintf_task_args *args = data;
	const struct dso *dso = map__dso(map);
	u32 prot = map__prot(map);
	int ret;
844

845 846 847 848 849 850 851 852 853
	ret = fprintf(args->fp,
		"%*s  %" PRIx64 "-%" PRIx64 " %c%c%c%c %08" PRIx64 " %" PRIu64 " %s\n",
		args->indent, "", map__start(map), map__end(map),
		prot & PROT_READ ? 'r' : '-',
		prot & PROT_WRITE ? 'w' : '-',
		prot & PROT_EXEC ? 'x' : '-',
		map__flags(map) ? 's' : 'p',
		map__pgoff(map),
		dso->id.ino, dso->name);
854

855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870
	if (ret < 0)
		return ret;

	args->printed += ret;
	return 0;
}

static size_t maps__fprintf_task(struct maps *maps, int indent, FILE *fp)
{
	struct maps__fprintf_task_args args = {
		.indent = indent,
		.fp = fp,
		.printed = 0,
	};

	maps__for_each_map(maps, maps__fprintf_task_cb, &args);
871

872
	return args.printed;
873 874
}

875
static int thread_level(struct machine *machine, const struct thread *thread)
876
{
877 878
	struct thread *parent_thread;
	int res;
879

880 881
	if (thread__tid(thread) <= 0)
		return 0;
882

883 884
	if (thread__ppid(thread) <= 0)
		return 1;
885

886 887 888 889
	parent_thread = machine__find_thread(machine, -1, thread__ppid(thread));
	if (!parent_thread) {
		pr_err("Missing parent thread of %d\n", thread__tid(thread));
		return 0;
890
	}
891 892 893
	res = 1 + thread_level(machine, parent_thread);
	thread__put(parent_thread);
	return res;
894 895
}

896
static void task__print_level(struct machine *machine, struct thread *thread, FILE *fp)
897
{
898 899 900 901
	int level = thread_level(machine, thread);
	int comm_indent = fprintf(fp, "  %8d %8d %8d |%*s",
				  thread__pid(thread), thread__tid(thread),
				  thread__ppid(thread), level, "");
902

903
	fprintf(fp, "%s\n", thread__comm_str(thread));
904

905 906
	maps__fprintf_task(thread__maps(thread), comm_indent, fp);
}
907

908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929
/*
 * Sort two thread list nodes such that they form a tree. The first node is the
 * root of the tree, its children are ordered numerically after it. If a child
 * has children itself then they appear immediately after their parent. For
 * example, the 4 threads in the order they'd appear in the list:
 * - init with a TID 1 and a parent of 0
 * - systemd with a TID 3000 and a parent of init/1
 * - systemd child thread with TID 4000, the parent is 3000
 * - NetworkManager is a child of init with a TID of 3500.
 */
static int task_list_cmp(void *priv, const struct list_head *la, const struct list_head *lb)
{
	struct machine *machine = priv;
	struct thread_list *task_a = list_entry(la, struct thread_list, list);
	struct thread_list *task_b = list_entry(lb, struct thread_list, list);
	struct thread *a = task_a->thread;
	struct thread *b = task_b->thread;
	int level_a, level_b, res;

	/* Same thread? */
	if (thread__tid(a) == thread__tid(b))
		return 0;
930

931 932 933
	/* Compare a and b to root. */
	if (thread__tid(a) == 0)
		return -1;
934

935 936
	if (thread__tid(b) == 0)
		return 1;
937

938 939 940
	/* If parents match sort by tid. */
	if (thread__ppid(a) == thread__ppid(b))
		return thread__tid(a) < thread__tid(b) ? -1 : 1;
941 942

	/*
943 944 945
	 * Find a and b such that if they are a child of each other a and b's
	 * tid's match, otherwise a and b have a common parent and distinct
	 * tid's to sort by. First make the depths of the threads match.
946
	 */
947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991
	level_a = thread_level(machine, a);
	level_b = thread_level(machine, b);
	a = thread__get(a);
	b = thread__get(b);
	for (int i = level_a; i > level_b; i--) {
		struct thread *parent = machine__find_thread(machine, -1, thread__ppid(a));

		thread__put(a);
		if (!parent) {
			pr_err("Missing parent thread of %d\n", thread__tid(a));
			thread__put(b);
			return -1;
		}
		a = parent;
	}
	for (int i = level_b; i > level_a; i--) {
		struct thread *parent = machine__find_thread(machine, -1, thread__ppid(b));

		thread__put(b);
		if (!parent) {
			pr_err("Missing parent thread of %d\n", thread__tid(b));
			thread__put(a);
			return 1;
		}
		b = parent;
	}
	/* Search up to a common parent. */
	while (thread__ppid(a) != thread__ppid(b)) {
		struct thread *parent;

		parent = machine__find_thread(machine, -1, thread__ppid(a));
		thread__put(a);
		if (!parent)
			pr_err("Missing parent thread of %d\n", thread__tid(a));
		a = parent;
		parent = machine__find_thread(machine, -1, thread__ppid(b));
		thread__put(b);
		if (!parent)
			pr_err("Missing parent thread of %d\n", thread__tid(b));
		b = parent;
		if (!a || !b) {
			/* Handle missing parent (unexpected) with some sanity. */
			thread__put(a);
			thread__put(b);
			return !a && !b ? 0 : (!a ? -1 : 1);
992 993
		}
	}
994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010
	if (thread__tid(a) == thread__tid(b)) {
		/* a is a child of b or vice-versa, deeper levels appear later. */
		res = level_a < level_b ? -1 : (level_a > level_b ? 1 : 0);
	} else {
		/* Sort by tid now the parent is the same. */
		res = thread__tid(a) < thread__tid(b) ? -1 : 1;
	}
	thread__put(a);
	thread__put(b);
	return res;
}

static int tasks_print(struct report *rep, FILE *fp)
{
	struct machine *machine = &rep->session->machines.host;
	LIST_HEAD(tasks);
	int ret;
1011

1012 1013 1014
	ret = machine__thread_list(machine, &tasks);
	if (!ret) {
		struct thread_list *task;
1015

1016
		list_sort(machine, &tasks, task_list_cmp);
1017

1018 1019 1020 1021 1022 1023 1024
		fprintf(fp, "# %8s %8s %8s  %s\n", "pid", "tid", "ppid", "comm");

		list_for_each_entry(task, &tasks, list)
			task__print_level(machine, task->thread, fp);
	}
	thread_list__delete(&tasks);
	return ret;
1025 1026
}

1027
static int __cmd_report(struct report *rep)
1028
{
1029
	int ret;
1030
	struct perf_session *session = rep->session;
1031
	struct evsel *pos;
1032
	struct perf_data *data = session->data;
1033

1034 1035
	signal(SIGINT, sig_handler);

1036 1037 1038
	if (rep->cpu_list) {
		ret = perf_session__cpu_bitmap(session, rep->cpu_list,
					       rep->cpu_bitmap);
1039 1040
		if (ret) {
			ui__error("failed to set cpu bitmap\n");
1041
			return ret;
1042
		}
1043
		session->itrace_synth_opts->cpu_bitmap = rep->cpu_bitmap;
1044 1045
	}

1046 1047 1048 1049 1050
	if (rep->show_threads) {
		ret = perf_read_values_init(&rep->show_threads_values);
		if (ret)
			return ret;
	}
1051

1052
	ret = report__setup_sample_type(rep);
1053 1054
	if (ret) {
		/* report__setup_sample_type() already showed error message */
1055
		return ret;
1056
	}
1057

1058 1059 1060
	if (rep->stats_mode)
		stats_setup(rep);

1061 1062 1063
	if (rep->tasks_mode)
		tasks_setup(rep);

1064
	ret = perf_session__process_events(session);
1065 1066
	if (ret) {
		ui__error("failed to process sample\n");
1067
		return ret;
1068
	}
1069

1070 1071
	evlist__check_mem_load_aux(session->evlist);

1072 1073 1074
	if (rep->stats_mode)
		return stats_print(rep);

1075 1076 1077
	if (rep->tasks_mode)
		return tasks_print(rep, stdout);

1078
	report__warn_kptr_restrict(rep);
1079

1080
	evlist__for_each_entry(session->evlist, pos)
1081 1082
		rep->nr_entries += evsel__hists(pos)->nr_entries;

1083 1084 1085
	if (use_browser == 0) {
		if (verbose > 3)
			perf_session__fprintf(session, stdout);
1086

1087 1088
		if (verbose > 2)
			perf_session__fprintf_dsos(session, stdout);
1089

1090
		if (dump_trace) {
1091 1092 1093 1094
			perf_session__fprintf_nr_events(session, stdout,
							rep->skip_empty);
			evlist__fprintf_nr_events(session->evlist, stdout,
						  rep->skip_empty);
1095 1096
			return 0;
		}
1097 1098
	}

1099 1100 1101 1102 1103
	ret = report__collapse_hists(rep);
	if (ret) {
		ui__error("failed to process hist entry\n");
		return ret;
	}
1104

1105 1106 1107
	if (session_done())
		return 0;

1108 1109 1110 1111 1112
	/*
	 * recalculate number of entries after collapsing since it
	 * might be changed during the collapse phase.
	 */
	rep->nr_entries = 0;
1113
	evlist__for_each_entry(session->evlist, pos)
1114 1115
		rep->nr_entries += evsel__hists(pos)->nr_entries;

1116
	if (rep->nr_entries == 0) {
1117
		ui__error("The %s data has no samples!\n", data->path);
1118
		return 0;
1119 1120
	}

1121
	report__output_resort(rep);
1122

1123
	if (rep->total_cycles_mode) {
1124 1125 1126 1127 1128 1129 1130 1131 1132
		int block_hpps[6] = {
			PERF_HPP_REPORT__BLOCK_TOTAL_CYCLES_PCT,
			PERF_HPP_REPORT__BLOCK_LBR_CYCLES,
			PERF_HPP_REPORT__BLOCK_CYCLES_PCT,
			PERF_HPP_REPORT__BLOCK_AVG_CYCLES,
			PERF_HPP_REPORT__BLOCK_RANGE,
			PERF_HPP_REPORT__BLOCK_DSO,
		};

1133
		rep->block_reports = block_info__create_report(session->evlist,
1134 1135 1136
							       rep->total_cycles,
							       block_hpps, 6,
							       &rep->nr_block_reports);
1137 1138 1139 1140
		if (!rep->block_reports)
			return -1;
	}

1141
	return report__browse_hists(rep);
1142 1143
}

1144
static int
1145
report_parse_callchain_opt(const struct option *opt, const char *arg, int unset)
1146
{
1147
	struct callchain_param *callchain = opt->value;
1148

1149
	callchain->enabled = !unset;
1150 1151 1152 1153
	/*
	 * --no-call-graph
	 */
	if (unset) {
1154 1155
		symbol_conf.use_callchain = false;
		callchain->mode = CHAIN_NONE;
1156 1157 1158
		return 0;
	}

1159
	return parse_callchain_report_opt(arg);
1160 1161
}

1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175
static int
parse_time_quantum(const struct option *opt, const char *arg,
		   int unset __maybe_unused)
{
	unsigned long *time_q = opt->value;
	char *end;

	*time_q = strtoul(arg, &end, 0);
	if (end == arg)
		goto parse_err;
	if (*time_q == 0) {
		pr_err("time quantum cannot be 0");
		return -1;
	}
1176
	end = skip_spaces(end);
1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197
	if (*end == 0)
		return 0;
	if (!strcmp(end, "s")) {
		*time_q *= NSEC_PER_SEC;
		return 0;
	}
	if (!strcmp(end, "ms")) {
		*time_q *= NSEC_PER_MSEC;
		return 0;
	}
	if (!strcmp(end, "us")) {
		*time_q *= NSEC_PER_USEC;
		return 0;
	}
	if (!strcmp(end, "ns"))
		return 0;
parse_err:
	pr_err("Cannot parse time quantum `%s'\n", arg);
	return -1;
}

1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215
int
report_parse_ignore_callees_opt(const struct option *opt __maybe_unused,
				const char *arg, int unset __maybe_unused)
{
	if (arg) {
		int err = regcomp(&ignore_callees_regex, arg, REG_EXTENDED);
		if (err) {
			char buf[BUFSIZ];
			regerror(err, &ignore_callees_regex, buf, sizeof(buf));
			pr_err("Invalid --ignore-callees regex: %s\n%s", arg, buf);
			return -1;
		}
		have_ignore_callees = 1;
	}

	return 0;
}

1216
static int
1217
parse_branch_mode(const struct option *opt,
1218
		  const char *str __maybe_unused, int unset)
1219
{
1220 1221 1222
	int *branch_mode = opt->value;

	*branch_mode = !unset;
1223 1224 1225
	return 0;
}

1226 1227 1228 1229
static int
parse_percent_limit(const struct option *opt, const char *str,
		    int unset __maybe_unused)
{
1230
	struct report *rep = opt->value;
1231
	double pcnt = strtof(str, NULL);
1232

1233 1234
	rep->min_percent = pcnt;
	callchain_param.min_percent = pcnt;
1235 1236 1237
	return 0;
}

1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252
static int process_attr(struct perf_tool *tool __maybe_unused,
			union perf_event *event,
			struct evlist **pevlist)
{
	u64 sample_type;
	int err;

	err = perf_event__process_attr(tool, event, pevlist);
	if (err)
		return err;

	/*
	 * Check if we need to enable callchains based
	 * on events sample_type.
	 */
1253
	sample_type = evlist__combined_sample_type(*pevlist);
1254
	callchain_param_setup(sample_type, perf_env__arch((*pevlist)->env));
1255 1256 1257
	return 0;
}

1258
int cmd_report(int argc, const char **argv)
1259
{
1260
	struct perf_session *session;
1261
	struct itrace_synth_opts itrace_synth_opts = { .set = 0, };
1262
	struct stat st;
1263
	bool has_br_stack = false;
1264
	int branch_mode = -1;
1265
	int last_key = 0;
1266
	bool branch_call_mode = false;
1267
#define CALLCHAIN_DEFAULT_OPT  "graph,0.5,caller,function,percent"
1268 1269 1270
	static const char report_callchain_help[] = "Display call graph (stack chain/backtrace):\n\n"
						    CALLCHAIN_REPORT_HELP
						    "\n\t\t\t\tDefault: " CALLCHAIN_DEFAULT_OPT;
1271
	char callchain_default_opt[] = CALLCHAIN_DEFAULT_OPT;
1272
	const char * const report_usage[] = {
Namhyung Kim's avatar
Namhyung Kim committed
1273
		"perf report [<options>]",
1274 1275
		NULL
	};
1276
	struct report report = {
1277
		.tool = {
1278 1279
			.sample		 = process_sample_event,
			.mmap		 = perf_event__process_mmap,
1280
			.mmap2		 = perf_event__process_mmap2,
1281
			.comm		 = perf_event__process_comm,
1282
			.namespaces	 = perf_event__process_namespaces,
1283
			.cgroup		 = perf_event__process_cgroup,
1284 1285
			.exit		 = perf_event__process_exit,
			.fork		 = perf_event__process_fork,
1286 1287
			.lost		 = perf_event__process_lost,
			.read		 = process_read_event,
1288
			.attr		 = process_attr,
1289
#ifdef HAVE_LIBTRACEEVENT
1290
			.tracing_data	 = perf_event__process_tracing_data,
1291
#endif
1292
			.build_id	 = perf_event__process_build_id,
1293 1294 1295
			.id_index	 = perf_event__process_id_index,
			.auxtrace_info	 = perf_event__process_auxtrace_info,
			.auxtrace	 = perf_event__process_auxtrace,
1296
			.event_update	 = perf_event__process_event_update,
1297
			.feature	 = process_feature_event,
1298
			.ordered_events	 = true,
1299 1300
			.ordering_requires_timestamps = true,
		},
1301
		.max_stack		 = PERF_MAX_STACK_DEPTH,
1302
		.pretty_printing_style	 = "normal",
1303
		.socket_filter		 = -1,
1304
		.skip_empty		 = true,
1305
	};
1306 1307
	char *sort_order_help = sort_help("sort by key(s):");
	char *field_order_help = sort_help("output field(s): overhead period sample ");
1308
	const char *disassembler_style = NULL, *objdump_path = NULL, *addr2line_path = NULL;
1309
	const struct option options[] = {
1310
	OPT_STRING('i', "input", &input_name, "file",
1311
		    "input file name"),
1312
	OPT_INCR('v', "verbose", &verbose,
1313
		    "be more verbose (show symbol address, etc)"),
1314
	OPT_BOOLEAN('q', "quiet", &quiet, "Do not show any warnings or messages"),
1315 1316
	OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
		    "dump raw trace in ASCII"),
1317
	OPT_BOOLEAN(0, "stats", &report.stats_mode, "Display event stats"),
1318
	OPT_BOOLEAN(0, "tasks", &report.tasks_mode, "Display recorded tasks"),
1319
	OPT_BOOLEAN(0, "mmaps", &report.mmaps_mode, "Display recorded tasks memory maps"),
1320 1321
	OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
		   "file", "vmlinux pathname"),
1322 1323
	OPT_BOOLEAN(0, "ignore-vmlinux", &symbol_conf.ignore_vmlinux,
                    "don't load vmlinux even if found"),
1324 1325
	OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name,
		   "file", "kallsyms pathname"),
1326
	OPT_BOOLEAN('f', "force", &symbol_conf.force, "don't complain, do it"),
1327
	OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
1328
		    "load module symbols - WARNING: use only with -k and LIVE kernel"),
1329
	OPT_BOOLEAN('n', "show-nr-samples", &symbol_conf.show_nr_samples,
1330
		    "Show a column with the number of samples"),
1331
	OPT_BOOLEAN('T', "threads", &report.show_threads,
1332
		    "Show per-thread event counters"),
1333
	OPT_STRING(0, "pretty", &report.pretty_printing_style, "key",
1334
		   "pretty printing style key: normal raw"),
1335
#ifdef HAVE_SLANG_SUPPORT
1336
	OPT_BOOLEAN(0, "tui", &report.use_tui, "Use the TUI interface"),
1337
#endif
1338
#ifdef HAVE_GTK2_SUPPORT
1339
	OPT_BOOLEAN(0, "gtk", &report.use_gtk, "Use the GTK2 interface"),
1340
#endif
1341 1342
	OPT_BOOLEAN(0, "stdio", &report.use_stdio,
		    "Use the stdio interface"),
1343 1344 1345
	OPT_BOOLEAN(0, "header", &report.header, "Show data header."),
	OPT_BOOLEAN(0, "header-only", &report.header_only,
		    "Show only data header."),
1346
	OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
1347
		   sort_order_help),
1348
	OPT_STRING('F', "fields", &field_order, "key[,keys...]",
1349
		   field_order_help),
1350
	OPT_BOOLEAN(0, "show-cpu-utilization", &symbol_conf.show_cpu_utilization,
1351
		    "Show sample percentage for different cpu modes"),
1352 1353
	OPT_BOOLEAN_FLAG(0, "showcpuutilization", &symbol_conf.show_cpu_utilization,
		    "Show sample percentage for different cpu modes", PARSE_OPT_HIDDEN),
1354 1355
	OPT_STRING('p', "parent", &parent_pattern, "regex",
		   "regex filter to identify parent, see: '--sort parent'"),
1356
	OPT_BOOLEAN('x', "exclude-other", &symbol_conf.exclude_other,
1357
		    "Only display entries with parent-match"),
1358
	OPT_CALLBACK_DEFAULT('g', "call-graph", &callchain_param,
1359
			     "print_type,threshold[,print_limit],order,sort_key[,branch],value",
1360 1361
			     report_callchain_help, &report_parse_callchain_opt,
			     callchain_default_opt),
1362
	OPT_BOOLEAN(0, "children", &symbol_conf.cumulate_callchain,
1363 1364
		    "Accumulate callchains of children and show total overhead as well. "
		    "Enabled by default, use --no-children to disable."),
1365 1366 1367
	OPT_INTEGER(0, "max-stack", &report.max_stack,
		    "Set the maximum stack depth when parsing the callchain, "
		    "anything beyond the specified depth will be ignored. "
1368
		    "Default: kernel.perf_event_max_stack or " __stringify(PERF_MAX_STACK_DEPTH)),
1369 1370
	OPT_BOOLEAN('G', "inverted", &report.inverted_callchain,
		    "alias for inverted call graph"),
1371 1372 1373
	OPT_CALLBACK(0, "ignore-callees", NULL, "regex",
		   "ignore callees of these functions in call graphs",
		   report_parse_ignore_callees_opt),
1374
	OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
1375
		   "only consider symbols in these dsos"),
1376
	OPT_STRING('c', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
1377
		   "only consider symbols in these comms"),
1378 1379 1380 1381
	OPT_STRING(0, "pid", &symbol_conf.pid_list_str, "pid[,pid...]",
		   "only consider symbols in these pids"),
	OPT_STRING(0, "tid", &symbol_conf.tid_list_str, "tid[,tid...]",
		   "only consider symbols in these tids"),
1382
	OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
1383
		   "only consider these symbols"),
1384 1385
	OPT_STRING(0, "symbol-filter", &report.symbol_filter_str, "filter",
		   "only show symbols that (partially) match with this filter"),
1386
	OPT_STRING('w', "column-widths", &symbol_conf.col_width_list_str,
1387 1388
		   "width[,width...]",
		   "don't try to adjust column width, use these fixed values"),
1389
	OPT_STRING_NOEMPTY('t', "field-separator", &symbol_conf.field_sep, "separator",
1390 1391
		   "separator for columns, no spaces will be added between "
		   "columns '.' is reserved."),
1392
	OPT_BOOLEAN('U', "hide-unresolved", &symbol_conf.hide_unresolved,
1393
		    "Only display entries resolved to a symbol"),
1394 1395 1396
	OPT_CALLBACK(0, "symfs", NULL, "directory",
		     "Look for files with symbols relative to this directory",
		     symbol__config_symfs),
1397
	OPT_STRING('C', "cpu", &report.cpu_list, "cpu",
1398 1399
		   "list of cpus to profile"),
	OPT_BOOLEAN('I', "show-info", &report.show_full_info,
1400
		    "Display extended information about perf.data file"),
1401
	OPT_BOOLEAN(0, "source", &annotate_opts.annotate_src,
1402
		    "Interleave source code with assembly code (default)"),
1403
	OPT_BOOLEAN(0, "asm-raw", &annotate_opts.show_asm_raw,
1404
		    "Display raw encoding of assembly instructions (default)"),
1405
	OPT_STRING('M', "disassembler-style", &disassembler_style, "disassembler style",
1406
		   "Specify disassembler style (e.g. -M intel for intel syntax)"),
1407
	OPT_STRING(0, "prefix", &annotate_opts.prefix, "prefix",
1408
		    "Add prefix to source file path names in programs (with --prefix-strip)"),
1409
	OPT_STRING(0, "prefix-strip", &annotate_opts.prefix_strip, "N",
1410
		    "Strip first N entries of source file path name in programs (with --prefix)"),
1411 1412
	OPT_BOOLEAN(0, "show-total-period", &symbol_conf.show_total_period,
		    "Show a column with the sum of periods"),
1413
	OPT_BOOLEAN_SET(0, "group", &symbol_conf.event_group, &report.group_set,
1414
		    "Show event group information together"),
1415 1416 1417 1418
	OPT_INTEGER(0, "group-sort-idx", &symbol_conf.group_sort_idx,
		    "Sort the output by the event at the index n in group. "
		    "If n is invalid, sort by the first event. "
		    "WARNING: should be used on grouped events."),
1419
	OPT_CALLBACK_NOOPT('b', "branch-stack", &branch_mode, "",
1420 1421 1422 1423
		    "use branch records for per branch histogram filling",
		    parse_branch_mode),
	OPT_BOOLEAN(0, "branch-history", &branch_call_mode,
		    "add last branch records to call history"),
1424
	OPT_STRING(0, "objdump", &objdump_path, "path",
1425
		   "objdump binary to use for disassembly and annotations"),
1426 1427
	OPT_STRING(0, "addr2line", &addr2line_path, "path",
		   "addr2line binary to use for line numbers"),
1428 1429
	OPT_BOOLEAN(0, "demangle", &symbol_conf.demangle,
		    "Disable symbol demangling"),
1430 1431
	OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf.demangle_kernel,
		    "Enable kernel symbol demangling"),
1432
	OPT_BOOLEAN(0, "mem-mode", &report.mem_mode, "mem access profile"),
1433 1434
	OPT_INTEGER(0, "samples", &symbol_conf.res_sample,
		    "Number of samples to save per histogram entry for individual browsing"),
1435 1436
	OPT_CALLBACK(0, "percent-limit", &report, "percent",
		     "Don't show entries under that percent", parse_percent_limit),
1437
	OPT_CALLBACK(0, "percentage", NULL, "relative|absolute",
1438
		     "how to display percentage of filtered entries", parse_filter_percentage),
1439
	OPT_CALLBACK_OPTARG(0, "itrace", &itrace_synth_opts, NULL, "opts",
1440
			    "Instruction Tracing options\n" ITRACE_HELP,
1441
			    itrace_parse_synth_opts),
1442 1443
	OPT_BOOLEAN(0, "full-source-path", &srcline_full_filename,
			"Show full source file name path for source lines"),
1444 1445
	OPT_BOOLEAN(0, "show-ref-call-graph", &symbol_conf.show_ref_callgraph,
		    "Show callgraph from reference event"),
1446 1447
	OPT_BOOLEAN(0, "stitch-lbr", &report.stitch_lbr,
		    "Enable LBR callgraph stitching approach"),
1448 1449
	OPT_INTEGER(0, "socket-filter", &report.socket_filter,
		    "only show processor socket that match with this filter"),
1450 1451
	OPT_BOOLEAN(0, "raw-trace", &symbol_conf.raw_trace,
		    "Show raw trace event output (do not use print fmt or plugins)"),
1452
	OPT_BOOLEAN('H', "hierarchy", &symbol_conf.report_hierarchy,
1453
		    "Show entries in a hierarchy"),
1454 1455 1456
	OPT_CALLBACK_DEFAULT(0, "stdio-color", NULL, "mode",
			     "'always' (default), 'never' or 'auto' only applicable to --stdio mode",
			     stdio__config_color, "always"),
1457 1458
	OPT_STRING(0, "time", &report.time_str, "str",
		   "Time span of interest (start,stop)"),
1459 1460
	OPT_BOOLEAN(0, "inline", &symbol_conf.inline_name,
		    "Show inline function"),
1461
	OPT_CALLBACK(0, "percent-type", &annotate_opts, "local-period",
1462 1463
		     "Set percent type local/global-period/hits",
		     annotate_parse_percent_type),
1464
	OPT_BOOLEAN(0, "ns", &symbol_conf.nanosecs, "Show times in nanosecs"),
1465 1466 1467
	OPT_CALLBACK(0, "time-quantum", &symbol_conf.time_quantum, "time (ms|us|ns|s)",
		     "Set time quantum for time sort key (default 100ms)",
		     parse_time_quantum),
1468
	OPTS_EVSWITCH(&report.evswitch),
1469 1470
	OPT_BOOLEAN(0, "total-cycles", &report.total_cycles_mode,
		    "Sort all blocks by 'Sampled Cycles%'"),
1471 1472
	OPT_BOOLEAN(0, "disable-order", &report.disable_order,
		    "Disable raw trace ordering"),
1473 1474
	OPT_BOOLEAN(0, "skip-empty", &report.skip_empty,
		    "Do not display empty (or dummy) events in the output"),
1475
	OPT_END()
1476
	};
1477
	struct perf_data data = {
1478 1479
		.mode  = PERF_DATA_MODE_READ,
	};
1480
	int ret = hists__init();
1481
	char sort_tmp[128];
1482 1483

	if (ret < 0)
1484
		goto exit;
1485

1486 1487 1488 1489 1490 1491 1492
	/*
	 * tasks_mode require access to exited threads to list those that are in
	 * the data file. Off-cpu events are synthesized after other events and
	 * reference exited threads.
	 */
	symbol_conf.keep_exited_threads = true;

1493
	annotation_options__init();
1494

1495 1496
	ret = perf_config(report__config, &report);
	if (ret)
1497
		goto exit;
1498

1499
	argc = parse_options(argc, argv, options, report_usage, 0);
1500 1501 1502 1503 1504 1505 1506 1507 1508 1509
	if (argc) {
		/*
		 * Special case: if there's an argument left then assume that
		 * it's a symbol filter:
		 */
		if (argc > 1)
			usage_with_options(report_usage, options);

		report.symbol_filter_str = argv[0];
	}
1510

1511
	if (disassembler_style) {
1512 1513
		annotate_opts.disassembler_style = strdup(disassembler_style);
		if (!annotate_opts.disassembler_style)
1514 1515 1516
			return -ENOMEM;
	}
	if (objdump_path) {
1517 1518
		annotate_opts.objdump_path = strdup(objdump_path);
		if (!annotate_opts.objdump_path)
1519 1520
			return -ENOMEM;
	}
1521 1522 1523 1524 1525
	if (addr2line_path) {
		symbol_conf.addr2line_path = strdup(addr2line_path);
		if (!symbol_conf.addr2line_path)
			return -ENOMEM;
	}
1526

1527
	if (annotate_check_args() < 0) {
1528 1529 1530
		ret = -EINVAL;
		goto exit;
	}
1531

1532 1533 1534
	if (report.mmaps_mode)
		report.tasks_mode = true;

1535
	if (dump_trace && report.disable_order)
1536 1537
		report.tool.ordered_events = false;

1538 1539 1540
	if (quiet)
		perf_quiet_option();

1541 1542
	ret = symbol__validate_sym_arguments();
	if (ret)
1543
		goto exit;
1544

1545
	if (report.inverted_callchain)
1546
		callchain_param.order = ORDER_CALLER;
1547 1548
	if (symbol_conf.cumulate_callchain && !callchain_param.order_set)
		callchain_param.order = ORDER_CALLER;
1549

1550
	if ((itrace_synth_opts.callchain || itrace_synth_opts.add_callchain) &&
1551 1552 1553
	    (int)itrace_synth_opts.callchain_sz > report.max_stack)
		report.max_stack = itrace_synth_opts.callchain_sz;

1554
	if (!input_name || !strlen(input_name)) {
1555
		if (!fstat(STDIN_FILENO, &st) && S_ISFIFO(st.st_mode))
1556
			input_name = "-";
1557
		else
1558
			input_name = "perf.data";
1559
	}
1560

1561 1562
	data.path  = input_name;
	data.force = symbol_conf.force;
1563

1564
repeat:
1565
	session = perf_session__new(&data, &report.tool);
1566 1567 1568 1569
	if (IS_ERR(session)) {
		ret = PTR_ERR(session);
		goto exit;
	}
1570

1571 1572
	ret = evswitch__init(&report.evswitch, session->evlist, stderr);
	if (ret)
1573
		goto exit;
1574

1575 1576 1577
	if (zstd_init(&(session->zstd_data), 0) < 0)
		pr_warning("Decompression initialization failed. Reported data may be incomplete.\n");

1578 1579 1580 1581 1582
	if (report.queue_size) {
		ordered_events__set_alloc_size(&session->ordered_events,
					       report.queue_size);
	}

1583 1584
	session->itrace_synth_opts = &itrace_synth_opts;

1585 1586 1587 1588
	report.session = session;

	has_br_stack = perf_header__has_feat(&session->header,
					     HEADER_BRANCH_STACK);
1589
	if (evlist__combined_sample_type(session->evlist) & PERF_SAMPLE_STACK_USER)
1590
		has_br_stack = false;
1591

1592
	setup_forced_leader(&report, session->evlist);
1593

1594
	if (symbol_conf.group_sort_idx && evlist__nr_groups(session->evlist) == 0) {
1595 1596 1597 1598 1599
		parse_options_usage(NULL, options, "group-sort-idx", 0);
		ret = -EINVAL;
		goto error;
	}

1600
	if (itrace_synth_opts.last_branch || itrace_synth_opts.add_last_branch)
1601 1602
		has_br_stack = true;

1603 1604 1605
	if (has_br_stack && branch_call_mode)
		symbol_conf.show_branchflag_count = true;

1606 1607
	memset(&report.brtype_stat, 0, sizeof(struct branch_type_stat));

1608 1609 1610 1611 1612 1613
	/*
	 * Branch mode is a tristate:
	 * -1 means default, so decide based on the file having branch data.
	 * 0/1 means the user chose a mode.
	 */
	if (((branch_mode == -1 && has_br_stack) || branch_mode == 1) &&
1614
	    !branch_call_mode) {
1615
		sort__mode = SORT_MODE__BRANCH;
1616 1617
		symbol_conf.cumulate_callchain = false;
	}
1618
	if (branch_call_mode) {
1619
		callchain_param.key = CCKEY_ADDRESS;
1620
		callchain_param.branch_callstack = true;
1621 1622 1623 1624 1625
		symbol_conf.use_callchain = true;
		callchain_register_param(&callchain_param);
		if (sort_order == NULL)
			sort_order = "srcline,symbol,dso";
	}
1626

1627
	if (report.mem_mode) {
1628
		if (sort__mode == SORT_MODE__BRANCH) {
1629
			pr_err("branch and mem mode incompatible\n");
1630 1631
			goto error;
		}
1632
		sort__mode = SORT_MODE__MEMORY;
1633
		symbol_conf.cumulate_callchain = false;
1634
	}
1635

1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646
	if (symbol_conf.report_hierarchy) {
		/* disable incompatible options */
		symbol_conf.cumulate_callchain = false;

		if (field_order) {
			pr_err("Error: --hierarchy and --fields options cannot be used together\n");
			parse_options_usage(report_usage, options, "F", 1);
			parse_options_usage(NULL, options, "hierarchy", 0);
			goto error;
		}

1647
		perf_hpp_list.need_collapse = true;
1648 1649
	}

1650 1651
	if (report.use_stdio)
		use_browser = 0;
1652
#ifdef HAVE_SLANG_SUPPORT
1653 1654
	else if (report.use_tui)
		use_browser = 1;
1655
#endif
1656
#ifdef HAVE_GTK2_SUPPORT
1657 1658
	else if (report.use_gtk)
		use_browser = 2;
1659
#endif
1660

1661 1662
	/* Force tty output for header output and per-thread stat. */
	if (report.header || report.header_only || report.show_threads)
1663
		use_browser = 0;
1664 1665 1666 1667
	if (report.header || report.header_only)
		report.tool.show_feat_hdr = SHOW_FEAT_HEADER;
	if (report.show_full_info)
		report.tool.show_feat_hdr = SHOW_FEAT_HEADER_FULL_INFO;
1668
	if (report.stats_mode || report.tasks_mode)
1669
		use_browser = 0;
1670
	if (report.stats_mode && report.tasks_mode) {
1671
		pr_err("Error: --tasks and --mmaps can't be used together with --stats\n");
1672 1673
		goto error;
	}
1674

1675 1676 1677
	if (report.total_cycles_mode) {
		if (sort__mode != SORT_MODE__BRANCH)
			report.total_cycles_mode = false;
1678
		else
1679
			sort_order = NULL;
1680 1681
	}

1682 1683 1684 1685 1686 1687 1688 1689 1690 1691
	if (sort_order && strstr(sort_order, "type")) {
		report.data_type = true;
		annotate_opts.annotate_src = false;

#ifndef HAVE_DWARF_GETLOCATIONS_SUPPORT
		pr_err("Error: Data type profiling is disabled due to missing DWARF support\n");
		goto error;
#endif
	}

1692 1693
	if (strcmp(input_name, "-") != 0)
		setup_browser(true);
1694
	else
1695 1696
		use_browser = 0;

1697 1698 1699 1700 1701
	if (report.data_type && use_browser == 1) {
		symbol_conf.annotate_data_member = true;
		symbol_conf.annotate_data_sample = true;
	}

1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719
	if (sort_order && strstr(sort_order, "ipc")) {
		parse_options_usage(report_usage, options, "s", 1);
		goto error;
	}

	if (sort_order && strstr(sort_order, "symbol")) {
		if (sort__mode == SORT_MODE__BRANCH) {
			snprintf(sort_tmp, sizeof(sort_tmp), "%s,%s",
				 sort_order, "ipc_lbr");
			report.symbol_ipc = true;
		} else {
			snprintf(sort_tmp, sizeof(sort_tmp), "%s,%s",
				 sort_order, "ipc_null");
		}

		sort_order = sort_tmp;
	}

1720
	if ((last_key != K_SWITCH_INPUT_DATA && last_key != K_RELOAD) &&
1721
	    (setup_sorting(session->evlist) < 0)) {
1722 1723 1724 1725 1726 1727 1728 1729
		if (sort_order)
			parse_options_usage(report_usage, options, "s", 1);
		if (field_order)
			parse_options_usage(sort_order ? NULL : report_usage,
					    options, "F", 1);
		goto error;
	}

1730
	if ((report.header || report.header_only) && !quiet) {
1731 1732
		perf_session__fprintf_info(session, stdout,
					   report.show_full_info);
1733
		if (report.header_only) {
1734 1735 1736 1737 1738 1739 1740
			if (data.is_pipe) {
				/*
				 * we need to process first few records
				 * which contains PERF_RECORD_HEADER_FEATURE.
				 */
				perf_session__process_events(session);
			}
1741 1742 1743
			ret = 0;
			goto error;
		}
1744 1745
	} else if (use_browser == 0 && !quiet &&
		   !report.stats_mode && !report.tasks_mode) {
1746 1747 1748 1749
		fputs("# To display the perf.data header info, please use --header/--header-only options.\n#\n",
		      stdout);
	}

1750
	/*
1751
	 * Only in the TUI browser we are doing integrated annotation,
1752 1753 1754
	 * so don't allocate extra space that won't be used in the stdio
	 * implementation.
	 */
1755
	if (ui__has_annotation() || report.symbol_ipc || report.data_type ||
1756
	    report.total_cycles_mode) {
1757 1758 1759
		ret = symbol__annotation_init();
		if (ret < 0)
			goto error;
1760 1761 1762 1763 1764
		/*
 		 * For searching by name on the "Browse map details".
 		 * providing it only in verbose mode not to bloat too
 		 * much struct symbol.
 		 */
1765
		if (verbose > 0) {
1766 1767 1768 1769 1770 1771 1772 1773
			/*
			 * XXX: Need to provide a less kludgy way to ask for
			 * more space per symbol, the u32 is for the index on
			 * the ui browser.
			 * See symbol__browser_index.
			 */
			symbol_conf.priv_size += sizeof(u32);
		}
1774
		annotation_config__init();
1775
	}
1776

1777
	if (symbol__init(&session->header.env) < 0)
1778
		goto error;
1779

1780 1781 1782 1783 1784 1785
	if (report.time_str) {
		ret = perf_time__parse_for_ranges(report.time_str, session,
						  &report.ptime_range,
						  &report.range_size,
						  &report.range_num);
		if (ret < 0)
1786
			goto error;
1787 1788 1789 1790

		itrace_synth_opts__set_time_range(&itrace_synth_opts,
						  report.ptime_range,
						  report.range_num);
1791 1792
	}

1793
#ifdef HAVE_LIBTRACEEVENT
1794
	if (session->tevent.pevent &&
1795 1796 1797
	    tep_set_function_resolver(session->tevent.pevent,
				      machine__resolve_kernel_addr,
				      &session->machines.host) < 0) {
1798 1799 1800 1801
		pr_err("%s: failed to set libtraceevent function resolver\n",
		       __func__);
		return -1;
	}
1802
#endif
1803
	sort__setup_elide(stdout);
1804

1805
	ret = __cmd_report(&report);
1806
	if (ret == K_SWITCH_INPUT_DATA || ret == K_RELOAD) {
1807
		perf_session__delete(session);
1808
		last_key = K_SWITCH_INPUT_DATA;
1809 1810 1811 1812
		goto repeat;
	} else
		ret = 0;

1813 1814
	if (!use_browser && (verbose > 2 || debug_kmaps))
		perf_session__dump_kmaps(session);
1815
error:
1816 1817
	if (report.ptime_range) {
		itrace_synth_opts__clear_time_range(&itrace_synth_opts);
1818
		zfree(&report.ptime_range);
1819
	}
1820

1821 1822 1823 1824 1825
	if (report.block_reports) {
		block_info__free_report(report.block_reports,
					report.nr_block_reports);
		report.block_reports = NULL;
	}
1826

1827
	zstd_fini(&(session->zstd_data));
1828
	perf_session__delete(session);
1829
exit:
1830
	annotation_options__exit();
1831 1832
	free(sort_order_help);
	free(field_order_help);
1833
	return ret;
1834
}