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