blob: b63b3fb2de7012698dd0f68ab1535791df8e00f8 [file] [log] [blame]
Greg Kroah-Hartmanb2441312017-11-01 15:07:57 +01001// SPDX-License-Identifier: GPL-2.0
Ingo Molnarbf9e1872009-06-02 23:37:05 +02002/*
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 */
Ingo Molnar16f762a2009-05-27 09:10:38 +02009#include "builtin.h"
Ingo Molnar53cb8bc2009-05-26 09:17:18 +020010
Taeung Song41840d22016-06-23 17:55:17 +090011#include "util/config.h"
Ingo Molnarbf9e1872009-06-02 23:37:05 +020012
Arnaldo Carvalho de Melo78f7def2011-02-04 09:45:46 -020013#include "util/annotate.h"
Ingo Molnar8fc03212009-06-04 15:19:47 +020014#include "util/color.h"
Arnaldo Carvalho de Melo4a3cec82019-08-30 11:11:01 -030015#include "util/dso.h"
Arnaldo Carvalho de Melo5da50252009-07-01 14:46:08 -030016#include <linux/list.h>
Arnaldo Carvalho de Melo43cbcd82009-07-01 12:28:37 -030017#include <linux/rbtree.h>
Jiri Olsa930f8b32018-01-07 17:03:56 +010018#include <linux/err.h>
Arnaldo Carvalho de Melo7f7c5362019-07-04 11:32:27 -030019#include <linux/zalloc.h>
Arnaldo Carvalho de Melo1101f692019-01-27 13:42:37 +010020#include "util/map.h"
Arnaldo Carvalho de Meloa2928c42009-05-28 14:55:04 -030021#include "util/symbol.h"
Arnaldo Carvalho de Melod3300a32019-08-30 15:09:54 -030022#include "util/map_symbol.h"
23#include "util/mem-events.h"
24#include "util/branch.h"
Frederic Weisbeckerf55c5552009-06-26 16:28:01 +020025#include "util/callchain.h"
Brice Goglin8d513272009-08-07 13:55:24 +020026#include "util/values.h"
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -030027
Ingo Molnar53cb8bc2009-05-26 09:17:18 +020028#include "perf.h"
Frederic Weisbecker8f288272009-08-16 22:05:48 +020029#include "util/debug.h"
Arnaldo Carvalho de Meloe248de32011-03-05 21:40:06 -030030#include "util/evlist.h"
31#include "util/evsel.h"
Arnaldo Carvalho de Meloef4b1a52019-08-15 18:18:58 -030032#include "util/evswitch.h"
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +020033#include "util/header.h"
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -020034#include "util/session.h"
Arnaldo Carvalho de Melo97b9d862019-08-22 17:10:08 -030035#include "util/srcline.h"
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -020036#include "util/tool.h"
Ingo Molnar53cb8bc2009-05-26 09:17:18 +020037
Josh Poimboeuf4b6ab942015-12-15 09:39:39 -060038#include <subcmd/parse-options.h>
Namhyung Kim34b7b0f2016-01-09 19:16:29 +090039#include <subcmd/exec-cmd.h>
Ingo Molnar53cb8bc2009-05-26 09:17:18 +020040#include "util/parse-events.h"
41
Frederic Weisbecker6baa0a5a2009-08-14 12:21:53 +020042#include "util/thread.h"
John Kacurdd68ada2009-09-24 18:02:49 +020043#include "util/sort.h"
John Kacur3d1d07e2009-09-28 15:32:55 +020044#include "util/hist.h"
Jiri Olsaf5fc14122013-10-15 16:27:32 +020045#include "util/data.h"
Irina Tirdea68e94f42012-10-16 02:33:38 +030046#include "arch/common.h"
David Ahern46690a82016-11-29 10:15:46 -070047#include "util/time-utils.h"
Adrian Hunter520a2eb2015-04-24 22:29:45 +030048#include "util/auxtrace.h"
Arnaldo Carvalho de Melo58db1d62017-04-19 16:05:56 -030049#include "util/units.h"
Arnaldo Carvalho de Melofb71c86c2019-09-03 10:56:06 -030050#include "util/util.h" // perf_tip()
Arnaldo Carvalho de Melo8520a982019-08-29 16:18:59 -030051#include "ui/ui.h"
Arnaldo Carvalho de Melo171f7472019-08-30 11:28:14 -030052#include "ui/progress.h"
Jin Yao6f7164f2019-11-07 15:47:17 +080053#include "util/block-info.h"
Adrian Hunter520a2eb2015-04-24 22:29:45 +030054
Namhyung Kimfc672972013-09-13 15:27:43 +090055#include <dlfcn.h>
Arnaldo Carvalho de Meloa43783a2017-04-18 10:46:11 -030056#include <errno.h>
Arnaldo Carvalho de Melofd20e812017-04-17 15:23:08 -030057#include <inttypes.h>
Arnaldo Carvalho de Melo1eae20c2017-04-18 12:33:30 -030058#include <regex.h>
Arnaldo Carvalho de Melo3052ba52019-06-25 17:27:31 -030059#include <linux/ctype.h>
Arnaldo Carvalho de Melo9607ad32017-04-19 15:49:18 -030060#include <signal.h>
Anton Blanchard5d67be92011-07-04 21:57:50 +100061#include <linux/bitmap.h>
Arnaldo Carvalho de Melo8520a982019-08-29 16:18:59 -030062#include <linux/string.h>
Arnaldo Carvalho de Melo531d2412016-03-23 15:16:55 -030063#include <linux/stringify.h>
Andi Kleen2a1292c2019-03-05 06:47:48 -080064#include <linux/time64.h>
Arnaldo Carvalho de Melo7a8ef4c2017-04-19 20:57:47 -030065#include <sys/types.h>
66#include <sys/stat.h>
67#include <unistd.h>
Arnaldo Carvalho de Melo6439d7d2018-01-09 15:25:03 -030068#include <linux/mman.h>
Anton Blanchard5d67be92011-07-04 21:57:50 +100069
Arnaldo Carvalho de Melo28b21392013-12-19 14:53:53 -030070struct report {
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -020071 struct perf_tool tool;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -020072 struct perf_session *session;
Arnaldo Carvalho de Meloef4b1a52019-08-15 18:18:58 -030073 struct evswitch evswitch;
Arnaldo Carvalho de Melo2059fc72015-11-12 16:50:13 -030074 bool use_tui, use_gtk, use_stdio;
Arnaldo Carvalho de Melofa372aa2011-11-17 12:19:04 -020075 bool show_full_info;
76 bool show_threads;
77 bool inverted_callchain;
Stephane Eranianf4f7e282013-01-24 16:10:36 +010078 bool mem_mode;
Jiri Olsaa4a4d0a2018-01-07 17:03:55 +010079 bool stats_mode;
Jiri Olsa930f8b32018-01-07 17:03:56 +010080 bool tasks_mode;
Arnaldo Carvalho de Melo6439d7d2018-01-09 15:25:03 -030081 bool mmaps_mode;
Jiri Olsa5cfe2c82013-12-09 11:02:49 +010082 bool header;
83 bool header_only;
Andi Kleen98df8582015-07-18 08:24:47 -070084 bool nonany_branch_mode;
Jiri Olsa57b5de42018-03-14 10:22:05 +010085 bool group_set;
Kan Liangb1d14292020-03-19 13:25:13 -070086 bool stitch_lbr;
Waiman Long91e95612013-10-18 10:38:48 -040087 int max_stack;
Arnaldo Carvalho de Melofa372aa2011-11-17 12:19:04 -020088 struct perf_read_values show_threads_values;
Arnaldo Carvalho de Melo1eddd9e2018-05-28 11:42:59 -030089 struct annotation_options annotation_opts;
Arnaldo Carvalho de Melofa372aa2011-11-17 12:19:04 -020090 const char *pretty_printing_style;
Arnaldo Carvalho de Melofa372aa2011-11-17 12:19:04 -020091 const char *cpu_list;
Namhyung Kimb14ffac2012-03-16 17:50:54 +090092 const char *symbol_filter_str;
David Ahern46690a82016-11-29 10:15:46 -070093 const char *time_str;
Jin Yao0a3cc3a2018-01-10 23:00:32 +080094 struct perf_time_interval *ptime_range;
95 int range_size;
Jin Yao5b969bc2017-12-08 21:13:45 +080096 int range_num;
Namhyung Kim064f1982013-05-14 11:09:04 +090097 float min_percent;
Namhyung Kim58c311d2014-04-22 09:47:25 +090098 u64 nr_entries;
Jiri Olsa94786b62014-06-05 11:00:20 +020099 u64 queue_size;
Jin Yao6f7164f2019-11-07 15:47:17 +0800100 u64 total_cycles;
Kan Liang21394d92015-09-04 10:45:44 -0400101 int socket_filter;
Arnaldo Carvalho de Melofa372aa2011-11-17 12:19:04 -0200102 DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
Jin Yao2d78b182017-07-18 20:13:14 +0800103 struct branch_type_stat brtype_stat;
Jin Yaoec6ae742018-11-30 21:54:56 +0800104 bool symbol_ipc;
Jin Yao6f7164f2019-11-07 15:47:17 +0800105 bool total_cycles_mode;
106 struct block_report *block_reports;
Jin Yaocca0cc72020-02-02 22:16:54 +0800107 int nr_block_reports;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200108};
Anton Blanchard5d67be92011-07-04 21:57:50 +1000109
Arnaldo Carvalho de Melo28b21392013-12-19 14:53:53 -0300110static int report__config(const char *var, const char *value, void *cb)
Namhyung Kim00c7e1f2013-01-22 18:09:46 +0900111{
Jiri Olsa94786b62014-06-05 11:00:20 +0200112 struct report *rep = cb;
113
Namhyung Kim00c7e1f2013-01-22 18:09:46 +0900114 if (!strcmp(var, "report.group")) {
115 symbol_conf.event_group = perf_config_bool(var, value);
116 return 0;
117 }
Namhyung Kimeec574e2013-05-14 11:09:06 +0900118 if (!strcmp(var, "report.percent-limit")) {
Namhyung Kim2665b452016-01-28 00:40:50 +0900119 double pcnt = strtof(value, NULL);
120
121 rep->min_percent = pcnt;
122 callchain_param.min_percent = pcnt;
Namhyung Kimeec574e2013-05-14 11:09:06 +0900123 return 0;
124 }
Namhyung Kim8d8e6452013-01-22 18:09:46 +0900125 if (!strcmp(var, "report.children")) {
126 symbol_conf.cumulate_callchain = perf_config_bool(var, value);
127 return 0;
128 }
Arnaldo Carvalho de Melo25ce4bb2017-06-27 11:44:58 -0300129 if (!strcmp(var, "report.queue-size"))
130 return perf_config_u64(&rep->queue_size, var, value);
131
Arnaldo Carvalho de Melofa1f4562016-08-12 20:41:01 -0300132 if (!strcmp(var, "report.sort_order")) {
133 default_sort_order = strdup(value);
134 return 0;
135 }
Namhyung Kim00c7e1f2013-01-22 18:09:46 +0900136
Wang Nanb8cbb342016-02-26 09:31:51 +0000137 return 0;
Namhyung Kim00c7e1f2013-01-22 18:09:46 +0900138}
139
Namhyung Kim9d3c02d2014-01-07 17:02:25 +0900140static int hist_iter__report_callback(struct hist_entry_iter *iter,
141 struct addr_location *al, bool single,
142 void *arg)
143{
144 int err = 0;
145 struct report *rep = arg;
146 struct hist_entry *he = iter->he;
Jiri Olsa32dcd022019-07-21 13:23:51 +0200147 struct evsel *evsel = iter->evsel;
Taeung Songbab89f62017-07-20 16:28:53 -0300148 struct perf_sample *sample = iter->sample;
Namhyung Kim9d3c02d2014-01-07 17:02:25 +0900149 struct mem_info *mi;
150 struct branch_info *bi;
151
Jin Yaoec6ae742018-11-30 21:54:56 +0800152 if (!ui__has_annotation() && !rep->symbol_ipc)
Namhyung Kim9d3c02d2014-01-07 17:02:25 +0900153 return 0;
154
155 if (sort__mode == SORT_MODE__BRANCH) {
156 bi = he->branch_info;
Arnaldo Carvalho de Meloe345f3b2018-05-24 12:05:39 -0300157 err = addr_map_symbol__inc_samples(&bi->from, sample, evsel);
Namhyung Kim9d3c02d2014-01-07 17:02:25 +0900158 if (err)
159 goto out;
160
Arnaldo Carvalho de Meloe345f3b2018-05-24 12:05:39 -0300161 err = addr_map_symbol__inc_samples(&bi->to, sample, evsel);
Namhyung Kim9d3c02d2014-01-07 17:02:25 +0900162
163 } else if (rep->mem_mode) {
164 mi = he->mem_info;
Arnaldo Carvalho de Meloe345f3b2018-05-24 12:05:39 -0300165 err = addr_map_symbol__inc_samples(&mi->daddr, sample, evsel);
Namhyung Kim9d3c02d2014-01-07 17:02:25 +0900166 if (err)
167 goto out;
168
Arnaldo Carvalho de Meloe345f3b2018-05-24 12:05:39 -0300169 err = hist_entry__inc_addr_samples(he, sample, evsel, al->addr);
Namhyung Kim9d3c02d2014-01-07 17:02:25 +0900170
171 } else if (symbol_conf.cumulate_callchain) {
172 if (single)
Arnaldo Carvalho de Meloe345f3b2018-05-24 12:05:39 -0300173 err = hist_entry__inc_addr_samples(he, sample, evsel, al->addr);
Namhyung Kim9d3c02d2014-01-07 17:02:25 +0900174 } else {
Arnaldo Carvalho de Meloe345f3b2018-05-24 12:05:39 -0300175 err = hist_entry__inc_addr_samples(he, sample, evsel, al->addr);
Namhyung Kim9d3c02d2014-01-07 17:02:25 +0900176 }
177
178out:
179 return err;
Namhyung Kim58c311d2014-04-22 09:47:25 +0900180}
181
Jin Yao2d78b182017-07-18 20:13:14 +0800182static int hist_iter__branch_callback(struct hist_entry_iter *iter,
183 struct addr_location *al __maybe_unused,
184 bool single __maybe_unused,
185 void *arg)
186{
187 struct hist_entry *he = iter->he;
188 struct report *rep = arg;
Jin Yaoc3b106492020-03-13 21:46:07 +0800189 struct branch_info *bi = he->branch_info;
Jin Yao40c39e32017-12-26 18:42:43 +0800190 struct perf_sample *sample = iter->sample;
Jiri Olsa32dcd022019-07-21 13:23:51 +0200191 struct evsel *evsel = iter->evsel;
Jin Yao40c39e32017-12-26 18:42:43 +0800192 int err;
193
Jin Yaoc3b106492020-03-13 21:46:07 +0800194 branch_type_count(&rep->brtype_stat, &bi->flags,
195 bi->from.addr, bi->to.addr);
196
Jin Yaoec6ae742018-11-30 21:54:56 +0800197 if (!ui__has_annotation() && !rep->symbol_ipc)
Jin Yao40c39e32017-12-26 18:42:43 +0800198 return 0;
199
Arnaldo Carvalho de Meloe345f3b2018-05-24 12:05:39 -0300200 err = addr_map_symbol__inc_samples(&bi->from, sample, evsel);
Jin Yao40c39e32017-12-26 18:42:43 +0800201 if (err)
202 goto out;
203
Arnaldo Carvalho de Meloe345f3b2018-05-24 12:05:39 -0300204 err = addr_map_symbol__inc_samples(&bi->to, sample, evsel);
Jin Yao40c39e32017-12-26 18:42:43 +0800205
Jin Yao40c39e32017-12-26 18:42:43 +0800206out:
207 return err;
Jin Yao2d78b182017-07-18 20:13:14 +0800208}
209
Jiri Olsa57b5de42018-03-14 10:22:05 +0100210static void setup_forced_leader(struct report *report,
Jiri Olsa63503db2019-07-21 13:23:52 +0200211 struct evlist *evlist)
Jiri Olsa57b5de42018-03-14 10:22:05 +0100212{
Jin Yaoa26bb0b2018-05-21 22:57:45 +0800213 if (report->group_set)
214 perf_evlist__force_leader(evlist);
Jiri Olsa57b5de42018-03-14 10:22:05 +0100215}
216
Jiri Olsa89f16882018-09-13 14:54:03 +0200217static int process_feature_event(struct perf_session *session,
218 union perf_event *event)
Jiri Olsa57b5de42018-03-14 10:22:05 +0100219{
Jiri Olsa89f16882018-09-13 14:54:03 +0200220 struct report *rep = container_of(session->tool, struct report, tool);
Jiri Olsa57b5de42018-03-14 10:22:05 +0100221
222 if (event->feat.feat_id < HEADER_LAST_FEATURE)
Jiri Olsa89f16882018-09-13 14:54:03 +0200223 return perf_event__process_feature(session, event);
Jiri Olsa57b5de42018-03-14 10:22:05 +0100224
225 if (event->feat.feat_id != HEADER_LAST_FEATURE) {
Jiri Olsa1b8896f2019-08-28 15:57:13 +0200226 pr_err("failed: wrong feature ID: %" PRI_lu64 "\n",
Jiri Olsa57b5de42018-03-14 10:22:05 +0100227 event->feat.feat_id);
228 return -1;
229 }
230
231 /*
Ravi Bangoria92ead7e2018-06-25 18:12:20 +0530232 * (feat_id = HEADER_LAST_FEATURE) is the end marker which
233 * means all features are received, now we can force the
Jiri Olsa57b5de42018-03-14 10:22:05 +0100234 * group if needed.
235 */
236 setup_forced_leader(rep, session->evlist);
237 return 0;
238}
239
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200240static int process_sample_event(struct perf_tool *tool,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200241 union perf_event *event,
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -0200242 struct perf_sample *sample,
Jiri Olsa32dcd022019-07-21 13:23:51 +0200243 struct evsel *evsel,
Arnaldo Carvalho de Melo743eb8682011-11-28 07:56:39 -0200244 struct machine *machine)
Ingo Molnar75051722009-06-03 23:14:49 +0200245{
Arnaldo Carvalho de Melo28b21392013-12-19 14:53:53 -0300246 struct report *rep = container_of(tool, struct report, tool);
Arnaldo Carvalho de Melo1ed091c2009-11-27 16:29:23 -0200247 struct addr_location al;
Namhyung Kim69bcb012013-10-30 09:40:34 +0900248 struct hist_entry_iter iter = {
Namhyung Kim063bd932015-05-19 17:04:10 +0900249 .evsel = evsel,
250 .sample = sample,
Namhyung Kimb49a8fe2015-11-26 16:08:20 +0900251 .hide_unresolved = symbol_conf.hide_unresolved,
Namhyung Kim063bd932015-05-19 17:04:10 +0900252 .add_entry_cb = hist_iter__report_callback,
Namhyung Kim69bcb012013-10-30 09:40:34 +0900253 };
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -0300254 int ret = 0;
OGAWA Hirofumi180f95e2009-12-06 20:08:24 +0900255
Jin Yao5b969bc2017-12-08 21:13:45 +0800256 if (perf_time__ranges_skip_sample(rep->ptime_range, rep->range_num,
257 sample->time)) {
David Ahern46690a82016-11-29 10:15:46 -0700258 return 0;
Jin Yao5b969bc2017-12-08 21:13:45 +0800259 }
David Ahern46690a82016-11-29 10:15:46 -0700260
Arnaldo Carvalho de Meloef4b1a52019-08-15 18:18:58 -0300261 if (evswitch__discard(&rep->evswitch, evsel))
262 return 0;
263
Arnaldo Carvalho de Melobb3eb562016-03-22 18:39:09 -0300264 if (machine__resolve(machine, &al, sample) < 0) {
Namhyung Kima4210142013-12-20 14:11:12 +0900265 pr_debug("problem processing %d event, skipping it.\n",
266 event->header.type);
Ingo Molnar75051722009-06-03 23:14:49 +0200267 return -1;
268 }
269
Kan Liangb1d14292020-03-19 13:25:13 -0700270 if (rep->stitch_lbr)
271 al.thread->lbr_stitch_enable = true;
272
Namhyung Kimb49a8fe2015-11-26 16:08:20 +0900273 if (symbol_conf.hide_unresolved && al.sym == NULL)
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -0300274 goto out_put;
Arnaldo Carvalho de Melo7bec7a92009-06-30 19:01:22 -0300275
Arnaldo Carvalho de Melofa372aa2011-11-17 12:19:04 -0200276 if (rep->cpu_list && !test_bit(sample->cpu, rep->cpu_bitmap))
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -0300277 goto out_put;
Anton Blanchard5d67be92011-07-04 21:57:50 +1000278
Adrian Hunterf86225d2015-09-25 16:15:42 +0300279 if (sort__mode == SORT_MODE__BRANCH) {
280 /*
281 * A non-synthesized event might not have a branch stack if
282 * branch stacks have been synthesized (using itrace options).
283 */
284 if (!sample->branch_stack)
285 goto out_put;
Jin Yao2d78b182017-07-18 20:13:14 +0800286
287 iter.add_entry_cb = hist_iter__branch_callback;
Namhyung Kim69bcb012013-10-30 09:40:34 +0900288 iter.ops = &hist_iter_branch;
Adrian Hunterf86225d2015-09-25 16:15:42 +0300289 } else if (rep->mem_mode) {
Namhyung Kim69bcb012013-10-30 09:40:34 +0900290 iter.ops = &hist_iter_mem;
Adrian Hunterf86225d2015-09-25 16:15:42 +0300291 } else if (symbol_conf.cumulate_callchain) {
Namhyung Kim7a13aa22012-09-11 14:13:04 +0900292 iter.ops = &hist_iter_cumulative;
Adrian Hunterf86225d2015-09-25 16:15:42 +0300293 } else {
Namhyung Kim69bcb012013-10-30 09:40:34 +0900294 iter.ops = &hist_iter_normal;
Adrian Hunterf86225d2015-09-25 16:15:42 +0300295 }
Arnaldo Carvalho de Meloec80fde2011-05-26 09:53:51 -0300296
Namhyung Kim69bcb012013-10-30 09:40:34 +0900297 if (al.map != NULL)
298 al.map->dso->hit = 1;
299
Jin Yao6f7164f2019-11-07 15:47:17 +0800300 if (ui__has_annotation() || rep->symbol_ipc || rep->total_cycles_mode) {
Jin Yaobdd16662019-03-16 05:16:17 +0800301 hist__account_cycles(sample->branch_stack, &al, sample,
Jin Yao6f7164f2019-11-07 15:47:17 +0800302 rep->nonany_branch_mode,
303 &rep->total_cycles);
Jin Yaobdd16662019-03-16 05:16:17 +0800304 }
305
Namhyung Kim063bd932015-05-19 17:04:10 +0900306 ret = hist_entry_iter__add(&iter, &al, rep->max_stack, rep);
Namhyung Kim69bcb012013-10-30 09:40:34 +0900307 if (ret < 0)
308 pr_debug("problem adding hist entry, skipping event\n");
Arnaldo Carvalho de Melob91fc392015-04-06 20:43:22 -0300309out_put:
310 addr_location__put(&al);
Namhyung Kim27a0dcb2013-05-14 11:09:02 +0900311 return ret;
Ingo Molnar75051722009-06-03 23:14:49 +0200312}
313
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -0200314static int process_read_event(struct perf_tool *tool,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200315 union perf_event *event,
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300316 struct perf_sample *sample __maybe_unused,
Jiri Olsa32dcd022019-07-21 13:23:51 +0200317 struct evsel *evsel,
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300318 struct machine *machine __maybe_unused)
Peter Zijlstrae9ea2fd2009-06-24 22:46:04 +0200319{
Arnaldo Carvalho de Melo28b21392013-12-19 14:53:53 -0300320 struct report *rep = container_of(tool, struct report, tool);
Arnaldo Carvalho de Melo743eb8682011-11-28 07:56:39 -0200321
Arnaldo Carvalho de Melofa372aa2011-11-17 12:19:04 -0200322 if (rep->show_threads) {
Arnaldo Carvalho de Melo8ab2e962020-04-29 16:07:09 -0300323 const char *name = evsel__name(evsel);
Arnaldo Carvalho de Melo89973502016-10-14 18:23:11 -0300324 int err = perf_read_values_add_value(&rep->show_threads_values,
Brice Goglin8d513272009-08-07 13:55:24 +0200325 event->read.pid, event->read.tid,
Jiri Olsa99331832017-08-24 18:27:36 +0200326 evsel->idx,
Brice Goglin8d513272009-08-07 13:55:24 +0200327 name,
328 event->read.value);
Arnaldo Carvalho de Melo89973502016-10-14 18:23:11 -0300329
330 if (err)
331 return err;
Brice Goglin8d513272009-08-07 13:55:24 +0200332 }
333
Peter Zijlstrae9ea2fd2009-06-24 22:46:04 +0200334 return 0;
335}
336
David Ahern300aa942012-06-11 13:48:41 -0600337/* For pipe mode, sample_type is not currently set */
Arnaldo Carvalho de Melo28b21392013-12-19 14:53:53 -0300338static int report__setup_sample_type(struct report *rep)
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300339{
Arnaldo Carvalho de Meloc824c432013-10-22 19:01:31 -0300340 struct perf_session *session = rep->session;
341 u64 sample_type = perf_evlist__combined_sample_type(session->evlist);
Jiri Olsa8ceb41d2017-01-23 22:07:59 +0100342 bool is_pipe = perf_data__is_pipe(session->data);
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200343
Adrian Hunterd062ac12015-09-25 16:15:33 +0300344 if (session->itrace_synth_opts->callchain ||
Adrian Hunter1c5c25b2020-04-01 13:16:05 +0300345 session->itrace_synth_opts->add_callchain ||
Adrian Hunterd062ac12015-09-25 16:15:33 +0300346 (!is_pipe &&
347 perf_header__has_feat(&session->header, HEADER_AUXTRACE) &&
348 !session->itrace_synth_opts->set))
349 sample_type |= PERF_SAMPLE_CALLCHAIN;
350
Adrian Hunterec90e422020-04-29 18:07:46 +0300351 if (session->itrace_synth_opts->last_branch ||
352 session->itrace_synth_opts->add_last_branch)
Adrian Hunterc7eced62015-09-25 16:15:40 +0300353 sample_type |= PERF_SAMPLE_BRANCH_STACK;
354
Jiri Olsacc9784bd2013-10-15 16:27:34 +0200355 if (!is_pipe && !(sample_type & PERF_SAMPLE_CALLCHAIN)) {
Jiri Olsade7e6a72016-05-03 13:54:43 +0200356 if (perf_hpp_list.parent) {
Namhyung Kim3780f482012-05-29 13:22:57 +0900357 ui__error("Selected --sort parent, but no "
Arnaldo Carvalho de Melo00894ce2011-08-03 12:33:24 -0300358 "callchain data. Did you call "
359 "'perf record' without -g?\n");
Arnaldo Carvalho de Melod549c7692009-12-27 21:37:02 -0200360 return -EINVAL;
Frederic Weisbecker016e92f2009-10-07 12:47:31 +0200361 }
Jin Yaob49a8212017-05-08 18:43:02 +0800362 if (symbol_conf.use_callchain &&
363 !symbol_conf.show_branchflag_count) {
364 ui__error("Selected -g or --branch-history.\n"
365 "But no callchain or branch data.\n"
366 "Did you call 'perf record' without -g or -b?\n");
Frederic Weisbecker016e92f2009-10-07 12:47:31 +0200367 return -1;
368 }
Arnaldo Carvalho de Melo1cc83812016-04-18 11:54:31 -0300369 } else if (!callchain_param.enabled &&
Arnaldo Carvalho de Melofa372aa2011-11-17 12:19:04 -0200370 callchain_param.mode != CHAIN_NONE &&
Arnaldo Carvalho de Melob9a63b92010-01-05 11:54:45 -0200371 !symbol_conf.use_callchain) {
Arnaldo Carvalho de Melod599db32009-12-15 20:04:42 -0200372 symbol_conf.use_callchain = true;
Frederic Weisbecker16537f12011-01-14 04:52:00 +0100373 if (callchain_register_param(&callchain_param) < 0) {
Namhyung Kim3780f482012-05-29 13:22:57 +0900374 ui__error("Can't register callchain params.\n");
Arnaldo Carvalho de Melod549c7692009-12-27 21:37:02 -0200375 return -EINVAL;
Frederic Weisbecker016e92f2009-10-07 12:47:31 +0200376 }
Ingo Molnard80d3382009-06-03 23:14:49 +0200377 }
378
Namhyung Kim793aaaa2013-10-30 17:05:55 +0900379 if (symbol_conf.cumulate_callchain) {
380 /* Silently ignore if callchain is missing */
381 if (!(sample_type & PERF_SAMPLE_CALLCHAIN)) {
382 symbol_conf.cumulate_callchain = false;
383 perf_hpp__cancel_cumulate();
384 }
385 }
386
Namhyung Kim55369fc2013-04-01 20:35:20 +0900387 if (sort__mode == SORT_MODE__BRANCH) {
Jiri Olsacc9784bd2013-10-15 16:27:34 +0200388 if (!is_pipe &&
Arnaldo Carvalho de Melo7f3be652012-08-01 19:15:52 -0300389 !(sample_type & PERF_SAMPLE_BRANCH_STACK)) {
Namhyung Kim3780f482012-05-29 13:22:57 +0900390 ui__error("Selected -b but no branch data. "
391 "Did you call perf record without -b?\n");
Roberto Agostino Vitillob50311d2012-02-09 23:21:03 +0100392 return -1;
393 }
394 }
395
Ravi Bangoriabb30aca2019-11-14 18:52:13 +0530396 if (sort__mode == SORT_MODE__MEMORY) {
397 if (!is_pipe && !(sample_type & PERF_SAMPLE_DATA_SRC)) {
398 ui__error("Selected --mem-mode but no mem data. "
399 "Did you call perf record without -d?\n");
400 return -1;
401 }
402 }
403
Jiri Olsa0d71a2b2020-05-07 11:50:23 +0200404 callchain_param_setup(sample_type);
Andi Kleen98df8582015-07-18 08:24:47 -0700405
Kan Liangb1d14292020-03-19 13:25:13 -0700406 if (rep->stitch_lbr && (callchain_param.record_mode != CALLCHAIN_LBR)) {
407 ui__warning("Can't find LBR callchain. Switch off --stitch-lbr.\n"
408 "Please apply --call-graph lbr when recording.\n");
409 rep->stitch_lbr = false;
410 }
411
Andi Kleen98df8582015-07-18 08:24:47 -0700412 /* ??? handle more cases than just ANY? */
413 if (!(perf_evlist__combined_branch_type(session->evlist) &
414 PERF_SAMPLE_BRANCH_ANY))
415 rep->nonany_branch_mode = true;
416
Jin Yaoc3314a72020-01-08 03:17:45 +0800417#if !defined(HAVE_LIBUNWIND_SUPPORT) && !defined(HAVE_DWARF_SUPPORT)
Jin Yao800d3f52019-10-11 10:21:22 +0800418 if (dwarf_callchain_users) {
Jin Yaoc3314a72020-01-08 03:17:45 +0800419 ui__warning("Please install libunwind or libdw "
420 "development packages during the perf build.\n");
Jin Yao800d3f52019-10-11 10:21:22 +0800421 }
422#endif
423
Ingo Molnard80d3382009-06-03 23:14:49 +0200424 return 0;
425}
426
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300427static void sig_handler(int sig __maybe_unused)
Tom Zanussi46656ac2010-04-01 23:59:17 -0500428{
429 session_done = 1;
430}
431
Arnaldo Carvalho de Melo28b21392013-12-19 14:53:53 -0300432static size_t hists__fprintf_nr_sample_events(struct hists *hists, struct report *rep,
Arnaldo Carvalho de Meloc82ee822010-05-14 14:19:35 -0300433 const char *evname, FILE *fp)
434{
435 size_t ret;
436 char unit;
Arnaldo Carvalho de Meloc824c432013-10-22 19:01:31 -0300437 unsigned long nr_samples = hists->stats.nr_events[PERF_RECORD_SAMPLE];
438 u64 nr_events = hists->stats.total_period;
Jiri Olsa32dcd022019-07-21 13:23:51 +0200439 struct evsel *evsel = hists_to_evsel(hists);
Namhyung Kim717e2632013-01-22 18:09:44 +0900440 char buf[512];
441 size_t size = sizeof(buf);
Kan Liang84734b02015-09-04 10:45:45 -0400442 int socked_id = hists->socket_filter;
Namhyung Kim717e2632013-01-22 18:09:44 +0900443
Namhyung Kim27fafab2017-02-17 17:17:39 +0900444 if (quiet)
445 return 0;
446
Namhyung Kimf2148332014-01-14 11:52:48 +0900447 if (symbol_conf.filter_relative) {
448 nr_samples = hists->stats.nr_non_filtered_samples;
449 nr_events = hists->stats.total_non_filtered_period;
450 }
451
Arnaldo Carvalho de Meloc754c382020-04-30 10:51:16 -0300452 if (evsel__is_group_event(evsel)) {
Jiri Olsa32dcd022019-07-21 13:23:51 +0200453 struct evsel *pos;
Namhyung Kim717e2632013-01-22 18:09:44 +0900454
Arnaldo Carvalho de Melo347c7512020-04-29 16:09:12 -0300455 evsel__group_desc(evsel, buf, size);
Namhyung Kim717e2632013-01-22 18:09:44 +0900456 evname = buf;
457
458 for_each_group_member(pos, evsel) {
Arnaldo Carvalho de Melo4ea062ed2014-10-09 13:13:41 -0300459 const struct hists *pos_hists = evsel__hists(pos);
460
Namhyung Kimf2148332014-01-14 11:52:48 +0900461 if (symbol_conf.filter_relative) {
Arnaldo Carvalho de Melo4ea062ed2014-10-09 13:13:41 -0300462 nr_samples += pos_hists->stats.nr_non_filtered_samples;
463 nr_events += pos_hists->stats.total_non_filtered_period;
Namhyung Kimf2148332014-01-14 11:52:48 +0900464 } else {
Arnaldo Carvalho de Melo4ea062ed2014-10-09 13:13:41 -0300465 nr_samples += pos_hists->stats.nr_events[PERF_RECORD_SAMPLE];
466 nr_events += pos_hists->stats.total_period;
Namhyung Kimf2148332014-01-14 11:52:48 +0900467 }
Namhyung Kim717e2632013-01-22 18:09:44 +0900468 }
469 }
Arnaldo Carvalho de Meloc82ee822010-05-14 14:19:35 -0300470
Ashay Ranecc6862802012-04-05 21:01:01 -0500471 nr_samples = convert_unit(nr_samples, &unit);
472 ret = fprintf(fp, "# Samples: %lu%c", nr_samples, unit);
Jiri Olsa8ef278b2018-03-07 16:50:02 +0100473 if (evname != NULL) {
474 ret += fprintf(fp, " of event%s '%s'",
Jiri Olsa5643b1a2019-07-21 13:24:46 +0200475 evsel->core.nr_members > 1 ? "s" : "", evname);
Jiri Olsa8ef278b2018-03-07 16:50:02 +0100476 }
Ashay Ranecc6862802012-04-05 21:01:01 -0500477
Jin Yao74256642018-01-10 23:00:30 +0800478 if (rep->time_str)
479 ret += fprintf(fp, " (time slices: %s)", rep->time_str);
480
Kan Liang9e207dd2015-08-11 06:30:49 -0400481 if (symbol_conf.show_ref_callgraph &&
482 strstr(evname, "call-graph=no")) {
483 ret += fprintf(fp, ", show reference callgraph");
484 }
485
Stephane Eranianf4f7e282013-01-24 16:10:36 +0100486 if (rep->mem_mode) {
487 ret += fprintf(fp, "\n# Total weight : %" PRIu64, nr_events);
Yunlong Song228f14f2015-03-23 11:50:05 +0800488 ret += fprintf(fp, "\n# Sort order : %s", sort_order ? : default_mem_sort_order);
Stephane Eranianf4f7e282013-01-24 16:10:36 +0100489 } else
490 ret += fprintf(fp, "\n# Event count (approx.): %" PRIu64, nr_events);
Kan Liang21394d92015-09-04 10:45:44 -0400491
Kan Liang84734b02015-09-04 10:45:45 -0400492 if (socked_id > -1)
493 ret += fprintf(fp, "\n# Processor Socket: %d", socked_id);
Kan Liang21394d92015-09-04 10:45:44 -0400494
Arnaldo Carvalho de Meloc82ee822010-05-14 14:19:35 -0300495 return ret + fprintf(fp, "\n#\n");
496}
497
Jin Yao7fa46cb2019-11-07 15:47:19 +0800498static int perf_evlist__tui_block_hists_browse(struct evlist *evlist,
499 struct report *rep)
500{
501 struct evsel *pos;
502 int i = 0, ret;
503
504 evlist__for_each_entry(evlist, pos) {
505 ret = report__browse_block_hists(&rep->block_reports[i++].hist,
Jin Yao848a5e52019-11-18 22:08:49 +0800506 rep->min_percent, pos,
507 &rep->session->header.env,
508 &rep->annotation_opts);
Jin Yao7fa46cb2019-11-07 15:47:19 +0800509 if (ret != 0)
510 return ret;
511 }
512
513 return 0;
514}
515
Jiri Olsa63503db2019-07-21 13:23:52 +0200516static int perf_evlist__tty_browse_hists(struct evlist *evlist,
Arnaldo Carvalho de Melo28b21392013-12-19 14:53:53 -0300517 struct report *rep,
Arnaldo Carvalho de Melo7f0030b2011-03-06 13:07:30 -0300518 const char *help)
Arnaldo Carvalho de Melod67f0882010-05-23 22:36:51 -0300519{
Jiri Olsa32dcd022019-07-21 13:23:51 +0200520 struct evsel *pos;
Jin Yao6f7164f2019-11-07 15:47:17 +0800521 int i = 0;
Arnaldo Carvalho de Melod67f0882010-05-23 22:36:51 -0300522
Namhyung Kim27fafab2017-02-17 17:17:39 +0900523 if (!quiet) {
524 fprintf(stdout, "#\n# Total Lost Samples: %" PRIu64 "\n#\n",
525 evlist->stats.total_lost_samples);
526 }
527
Arnaldo Carvalho de Meloe5cadb92016-06-23 11:26:15 -0300528 evlist__for_each_entry(evlist, pos) {
Arnaldo Carvalho de Melo4ea062ed2014-10-09 13:13:41 -0300529 struct hists *hists = evsel__hists(pos);
Arnaldo Carvalho de Melo8ab2e962020-04-29 16:07:09 -0300530 const char *evname = evsel__name(pos);
Arnaldo Carvalho de Melod67f0882010-05-23 22:36:51 -0300531
Arnaldo Carvalho de Meloc754c382020-04-30 10:51:16 -0300532 if (symbol_conf.event_group && !evsel__is_group_leader(pos))
Namhyung Kimfc24d7c2013-01-22 18:09:43 +0900533 continue;
534
Arnaldo Carvalho de Melo28b21392013-12-19 14:53:53 -0300535 hists__fprintf_nr_sample_events(hists, rep, evname, stdout);
Jin Yao6f7164f2019-11-07 15:47:17 +0800536
537 if (rep->total_cycles_mode) {
538 report__browse_block_hists(&rep->block_reports[i++].hist,
Jin Yao848a5e52019-11-18 22:08:49 +0800539 rep->min_percent, pos,
540 NULL, NULL);
Jin Yao6f7164f2019-11-07 15:47:17 +0800541 continue;
542 }
543
Namhyung Kim27fafab2017-02-17 17:17:39 +0900544 hists__fprintf(hists, !quiet, 0, 0, rep->min_percent, stdout,
Arnaldo Carvalho de Meloe9de7e22018-06-20 15:58:20 -0300545 !(symbol_conf.use_callchain ||
546 symbol_conf.show_branchflag_count));
Arnaldo Carvalho de Melod67f0882010-05-23 22:36:51 -0300547 fprintf(stdout, "\n\n");
Arnaldo Carvalho de Melod67f0882010-05-23 22:36:51 -0300548 }
549
Namhyung Kim8b53dbe2017-03-08 00:08:29 +0900550 if (!quiet)
Arnaldo Carvalho de Melod67f0882010-05-23 22:36:51 -0300551 fprintf(stdout, "#\n# (%s)\n#\n", help);
552
Namhyung Kim021162c2015-05-11 22:44:39 +0900553 if (rep->show_threads) {
554 bool style = !strcmp(rep->pretty_printing_style, "raw");
555 perf_read_values_display(stdout, &rep->show_threads_values,
556 style);
557 perf_read_values_destroy(&rep->show_threads_values);
Arnaldo Carvalho de Melod67f0882010-05-23 22:36:51 -0300558 }
559
Jin Yao2d78b182017-07-18 20:13:14 +0800560 if (sort__mode == SORT_MODE__BRANCH)
561 branch_type_stat_display(stdout, &rep->brtype_stat);
562
Arnaldo Carvalho de Melod67f0882010-05-23 22:36:51 -0300563 return 0;
564}
565
Arnaldo Carvalho de Melofad29182014-01-08 10:10:00 -0300566static void report__warn_kptr_restrict(const struct report *rep)
567{
Arnaldo Carvalho de Meloa5e813c2015-09-30 11:54:04 -0300568 struct map *kernel_map = machine__kernel_map(&rep->session->machines.host);
Wang Nanf6fcc142015-04-08 10:59:32 +0000569 struct kmap *kernel_kmap = kernel_map ? map__kmap(kernel_map) : NULL;
Arnaldo Carvalho de Melofad29182014-01-08 10:10:00 -0300570
Arnaldo Carvalho de Melo9c39ed92017-11-14 11:12:11 -0300571 if (perf_evlist__exclude_kernel(rep->session->evlist))
572 return;
573
Arnaldo Carvalho de Melofad29182014-01-08 10:10:00 -0300574 if (kernel_map == NULL ||
575 (kernel_map->dso->hit &&
576 (kernel_kmap->ref_reloc_sym == NULL ||
577 kernel_kmap->ref_reloc_sym->addr == 0))) {
578 const char *desc =
579 "As no suitable kallsyms nor vmlinux was found, kernel samples\n"
580 "can't be resolved.";
581
Arnaldo Carvalho de Meloe94b8612018-04-23 17:13:49 -0300582 if (kernel_map && map__has_symbols(kernel_map)) {
583 desc = "If some relocation was applied (e.g. "
584 "kexec) symbols may be misresolved.";
Arnaldo Carvalho de Melofad29182014-01-08 10:10:00 -0300585 }
586
587 ui__warning(
588"Kernel address maps (/proc/{kallsyms,modules}) were restricted.\n\n"
589"Check /proc/sys/kernel/kptr_restrict before running 'perf record'.\n\n%s\n\n"
590"Samples in kernel modules can't be resolved as well.\n\n",
591 desc);
592 }
593}
594
Arnaldo Carvalho de Melo83629512014-01-08 12:22:07 -0300595static int report__gtk_browse_hists(struct report *rep, const char *help)
596{
Jiri Olsa63503db2019-07-21 13:23:52 +0200597 int (*hist_browser)(struct evlist *evlist, const char *help,
Arnaldo Carvalho de Melo83629512014-01-08 12:22:07 -0300598 struct hist_browser_timer *timer, float min_pcnt);
599
600 hist_browser = dlsym(perf_gtk_handle, "perf_evlist__gtk_browse_hists");
601
602 if (hist_browser == NULL) {
603 ui__error("GTK browser not found!\n");
604 return -1;
605 }
606
607 return hist_browser(rep->session->evlist, help, NULL, rep->min_percent);
608}
609
610static int report__browse_hists(struct report *rep)
611{
612 int ret;
613 struct perf_session *session = rep->session;
Jiri Olsa63503db2019-07-21 13:23:52 +0200614 struct evlist *evlist = session->evlist;
Namhyung Kim34b7b0f2016-01-09 19:16:29 +0900615 const char *help = perf_tip(system_path(TIPDIR));
616
617 if (help == NULL) {
618 /* fallback for people who don't install perf ;-) */
619 help = perf_tip(DOCDIR);
620 if (help == NULL)
621 help = "Cannot load tips.txt file, please install perf!";
622 }
Arnaldo Carvalho de Melo83629512014-01-08 12:22:07 -0300623
624 switch (use_browser) {
625 case 1:
Jin Yao7fa46cb2019-11-07 15:47:19 +0800626 if (rep->total_cycles_mode) {
627 ret = perf_evlist__tui_block_hists_browse(evlist, rep);
628 break;
629 }
630
Arnaldo Carvalho de Melo83629512014-01-08 12:22:07 -0300631 ret = perf_evlist__tui_browse_hists(evlist, help, NULL,
632 rep->min_percent,
Kan Liang06cc1a42018-01-18 13:26:29 -0800633 &session->header.env,
Arnaldo Carvalho de Melocd0cccb2018-05-28 13:54:59 -0300634 true, &rep->annotation_opts);
Arnaldo Carvalho de Melo83629512014-01-08 12:22:07 -0300635 /*
636 * Usually "ret" is the last pressed key, and we only
637 * care if the key notifies us to switch data file.
638 */
Jin Yao5e3b8102020-02-20 09:36:15 +0800639 if (ret != K_SWITCH_INPUT_DATA && ret != K_RELOAD)
Arnaldo Carvalho de Melo83629512014-01-08 12:22:07 -0300640 ret = 0;
641 break;
642 case 2:
643 ret = report__gtk_browse_hists(rep, help);
644 break;
645 default:
646 ret = perf_evlist__tty_browse_hists(evlist, rep, help);
647 break;
648 }
649
650 return ret;
651}
652
Namhyung Kim5b2ea6f2016-02-16 23:08:26 +0900653static int report__collapse_hists(struct report *rep)
Arnaldo Carvalho de Melof6d8b052014-01-08 14:45:24 -0300654{
655 struct ui_progress prog;
Jiri Olsa32dcd022019-07-21 13:23:51 +0200656 struct evsel *pos;
Namhyung Kim5b2ea6f2016-02-16 23:08:26 +0900657 int ret = 0;
Arnaldo Carvalho de Melof6d8b052014-01-08 14:45:24 -0300658
Namhyung Kim58c311d2014-04-22 09:47:25 +0900659 ui_progress__init(&prog, rep->nr_entries, "Merging related events...");
Arnaldo Carvalho de Melof6d8b052014-01-08 14:45:24 -0300660
Arnaldo Carvalho de Meloe5cadb92016-06-23 11:26:15 -0300661 evlist__for_each_entry(rep->session->evlist, pos) {
Arnaldo Carvalho de Melo4ea062ed2014-10-09 13:13:41 -0300662 struct hists *hists = evsel__hists(pos);
Arnaldo Carvalho de Melof6d8b052014-01-08 14:45:24 -0300663
664 if (pos->idx == 0)
665 hists->symbol_filter_str = rep->symbol_filter_str;
666
Kan Liang21394d92015-09-04 10:45:44 -0400667 hists->socket_filter = rep->socket_filter;
668
Namhyung Kim5b2ea6f2016-02-16 23:08:26 +0900669 ret = hists__collapse_resort(hists, &prog);
670 if (ret < 0)
671 break;
Arnaldo Carvalho de Melof6d8b052014-01-08 14:45:24 -0300672
673 /* Non-group events are considered as leader */
Arnaldo Carvalho de Meloc754c382020-04-30 10:51:16 -0300674 if (symbol_conf.event_group && !evsel__is_group_leader(pos)) {
Arnaldo Carvalho de Melo4ea062ed2014-10-09 13:13:41 -0300675 struct hists *leader_hists = evsel__hists(pos->leader);
Arnaldo Carvalho de Melof6d8b052014-01-08 14:45:24 -0300676
677 hists__match(leader_hists, hists);
678 hists__link(leader_hists, hists);
679 }
680 }
681
682 ui_progress__finish();
Namhyung Kim5b2ea6f2016-02-16 23:08:26 +0900683 return ret;
Arnaldo Carvalho de Melof6d8b052014-01-08 14:45:24 -0300684}
685
Jiri Olsadbd2a1d2019-02-04 15:18:08 +0100686static int hists__resort_cb(struct hist_entry *he, void *arg)
687{
688 struct report *rep = arg;
689 struct symbol *sym = he->ms.sym;
690
691 if (rep->symbol_ipc && sym && !sym->annotate2) {
Jiri Olsa32dcd022019-07-21 13:23:51 +0200692 struct evsel *evsel = hists_to_evsel(he->hists);
Jiri Olsadbd2a1d2019-02-04 15:18:08 +0100693
Arnaldo Carvalho de Melo29754892019-11-04 11:10:00 -0300694 symbol__annotate2(&he->ms, evsel,
Jiri Olsadbd2a1d2019-02-04 15:18:08 +0100695 &annotation__default_options, NULL);
696 }
697
698 return 0;
699}
700
Namhyung Kim740b97f2014-12-22 13:44:10 +0900701static void report__output_resort(struct report *rep)
702{
703 struct ui_progress prog;
Jiri Olsa32dcd022019-07-21 13:23:51 +0200704 struct evsel *pos;
Namhyung Kim740b97f2014-12-22 13:44:10 +0900705
706 ui_progress__init(&prog, rep->nr_entries, "Sorting events for output...");
707
Jiri Olsadbd2a1d2019-02-04 15:18:08 +0100708 evlist__for_each_entry(rep->session->evlist, pos) {
Arnaldo Carvalho de Melo10c513f2020-05-06 12:58:55 -0300709 evsel__output_resort_cb(pos, &prog, hists__resort_cb, rep);
Jiri Olsadbd2a1d2019-02-04 15:18:08 +0100710 }
Namhyung Kim740b97f2014-12-22 13:44:10 +0900711
712 ui_progress__finish();
713}
714
Jiri Olsaa4a4d0a2018-01-07 17:03:55 +0100715static void stats_setup(struct report *rep)
716{
717 memset(&rep->tool, 0, sizeof(rep->tool));
718 rep->tool.no_warn = true;
719}
720
721static int stats_print(struct report *rep)
722{
723 struct perf_session *session = rep->session;
724
725 perf_session__fprintf_nr_events(session, stdout);
726 return 0;
727}
728
Jiri Olsa930f8b32018-01-07 17:03:56 +0100729static void tasks_setup(struct report *rep)
730{
731 memset(&rep->tool, 0, sizeof(rep->tool));
Jiri Olsa8614ada2018-02-06 19:17:57 +0100732 rep->tool.ordered_events = true;
Arnaldo Carvalho de Melo6439d7d2018-01-09 15:25:03 -0300733 if (rep->mmaps_mode) {
734 rep->tool.mmap = perf_event__process_mmap;
735 rep->tool.mmap2 = perf_event__process_mmap2;
736 }
Jiri Olsa930f8b32018-01-07 17:03:56 +0100737 rep->tool.comm = perf_event__process_comm;
738 rep->tool.exit = perf_event__process_exit;
739 rep->tool.fork = perf_event__process_fork;
740 rep->tool.no_warn = true;
741}
742
743struct task {
744 struct thread *thread;
745 struct list_head list;
746 struct list_head children;
747};
748
749static struct task *tasks_list(struct task *task, struct machine *machine)
750{
751 struct thread *parent_thread, *thread = task->thread;
752 struct task *parent_task;
753
754 /* Already listed. */
755 if (!list_empty(&task->list))
756 return NULL;
757
758 /* Last one in the chain. */
759 if (thread->ppid == -1)
760 return task;
761
762 parent_thread = machine__find_thread(machine, -1, thread->ppid);
763 if (!parent_thread)
764 return ERR_PTR(-ENOENT);
765
766 parent_task = thread__priv(parent_thread);
767 list_add_tail(&task->list, &parent_task->children);
768 return tasks_list(parent_task, machine);
769}
770
Arnaldo Carvalho de Melo6439d7d2018-01-09 15:25:03 -0300771static size_t maps__fprintf_task(struct maps *maps, int indent, FILE *fp)
772{
773 size_t printed = 0;
Arnaldo Carvalho de Melo8efc4f02019-10-28 11:31:38 -0300774 struct map *map;
Arnaldo Carvalho de Melo6439d7d2018-01-09 15:25:03 -0300775
Arnaldo Carvalho de Melo8efc4f02019-10-28 11:31:38 -0300776 maps__for_each_entry(maps, map) {
Arnaldo Carvalho de Melo6439d7d2018-01-09 15:25:03 -0300777 printed += fprintf(fp, "%*s %" PRIx64 "-%" PRIx64 " %c%c%c%c %08" PRIx64 " %" PRIu64 " %s\n",
778 indent, "", map->start, map->end,
779 map->prot & PROT_READ ? 'r' : '-',
780 map->prot & PROT_WRITE ? 'w' : '-',
781 map->prot & PROT_EXEC ? 'x' : '-',
782 map->flags & MAP_SHARED ? 's' : 'p',
783 map->pgoff,
Arnaldo Carvalho de Melo0e3149f2019-11-19 18:44:22 -0300784 map->dso->id.ino, map->dso->name);
Arnaldo Carvalho de Melo6439d7d2018-01-09 15:25:03 -0300785 }
786
787 return printed;
788}
789
Jiri Olsa930f8b32018-01-07 17:03:56 +0100790static void task__print_level(struct task *task, FILE *fp, int level)
791{
792 struct thread *thread = task->thread;
793 struct task *child;
Arnaldo Carvalho de Melo6439d7d2018-01-09 15:25:03 -0300794 int comm_indent = fprintf(fp, " %8d %8d %8d |%*s",
795 thread->pid_, thread->tid, thread->ppid,
796 level, "");
Jiri Olsa930f8b32018-01-07 17:03:56 +0100797
Arnaldo Carvalho de Melo6439d7d2018-01-09 15:25:03 -0300798 fprintf(fp, "%s\n", thread__comm_str(thread));
799
Arnaldo Carvalho de Melofe87797d2019-11-25 22:07:43 -0300800 maps__fprintf_task(thread->maps, comm_indent, fp);
Jiri Olsa930f8b32018-01-07 17:03:56 +0100801
802 if (!list_empty(&task->children)) {
803 list_for_each_entry(child, &task->children, list)
804 task__print_level(child, fp, level + 1);
805 }
806}
807
808static int tasks_print(struct report *rep, FILE *fp)
809{
810 struct perf_session *session = rep->session;
811 struct machine *machine = &session->machines.host;
812 struct task *tasks, *task;
813 unsigned int nr = 0, itask = 0, i;
814 struct rb_node *nd;
815 LIST_HEAD(list);
816
817 /*
818 * No locking needed while accessing machine->threads,
819 * because --tasks is single threaded command.
820 */
821
822 /* Count all the threads. */
823 for (i = 0; i < THREADS__TABLE_SIZE; i++)
824 nr += machine->threads[i].nr;
825
826 tasks = malloc(sizeof(*tasks) * nr);
827 if (!tasks)
828 return -ENOMEM;
829
830 for (i = 0; i < THREADS__TABLE_SIZE; i++) {
831 struct threads *threads = &machine->threads[i];
832
Davidlohr Buesof3acb3a2018-12-06 11:18:14 -0800833 for (nd = rb_first_cached(&threads->entries); nd;
834 nd = rb_next(nd)) {
Jiri Olsa930f8b32018-01-07 17:03:56 +0100835 task = tasks + itask++;
836
837 task->thread = rb_entry(nd, struct thread, rb_node);
838 INIT_LIST_HEAD(&task->children);
839 INIT_LIST_HEAD(&task->list);
840 thread__set_priv(task->thread, task);
841 }
842 }
843
844 /*
845 * Iterate every task down to the unprocessed parent
846 * and link all in task children list. Task with no
847 * parent is added into 'list'.
848 */
849 for (itask = 0; itask < nr; itask++) {
850 task = tasks + itask;
851
852 if (!list_empty(&task->list))
853 continue;
854
855 task = tasks_list(task, machine);
856 if (IS_ERR(task)) {
857 pr_err("Error: failed to process tasks\n");
858 free(tasks);
859 return PTR_ERR(task);
860 }
861
862 if (task)
863 list_add_tail(&task->list, &list);
864 }
865
866 fprintf(fp, "# %8s %8s %8s %s\n", "pid", "tid", "ppid", "comm");
867
868 list_for_each_entry(task, &list, list)
869 task__print_level(task, fp, 0);
870
871 free(tasks);
872 return 0;
873}
874
Arnaldo Carvalho de Melo28b21392013-12-19 14:53:53 -0300875static int __cmd_report(struct report *rep)
Ingo Molnard80d3382009-06-03 23:14:49 +0200876{
Arnaldo Carvalho de Melof6d8b052014-01-08 14:45:24 -0300877 int ret;
Stephane Eranian993ac882012-03-08 23:47:47 +0100878 struct perf_session *session = rep->session;
Jiri Olsa32dcd022019-07-21 13:23:51 +0200879 struct evsel *pos;
Jiri Olsa8ceb41d2017-01-23 22:07:59 +0100880 struct perf_data *data = session->data;
Ingo Molnard80d3382009-06-03 23:14:49 +0200881
Tom Zanussi46656ac2010-04-01 23:59:17 -0500882 signal(SIGINT, sig_handler);
883
Arnaldo Carvalho de Melofa372aa2011-11-17 12:19:04 -0200884 if (rep->cpu_list) {
885 ret = perf_session__cpu_bitmap(session, rep->cpu_list,
886 rep->cpu_bitmap);
Namhyung Kim25b16062015-11-28 02:32:37 +0900887 if (ret) {
888 ui__error("failed to set cpu bitmap\n");
Jiri Olsad4ae0a62013-06-25 13:54:13 +0200889 return ret;
Namhyung Kim25b16062015-11-28 02:32:37 +0900890 }
Adrian Hunter644e0842017-05-26 11:17:38 +0300891 session->itrace_synth_opts->cpu_bitmap = rep->cpu_bitmap;
Anton Blanchard5d67be92011-07-04 21:57:50 +1000892 }
893
Arnaldo Carvalho de Melo89973502016-10-14 18:23:11 -0300894 if (rep->show_threads) {
895 ret = perf_read_values_init(&rep->show_threads_values);
896 if (ret)
897 return ret;
898 }
Brice Goglin8d513272009-08-07 13:55:24 +0200899
Arnaldo Carvalho de Melo28b21392013-12-19 14:53:53 -0300900 ret = report__setup_sample_type(rep);
Namhyung Kim25b16062015-11-28 02:32:37 +0900901 if (ret) {
902 /* report__setup_sample_type() already showed error message */
Jiri Olsad4ae0a62013-06-25 13:54:13 +0200903 return ret;
Namhyung Kim25b16062015-11-28 02:32:37 +0900904 }
Arnaldo Carvalho de Melod549c7692009-12-27 21:37:02 -0200905
Jiri Olsaa4a4d0a2018-01-07 17:03:55 +0100906 if (rep->stats_mode)
907 stats_setup(rep);
908
Jiri Olsa930f8b32018-01-07 17:03:56 +0100909 if (rep->tasks_mode)
910 tasks_setup(rep);
911
Arnaldo Carvalho de Melob7b61cb2015-03-03 11:58:45 -0300912 ret = perf_session__process_events(session);
Namhyung Kim25b16062015-11-28 02:32:37 +0900913 if (ret) {
914 ui__error("failed to process sample\n");
Jiri Olsad4ae0a62013-06-25 13:54:13 +0200915 return ret;
Namhyung Kim25b16062015-11-28 02:32:37 +0900916 }
Ingo Molnar97b07b62009-05-26 18:48:58 +0200917
Jiri Olsaa4a4d0a2018-01-07 17:03:55 +0100918 if (rep->stats_mode)
919 return stats_print(rep);
920
Jiri Olsa930f8b32018-01-07 17:03:56 +0100921 if (rep->tasks_mode)
922 return tasks_print(rep, stdout);
923
Arnaldo Carvalho de Melofad29182014-01-08 10:10:00 -0300924 report__warn_kptr_restrict(rep);
Arnaldo Carvalho de Meloec80fde2011-05-26 09:53:51 -0300925
Arnaldo Carvalho de Meloe5cadb92016-06-23 11:26:15 -0300926 evlist__for_each_entry(session->evlist, pos)
Namhyung Kim590cd342014-12-22 13:44:09 +0900927 rep->nr_entries += evsel__hists(pos)->nr_entries;
928
Namhyung Kim150e4652013-12-20 14:11:13 +0900929 if (use_browser == 0) {
930 if (verbose > 3)
931 perf_session__fprintf(session, stdout);
Arnaldo Carvalho de Melo9ac99542009-06-04 13:54:00 -0300932
Namhyung Kim150e4652013-12-20 14:11:13 +0900933 if (verbose > 2)
934 perf_session__fprintf_dsos(session, stdout);
Ingo Molnar16f762a2009-05-27 09:10:38 +0200935
Namhyung Kim150e4652013-12-20 14:11:13 +0900936 if (dump_trace) {
937 perf_session__fprintf_nr_events(session, stdout);
Arnaldo Carvalho de Melo2a1731f2014-10-10 15:49:21 -0300938 perf_evlist__fprintf_nr_events(session->evlist, stdout);
Namhyung Kim150e4652013-12-20 14:11:13 +0900939 return 0;
940 }
Jiri Olsa71ad0f52012-08-07 15:20:46 +0200941 }
942
Namhyung Kim5b2ea6f2016-02-16 23:08:26 +0900943 ret = report__collapse_hists(rep);
944 if (ret) {
945 ui__error("failed to process hist entry\n");
946 return ret;
947 }
Arnaldo Carvalho de Meloe248de32011-03-05 21:40:06 -0300948
Arnaldo Carvalho de Melo33e940a2013-09-17 16:34:28 -0300949 if (session_done())
950 return 0;
951
Namhyung Kim740b97f2014-12-22 13:44:10 +0900952 /*
953 * recalculate number of entries after collapsing since it
954 * might be changed during the collapse phase.
955 */
956 rep->nr_entries = 0;
Arnaldo Carvalho de Meloe5cadb92016-06-23 11:26:15 -0300957 evlist__for_each_entry(session->evlist, pos)
Namhyung Kim740b97f2014-12-22 13:44:10 +0900958 rep->nr_entries += evsel__hists(pos)->nr_entries;
959
Namhyung Kim58c311d2014-04-22 09:47:25 +0900960 if (rep->nr_entries == 0) {
Jiri Olsa2d4f2792019-02-21 10:41:30 +0100961 ui__error("The %s data has no samples!\n", data->path);
Jiri Olsad4ae0a62013-06-25 13:54:13 +0200962 return 0;
Arnaldo Carvalho de Melo74cfc172011-02-17 14:40:46 -0200963 }
964
Namhyung Kim740b97f2014-12-22 13:44:10 +0900965 report__output_resort(rep);
Namhyung Kim6e1f6012013-01-22 18:09:32 +0900966
Jin Yao6f7164f2019-11-07 15:47:17 +0800967 if (rep->total_cycles_mode) {
Jin Yaocca0cc72020-02-02 22:16:54 +0800968 int block_hpps[6] = {
969 PERF_HPP_REPORT__BLOCK_TOTAL_CYCLES_PCT,
970 PERF_HPP_REPORT__BLOCK_LBR_CYCLES,
971 PERF_HPP_REPORT__BLOCK_CYCLES_PCT,
972 PERF_HPP_REPORT__BLOCK_AVG_CYCLES,
973 PERF_HPP_REPORT__BLOCK_RANGE,
974 PERF_HPP_REPORT__BLOCK_DSO,
975 };
976
Jin Yao6f7164f2019-11-07 15:47:17 +0800977 rep->block_reports = block_info__create_report(session->evlist,
Jin Yaocca0cc72020-02-02 22:16:54 +0800978 rep->total_cycles,
979 block_hpps, 6,
980 &rep->nr_block_reports);
Jin Yao6f7164f2019-11-07 15:47:17 +0800981 if (!rep->block_reports)
982 return -1;
983 }
984
Arnaldo Carvalho de Melo83629512014-01-08 12:22:07 -0300985 return report__browse_hists(rep);
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300986}
987
Frederic Weisbecker4eb3e472009-07-02 17:58:21 +0200988static int
Don Zickuscff6bb42014-04-07 14:55:24 -0400989report_parse_callchain_opt(const struct option *opt, const char *arg, int unset)
Frederic Weisbecker4eb3e472009-07-02 17:58:21 +0200990{
Arnaldo Carvalho de Melo1cc83812016-04-18 11:54:31 -0300991 struct callchain_param *callchain = opt->value;
Frederic Weisbeckerc20ab372009-07-02 20:14:33 +0200992
Arnaldo Carvalho de Melo1cc83812016-04-18 11:54:31 -0300993 callchain->enabled = !unset;
Arnaldo Carvalho de Melob9a63b92010-01-05 11:54:45 -0200994 /*
995 * --no-call-graph
996 */
997 if (unset) {
Arnaldo Carvalho de Melo1cc83812016-04-18 11:54:31 -0300998 symbol_conf.use_callchain = false;
999 callchain->mode = CHAIN_NONE;
Arnaldo Carvalho de Melob9a63b92010-01-05 11:54:45 -02001000 return 0;
1001 }
1002
Don Zickuscff6bb42014-04-07 14:55:24 -04001003 return parse_callchain_report_opt(arg);
Frederic Weisbecker4eb3e472009-07-02 17:58:21 +02001004}
1005
Andi Kleen2a1292c2019-03-05 06:47:48 -08001006static int
1007parse_time_quantum(const struct option *opt, const char *arg,
1008 int unset __maybe_unused)
1009{
1010 unsigned long *time_q = opt->value;
1011 char *end;
1012
1013 *time_q = strtoul(arg, &end, 0);
1014 if (end == arg)
1015 goto parse_err;
1016 if (*time_q == 0) {
1017 pr_err("time quantum cannot be 0");
1018 return -1;
1019 }
Arnaldo Carvalho de Melo526bbbd2019-06-26 11:24:37 -03001020 end = skip_spaces(end);
Andi Kleen2a1292c2019-03-05 06:47:48 -08001021 if (*end == 0)
1022 return 0;
1023 if (!strcmp(end, "s")) {
1024 *time_q *= NSEC_PER_SEC;
1025 return 0;
1026 }
1027 if (!strcmp(end, "ms")) {
1028 *time_q *= NSEC_PER_MSEC;
1029 return 0;
1030 }
1031 if (!strcmp(end, "us")) {
1032 *time_q *= NSEC_PER_USEC;
1033 return 0;
1034 }
1035 if (!strcmp(end, "ns"))
1036 return 0;
1037parse_err:
1038 pr_err("Cannot parse time quantum `%s'\n", arg);
1039 return -1;
1040}
1041
Greg Priceb21484f2012-12-06 21:48:05 -08001042int
1043report_parse_ignore_callees_opt(const struct option *opt __maybe_unused,
1044 const char *arg, int unset __maybe_unused)
1045{
1046 if (arg) {
1047 int err = regcomp(&ignore_callees_regex, arg, REG_EXTENDED);
1048 if (err) {
1049 char buf[BUFSIZ];
1050 regerror(err, &ignore_callees_regex, buf, sizeof(buf));
1051 pr_err("Invalid --ignore-callees regex: %s\n%s", arg, buf);
1052 return -1;
1053 }
1054 have_ignore_callees = 1;
1055 }
1056
1057 return 0;
1058}
1059
Stephane Eranian993ac882012-03-08 23:47:47 +01001060static int
Arnaldo Carvalho de Melo7e6a7992016-12-12 10:52:10 -03001061parse_branch_mode(const struct option *opt,
Irina Tirdea1d037ca2012-09-11 01:15:03 +03001062 const char *str __maybe_unused, int unset)
Stephane Eranian993ac882012-03-08 23:47:47 +01001063{
Namhyung Kim55369fc2013-04-01 20:35:20 +09001064 int *branch_mode = opt->value;
1065
1066 *branch_mode = !unset;
Stephane Eranian993ac882012-03-08 23:47:47 +01001067 return 0;
1068}
1069
Namhyung Kim064f1982013-05-14 11:09:04 +09001070static int
1071parse_percent_limit(const struct option *opt, const char *str,
1072 int unset __maybe_unused)
1073{
Arnaldo Carvalho de Melo28b21392013-12-19 14:53:53 -03001074 struct report *rep = opt->value;
Namhyung Kim2665b452016-01-28 00:40:50 +09001075 double pcnt = strtof(str, NULL);
Namhyung Kim064f1982013-05-14 11:09:04 +09001076
Namhyung Kim2665b452016-01-28 00:40:50 +09001077 rep->min_percent = pcnt;
1078 callchain_param.min_percent = pcnt;
Namhyung Kim064f1982013-05-14 11:09:04 +09001079 return 0;
1080}
1081
Jiri Olsa0d71a2b2020-05-07 11:50:23 +02001082static int process_attr(struct perf_tool *tool __maybe_unused,
1083 union perf_event *event,
1084 struct evlist **pevlist)
1085{
1086 u64 sample_type;
1087 int err;
1088
1089 err = perf_event__process_attr(tool, event, pevlist);
1090 if (err)
1091 return err;
1092
1093 /*
1094 * Check if we need to enable callchains based
1095 * on events sample_type.
1096 */
1097 sample_type = perf_evlist__combined_sample_type(*pevlist);
1098 callchain_param_setup(sample_type);
1099 return 0;
1100}
1101
Arnaldo Carvalho de Melob0ad8ea2017-03-27 11:47:20 -03001102int cmd_report(int argc, const char **argv)
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001103{
Stephane Eranian993ac882012-03-08 23:47:47 +01001104 struct perf_session *session;
Adrian Hunter520a2eb2015-04-24 22:29:45 +03001105 struct itrace_synth_opts itrace_synth_opts = { .set = 0, };
Robert Richterefad1412011-12-07 10:02:54 +01001106 struct stat st;
Stephane Eranian993ac882012-03-08 23:47:47 +01001107 bool has_br_stack = false;
Namhyung Kim55369fc2013-04-01 20:35:20 +09001108 int branch_mode = -1;
Jin Yao0feba172019-12-20 09:37:19 +08001109 int last_key = 0;
Andi Kleenfa94c362014-11-12 18:05:22 -08001110 bool branch_call_mode = false;
Arnaldo Carvalho de Melo9d0199c2018-05-28 14:34:40 -03001111#define CALLCHAIN_DEFAULT_OPT "graph,0.5,caller,function,percent"
Rasmus Villemoes49b8e2b2018-11-03 00:06:23 +01001112 static const char report_callchain_help[] = "Display call graph (stack chain/backtrace):\n\n"
1113 CALLCHAIN_REPORT_HELP
1114 "\n\t\t\t\tDefault: " CALLCHAIN_DEFAULT_OPT;
Namhyung Kim76a26542015-10-22 23:28:32 +09001115 char callchain_default_opt[] = CALLCHAIN_DEFAULT_OPT;
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001116 const char * const report_usage[] = {
Namhyung Kimfb2bace2011-12-13 00:16:56 +09001117 "perf report [<options>]",
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001118 NULL
1119 };
Arnaldo Carvalho de Melo28b21392013-12-19 14:53:53 -03001120 struct report report = {
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02001121 .tool = {
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001122 .sample = process_sample_event,
1123 .mmap = perf_event__process_mmap,
Stephane Eranian5c5e8542013-08-21 12:10:25 +02001124 .mmap2 = perf_event__process_mmap2,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001125 .comm = perf_event__process_comm,
Hari Bathinif3b36142017-03-08 02:11:43 +05301126 .namespaces = perf_event__process_namespaces,
Namhyung Kimba78c1c2020-03-25 21:45:30 +09001127 .cgroup = perf_event__process_cgroup,
Arnaldo Carvalho de Melof62d3f02012-10-06 15:44:59 -03001128 .exit = perf_event__process_exit,
1129 .fork = perf_event__process_fork,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001130 .lost = perf_event__process_lost,
1131 .read = process_read_event,
Jiri Olsa0d71a2b2020-05-07 11:50:23 +02001132 .attr = process_attr,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001133 .tracing_data = perf_event__process_tracing_data,
1134 .build_id = perf_event__process_build_id,
Adrian Hunter520a2eb2015-04-24 22:29:45 +03001135 .id_index = perf_event__process_id_index,
1136 .auxtrace_info = perf_event__process_auxtrace_info,
1137 .auxtrace = perf_event__process_auxtrace,
Jiri Olsa4ab84552018-10-03 23:20:52 +02001138 .event_update = perf_event__process_event_update,
Jiri Olsa57b5de42018-03-14 10:22:05 +01001139 .feature = process_feature_event,
Jiri Olsa0a8cb852014-07-06 14:18:21 +02001140 .ordered_events = true,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001141 .ordering_requires_timestamps = true,
1142 },
Arnaldo Carvalho de Melofe176082016-05-19 11:34:06 -03001143 .max_stack = PERF_MAX_STACK_DEPTH,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001144 .pretty_printing_style = "normal",
Kan Liang21394d92015-09-04 10:45:44 -04001145 .socket_filter = -1,
Arnaldo Carvalho de Melo1eddd9e2018-05-28 11:42:59 -03001146 .annotation_opts = annotation__default_options,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001147 };
1148 const struct option options[] = {
Feng Tang70cb4e92012-10-30 11:56:02 +08001149 OPT_STRING('i', "input", &input_name, "file",
Ingo Molnar53cb8bc2009-05-26 09:17:18 +02001150 "input file name"),
Ian Munsiec0555642010-04-13 18:37:33 +10001151 OPT_INCR('v', "verbose", &verbose,
Arnaldo Carvalho de Melo815e7772009-05-26 19:46:14 -03001152 "be more verbose (show symbol address, etc)"),
Namhyung Kim27fafab2017-02-17 17:17:39 +09001153 OPT_BOOLEAN('q', "quiet", &quiet, "Do not show any message"),
Ingo Molnar97b07b62009-05-26 18:48:58 +02001154 OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
1155 "dump raw trace in ASCII"),
Jiri Olsaa4a4d0a2018-01-07 17:03:55 +01001156 OPT_BOOLEAN(0, "stats", &report.stats_mode, "Display event stats"),
Jiri Olsa930f8b32018-01-07 17:03:56 +01001157 OPT_BOOLEAN(0, "tasks", &report.tasks_mode, "Display recorded tasks"),
Arnaldo Carvalho de Melo6439d7d2018-01-09 15:25:03 -03001158 OPT_BOOLEAN(0, "mmaps", &report.mmaps_mode, "Display recorded tasks memory maps"),
Arnaldo Carvalho de Melob32d1332009-11-24 12:05:15 -02001159 OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
1160 "file", "vmlinux pathname"),
Arnaldo Carvalho de Melo91340c512018-03-16 16:27:04 -03001161 OPT_BOOLEAN(0, "ignore-vmlinux", &symbol_conf.ignore_vmlinux,
1162 "don't load vmlinux even if found"),
David Ahernb226a5a72010-12-07 19:39:46 -07001163 OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name,
1164 "file", "kallsyms pathname"),
Arnaldo Carvalho de Melo2059fc72015-11-12 16:50:13 -03001165 OPT_BOOLEAN('f', "force", &symbol_conf.force, "don't complain, do it"),
Arnaldo Carvalho de Melob32d1332009-11-24 12:05:15 -02001166 OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
Mike Galbraith42976482009-07-02 08:09:46 +02001167 "load module symbols - WARNING: use only with -k and LIVE kernel"),
Arnaldo Carvalho de Melod599db32009-12-15 20:04:42 -02001168 OPT_BOOLEAN('n', "show-nr-samples", &symbol_conf.show_nr_samples,
Arnaldo Carvalho de Meloe3d7e182009-07-11 12:18:37 -03001169 "Show a column with the number of samples"),
Arnaldo Carvalho de Melofa372aa2011-11-17 12:19:04 -02001170 OPT_BOOLEAN('T', "threads", &report.show_threads,
Brice Goglin8d513272009-08-07 13:55:24 +02001171 "Show per-thread event counters"),
Arnaldo Carvalho de Melofa372aa2011-11-17 12:19:04 -02001172 OPT_STRING(0, "pretty", &report.pretty_printing_style, "key",
Brice Goglin9f866692009-08-10 15:26:32 +02001173 "pretty printing style key: normal raw"),
Arnaldo Carvalho de Melofa372aa2011-11-17 12:19:04 -02001174 OPT_BOOLEAN(0, "tui", &report.use_tui, "Use the TUI interface"),
Pekka Enbergc31a9452012-03-19 15:13:29 -03001175 OPT_BOOLEAN(0, "gtk", &report.use_gtk, "Use the GTK2 interface"),
Arnaldo Carvalho de Melofa372aa2011-11-17 12:19:04 -02001176 OPT_BOOLEAN(0, "stdio", &report.use_stdio,
1177 "Use the stdio interface"),
Jiri Olsa5cfe2c82013-12-09 11:02:49 +01001178 OPT_BOOLEAN(0, "header", &report.header, "Show data header."),
1179 OPT_BOOLEAN(0, "header-only", &report.header_only,
1180 "Show only data header."),
Ingo Molnar63299f02009-05-28 10:52:00 +02001181 OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
Andi Kleen702fb9b2019-03-14 15:49:57 -07001182 sort_help("sort by key(s):")),
Namhyung Kima7d945b2014-03-04 10:46:34 +09001183 OPT_STRING('F', "fields", &field_order, "key[,keys...]",
Andi Kleen702fb9b2019-03-14 15:49:57 -07001184 sort_help("output field(s): overhead period sample ")),
Namhyung Kimb272a592015-10-25 00:49:25 +09001185 OPT_BOOLEAN(0, "show-cpu-utilization", &symbol_conf.show_cpu_utilization,
Zhang, Yanmina1645ce2010-04-19 13:32:50 +08001186 "Show sample percentage for different cpu modes"),
Namhyung Kimb272a592015-10-25 00:49:25 +09001187 OPT_BOOLEAN_FLAG(0, "showcpuutilization", &symbol_conf.show_cpu_utilization,
1188 "Show sample percentage for different cpu modes", PARSE_OPT_HIDDEN),
Ingo Molnarb25bcf22009-06-18 07:01:03 +02001189 OPT_STRING('p', "parent", &parent_pattern, "regex",
1190 "regex filter to identify parent, see: '--sort parent'"),
Arnaldo Carvalho de Melod599db32009-12-15 20:04:42 -02001191 OPT_BOOLEAN('x', "exclude-other", &symbol_conf.exclude_other,
Ingo Molnarb8e6d822009-06-18 14:32:19 +02001192 "Only display entries with parent-match"),
Arnaldo Carvalho de Melo1cc83812016-04-18 11:54:31 -03001193 OPT_CALLBACK_DEFAULT('g', "call-graph", &callchain_param,
Namhyung Kimf2af0082015-11-09 14:45:41 +09001194 "print_type,threshold[,print_limit],order,sort_key[,branch],value",
Namhyung Kim21cf6282015-10-22 15:28:48 +09001195 report_callchain_help, &report_parse_callchain_opt,
1196 callchain_default_opt),
Namhyung Kim793aaaa2013-10-30 17:05:55 +09001197 OPT_BOOLEAN(0, "children", &symbol_conf.cumulate_callchain,
Andi Kleenaa9d1f82020-01-03 10:36:43 -08001198 "Accumulate callchains of children and show total overhead as well. "
1199 "Enabled by default, use --no-children to disable."),
Waiman Long91e95612013-10-18 10:38:48 -04001200 OPT_INTEGER(0, "max-stack", &report.max_stack,
1201 "Set the maximum stack depth when parsing the callchain, "
1202 "anything beyond the specified depth will be ignored. "
Arnaldo Carvalho de Melo4cb93442016-04-27 10:16:24 -03001203 "Default: kernel.perf_event_max_stack or " __stringify(PERF_MAX_STACK_DEPTH)),
Arnaldo Carvalho de Melofa372aa2011-11-17 12:19:04 -02001204 OPT_BOOLEAN('G', "inverted", &report.inverted_callchain,
1205 "alias for inverted call graph"),
Greg Priceb21484f2012-12-06 21:48:05 -08001206 OPT_CALLBACK(0, "ignore-callees", NULL, "regex",
1207 "ignore callees of these functions in call graphs",
1208 report_parse_ignore_callees_opt),
Arnaldo Carvalho de Melo655000e2009-12-15 20:04:40 -02001209 OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
Arnaldo Carvalho de Melo25903402009-06-30 19:01:20 -03001210 "only consider symbols in these dsos"),
David Ahernc8e66722011-11-13 11:30:08 -07001211 OPT_STRING('c', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
Arnaldo Carvalho de Melocc8b88b2009-06-30 19:01:21 -03001212 "only consider symbols in these comms"),
David Aherne03eaa42015-03-24 09:52:41 -06001213 OPT_STRING(0, "pid", &symbol_conf.pid_list_str, "pid[,pid...]",
1214 "only consider symbols in these pids"),
1215 OPT_STRING(0, "tid", &symbol_conf.tid_list_str, "tid[,tid...]",
1216 "only consider symbols in these tids"),
Arnaldo Carvalho de Melo655000e2009-12-15 20:04:40 -02001217 OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
Arnaldo Carvalho de Melo7bec7a92009-06-30 19:01:22 -03001218 "only consider these symbols"),
Namhyung Kimb14ffac2012-03-16 17:50:54 +09001219 OPT_STRING(0, "symbol-filter", &report.symbol_filter_str, "filter",
1220 "only show symbols that (partially) match with this filter"),
Arnaldo Carvalho de Melo655000e2009-12-15 20:04:40 -02001221 OPT_STRING('w', "column-widths", &symbol_conf.col_width_list_str,
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -03001222 "width[,width...]",
1223 "don't try to adjust column width, use these fixed values"),
Wang Nan0c8c2072015-03-13 12:51:54 +00001224 OPT_STRING_NOEMPTY('t', "field-separator", &symbol_conf.field_sep, "separator",
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -03001225 "separator for columns, no spaces will be added between "
1226 "columns '.' is reserved."),
Namhyung Kimb49a8fe2015-11-26 16:08:20 +09001227 OPT_BOOLEAN('U', "hide-unresolved", &symbol_conf.hide_unresolved,
Arnaldo Carvalho de Melo71289be2009-12-28 22:48:34 -02001228 "Only display entries resolved to a symbol"),
He Kuanga7066702016-05-19 11:47:37 +00001229 OPT_CALLBACK(0, "symfs", NULL, "directory",
1230 "Look for files with symbols relative to this directory",
1231 symbol__config_symfs),
David Ahernc8e66722011-11-13 11:30:08 -07001232 OPT_STRING('C', "cpu", &report.cpu_list, "cpu",
Arnaldo Carvalho de Melofa372aa2011-11-17 12:19:04 -02001233 "list of cpus to profile"),
1234 OPT_BOOLEAN('I', "show-info", &report.show_full_info,
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001235 "Display extended information about perf.data file"),
Arnaldo Carvalho de Melo1eddd9e2018-05-28 11:42:59 -03001236 OPT_BOOLEAN(0, "source", &report.annotation_opts.annotate_src,
Arnaldo Carvalho de Melo64c6f0c2011-10-06 12:48:31 -03001237 "Interleave source code with assembly code (default)"),
Arnaldo Carvalho de Melo1eddd9e2018-05-28 11:42:59 -03001238 OPT_BOOLEAN(0, "asm-raw", &report.annotation_opts.show_asm_raw,
Arnaldo Carvalho de Melo64c6f0c2011-10-06 12:48:31 -03001239 "Display raw encoding of assembly instructions (default)"),
Arnaldo Carvalho de Meloa47e8432018-05-28 11:50:21 -03001240 OPT_STRING('M', "disassembler-style", &report.annotation_opts.disassembler_style, "disassembler style",
Andi Kleenf69b64f2011-09-15 14:31:41 -07001241 "Specify disassembler style (e.g. -M intel for intel syntax)"),
Andi Kleen3b0b16bf2020-01-07 13:04:44 -08001242 OPT_STRING(0, "prefix", &report.annotation_opts.prefix, "prefix",
1243 "Add prefix to source file path names in programs (with --prefix-strip)"),
1244 OPT_STRING(0, "prefix-strip", &report.annotation_opts.prefix_strip, "N",
1245 "Strip first N entries of source file path name in programs (with --prefix)"),
Arnaldo Carvalho de Melo3f2728b2011-10-05 16:10:06 -03001246 OPT_BOOLEAN(0, "show-total-period", &symbol_conf.show_total_period,
1247 "Show a column with the sum of periods"),
Jiri Olsa57b5de42018-03-14 10:22:05 +01001248 OPT_BOOLEAN_SET(0, "group", &symbol_conf.event_group, &report.group_set,
Namhyung Kim01d14f12013-01-22 18:09:45 +09001249 "Show event group information together"),
Jin Yao429a5f92020-02-20 09:36:14 +08001250 OPT_INTEGER(0, "group-sort-idx", &symbol_conf.group_sort_idx,
1251 "Sort the output by the event at the index n in group. "
1252 "If n is invalid, sort by the first event. "
1253 "WARNING: should be used on grouped events."),
Namhyung Kim55369fc2013-04-01 20:35:20 +09001254 OPT_CALLBACK_NOOPT('b', "branch-stack", &branch_mode, "",
Andi Kleenfa94c362014-11-12 18:05:22 -08001255 "use branch records for per branch histogram filling",
1256 parse_branch_mode),
1257 OPT_BOOLEAN(0, "branch-history", &branch_call_mode,
1258 "add last branch records to call history"),
Arnaldo Carvalho de Melof178fd22018-05-28 14:24:45 -03001259 OPT_STRING(0, "objdump", &report.annotation_opts.objdump_path, "path",
Maciek Borzecki7a4ec932012-09-04 12:32:30 +02001260 "objdump binary to use for disassembly and annotations"),
Namhyung Kim328ccda2013-03-25 18:18:18 +09001261 OPT_BOOLEAN(0, "demangle", &symbol_conf.demangle,
1262 "Disable symbol demangling"),
Avi Kivity763122a2014-09-13 07:15:05 +03001263 OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf.demangle_kernel,
1264 "Enable kernel symbol demangling"),
Stephane Eranianf4f7e282013-01-24 16:10:36 +01001265 OPT_BOOLEAN(0, "mem-mode", &report.mem_mode, "mem access profile"),
Andi Kleen4968ac82019-03-11 07:44:58 -07001266 OPT_INTEGER(0, "samples", &symbol_conf.res_sample,
1267 "Number of samples to save per histogram entry for individual browsing"),
Namhyung Kim064f1982013-05-14 11:09:04 +09001268 OPT_CALLBACK(0, "percent-limit", &report, "percent",
1269 "Don't show entries under that percent", parse_percent_limit),
Namhyung Kimf2148332014-01-14 11:52:48 +09001270 OPT_CALLBACK(0, "percentage", NULL, "relative|absolute",
Namhyung Kim33db4562014-02-07 12:06:07 +09001271 "how to display percentage of filtered entries", parse_filter_percentage),
Adrian Hunter520a2eb2015-04-24 22:29:45 +03001272 OPT_CALLBACK_OPTARG(0, "itrace", &itrace_synth_opts, NULL, "opts",
Andi Kleenc12e0392018-09-13 20:10:31 -07001273 "Instruction Tracing options\n" ITRACE_HELP,
Adrian Hunter520a2eb2015-04-24 22:29:45 +03001274 itrace_parse_synth_opts),
Andi Kleena9710ba2015-08-07 15:24:05 -07001275 OPT_BOOLEAN(0, "full-source-path", &srcline_full_filename,
1276 "Show full source file name path for source lines"),
Kan Liang9e207dd2015-08-11 06:30:49 -04001277 OPT_BOOLEAN(0, "show-ref-call-graph", &symbol_conf.show_ref_callgraph,
1278 "Show callgraph from reference event"),
Kan Liangb1d14292020-03-19 13:25:13 -07001279 OPT_BOOLEAN(0, "stitch-lbr", &report.stitch_lbr,
1280 "Enable LBR callgraph stitching approach"),
Kan Liang21394d92015-09-04 10:45:44 -04001281 OPT_INTEGER(0, "socket-filter", &report.socket_filter,
1282 "only show processor socket that match with this filter"),
Namhyung Kim053a3982015-12-23 02:07:05 +09001283 OPT_BOOLEAN(0, "raw-trace", &symbol_conf.raw_trace,
1284 "Show raw trace event output (do not use print fmt or plugins)"),
Namhyung Kim42514462016-02-25 00:13:48 +09001285 OPT_BOOLEAN(0, "hierarchy", &symbol_conf.report_hierarchy,
1286 "Show entries in a hierarchy"),
Arnaldo Carvalho de Melo175b9682016-07-05 11:14:38 -03001287 OPT_CALLBACK_DEFAULT(0, "stdio-color", NULL, "mode",
1288 "'always' (default), 'never' or 'auto' only applicable to --stdio mode",
1289 stdio__config_color, "always"),
David Ahern46690a82016-11-29 10:15:46 -07001290 OPT_STRING(0, "time", &report.time_str, "str",
1291 "Time span of interest (start,stop)"),
Jin Yaof3a60642017-03-26 04:34:27 +08001292 OPT_BOOLEAN(0, "inline", &symbol_conf.inline_name,
1293 "Show inline function"),
Jiri Olsae6902d12018-08-04 15:05:21 +02001294 OPT_CALLBACK(0, "percent-type", &report.annotation_opts, "local-period",
1295 "Set percent type local/global-period/hits",
1296 annotate_parse_percent_type),
Andi Kleen52bab882019-03-05 06:47:47 -08001297 OPT_BOOLEAN(0, "ns", &symbol_conf.nanosecs, "Show times in nanosecs"),
Andi Kleen2a1292c2019-03-05 06:47:48 -08001298 OPT_CALLBACK(0, "time-quantum", &symbol_conf.time_quantum, "time (ms|us|ns|s)",
1299 "Set time quantum for time sort key (default 100ms)",
1300 parse_time_quantum),
Arnaldo Carvalho de Meloef4b1a52019-08-15 18:18:58 -03001301 OPTS_EVSWITCH(&report.evswitch),
Jin Yao6f7164f2019-11-07 15:47:17 +08001302 OPT_BOOLEAN(0, "total-cycles", &report.total_cycles_mode,
1303 "Sort all blocks by 'Sampled Cycles%'"),
Ingo Molnar53cb8bc2009-05-26 09:17:18 +02001304 OPT_END()
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02001305 };
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001306 struct perf_data data = {
Jiri Olsaf5fc14122013-10-15 16:27:32 +02001307 .mode = PERF_DATA_MODE_READ,
1308 };
Arnaldo Carvalho de Meloa635fc52014-10-09 16:16:00 -03001309 int ret = hists__init();
Jin Yaoec6ae742018-11-30 21:54:56 +08001310 char sort_tmp[128];
Arnaldo Carvalho de Meloa635fc52014-10-09 16:16:00 -03001311
1312 if (ret < 0)
1313 return ret;
Ingo Molnar53cb8bc2009-05-26 09:17:18 +02001314
Arnaldo Carvalho de Meloecc4c562017-01-24 13:44:10 -03001315 ret = perf_config(report__config, &report);
1316 if (ret)
1317 return ret;
Namhyung Kim00c7e1f2013-01-22 18:09:46 +09001318
Arnaldo Carvalho de Melo655000e2009-12-15 20:04:40 -02001319 argc = parse_options(argc, argv, options, report_usage, 0);
Namhyung Kimb3f38fc2015-12-10 12:00:56 +09001320 if (argc) {
1321 /*
1322 * Special case: if there's an argument left then assume that
1323 * it's a symbol filter:
1324 */
1325 if (argc > 1)
1326 usage_with_options(report_usage, options);
1327
1328 report.symbol_filter_str = argv[0];
1329 }
Arnaldo Carvalho de Melo655000e2009-12-15 20:04:40 -02001330
Andi Kleen3b0b16bf2020-01-07 13:04:44 -08001331 if (annotate_check_args(&report.annotation_opts) < 0)
1332 return -EINVAL;
1333
Arnaldo Carvalho de Melo6439d7d2018-01-09 15:25:03 -03001334 if (report.mmaps_mode)
1335 report.tasks_mode = true;
1336
Namhyung Kim27fafab2017-02-17 17:17:39 +09001337 if (quiet)
1338 perf_quiet_option();
1339
Li Zhang36c8bb52015-06-19 16:57:33 +08001340 if (symbol_conf.vmlinux_name &&
1341 access(symbol_conf.vmlinux_name, R_OK)) {
1342 pr_err("Invalid file: %s\n", symbol_conf.vmlinux_name);
1343 return -EINVAL;
1344 }
1345 if (symbol_conf.kallsyms_name &&
1346 access(symbol_conf.kallsyms_name, R_OK)) {
1347 pr_err("Invalid file: %s\n", symbol_conf.kallsyms_name);
1348 return -EINVAL;
1349 }
1350
Arnaldo Carvalho de Melofa372aa2011-11-17 12:19:04 -02001351 if (report.inverted_callchain)
Sam Liaod797fdc2011-06-07 23:49:46 +08001352 callchain_param.order = ORDER_CALLER;
Namhyung Kim792aeaf2015-10-22 16:45:46 +09001353 if (symbol_conf.cumulate_callchain && !callchain_param.order_set)
1354 callchain_param.order = ORDER_CALLER;
Sam Liaod797fdc2011-06-07 23:49:46 +08001355
Adrian Hunter1c5c25b2020-04-01 13:16:05 +03001356 if ((itrace_synth_opts.callchain || itrace_synth_opts.add_callchain) &&
Adrian Hunter188bb5e2015-09-25 16:15:46 +03001357 (int)itrace_synth_opts.callchain_sz > report.max_stack)
1358 report.max_stack = itrace_synth_opts.callchain_sz;
1359
Feng Tang70cb4e92012-10-30 11:56:02 +08001360 if (!input_name || !strlen(input_name)) {
Robert Richterefad1412011-12-07 10:02:54 +01001361 if (!fstat(STDIN_FILENO, &st) && S_ISFIFO(st.st_mode))
Feng Tang70cb4e92012-10-30 11:56:02 +08001362 input_name = "-";
Robert Richterefad1412011-12-07 10:02:54 +01001363 else
Feng Tang70cb4e92012-10-30 11:56:02 +08001364 input_name = "perf.data";
Robert Richterefad1412011-12-07 10:02:54 +01001365 }
Feng Tangad0de092013-02-03 14:38:21 +08001366
Jiri Olsa2d4f2792019-02-21 10:41:30 +01001367 data.path = input_name;
1368 data.force = symbol_conf.force;
Jiri Olsaf5fc14122013-10-15 16:27:32 +02001369
Feng Tangad0de092013-02-03 14:38:21 +08001370repeat:
Jiri Olsa8ceb41d2017-01-23 22:07:59 +01001371 session = perf_session__new(&data, false, &report.tool);
Mamatha Inamdar6ef81c52019-08-22 12:50:49 +05301372 if (IS_ERR(session))
1373 return PTR_ERR(session);
Robert Richterefad1412011-12-07 10:02:54 +01001374
Arnaldo Carvalho de Meloef4b1a52019-08-15 18:18:58 -03001375 ret = evswitch__init(&report.evswitch, session->evlist, stderr);
1376 if (ret)
1377 return ret;
1378
Alexey Budankovcb62c6f2019-03-18 20:45:11 +03001379 if (zstd_init(&(session->zstd_data), 0) < 0)
1380 pr_warning("Decompression initialization failed. Reported data may be incomplete.\n");
1381
Jiri Olsa94786b62014-06-05 11:00:20 +02001382 if (report.queue_size) {
1383 ordered_events__set_alloc_size(&session->ordered_events,
1384 report.queue_size);
1385 }
1386
Adrian Hunter520a2eb2015-04-24 22:29:45 +03001387 session->itrace_synth_opts = &itrace_synth_opts;
1388
Stephane Eranian993ac882012-03-08 23:47:47 +01001389 report.session = session;
1390
1391 has_br_stack = perf_header__has_feat(&session->header,
1392 HEADER_BRANCH_STACK);
Alexey Budankov10ccbc12019-08-09 18:31:28 +03001393 if (perf_evlist__combined_sample_type(session->evlist) & PERF_SAMPLE_STACK_USER)
1394 has_br_stack = false;
Stephane Eranian993ac882012-03-08 23:47:47 +01001395
Jiri Olsa57b5de42018-03-14 10:22:05 +01001396 setup_forced_leader(&report, session->evlist);
Jiri Olsaad52b8c2018-02-09 10:27:34 +01001397
Jin Yao429a5f92020-02-20 09:36:14 +08001398 if (symbol_conf.group_sort_idx && !session->evlist->nr_groups) {
1399 parse_options_usage(NULL, options, "group-sort-idx", 0);
1400 ret = -EINVAL;
1401 goto error;
1402 }
1403
Adrian Hunterec90e422020-04-29 18:07:46 +03001404 if (itrace_synth_opts.last_branch || itrace_synth_opts.add_last_branch)
Adrian Hunterfb9fab62015-09-25 16:15:41 +03001405 has_br_stack = true;
1406
Jin Yaof9a7be72016-10-31 09:19:50 +08001407 if (has_br_stack && branch_call_mode)
1408 symbol_conf.show_branchflag_count = true;
1409
Jin Yao2d78b182017-07-18 20:13:14 +08001410 memset(&report.brtype_stat, 0, sizeof(struct branch_type_stat));
1411
Andi Kleenfa94c362014-11-12 18:05:22 -08001412 /*
1413 * Branch mode is a tristate:
1414 * -1 means default, so decide based on the file having branch data.
1415 * 0/1 means the user chose a mode.
1416 */
1417 if (((branch_mode == -1 && has_br_stack) || branch_mode == 1) &&
He Kuangfefd2d92015-02-15 10:33:37 +08001418 !branch_call_mode) {
Namhyung Kim55369fc2013-04-01 20:35:20 +09001419 sort__mode = SORT_MODE__BRANCH;
Namhyung Kim793aaaa2013-10-30 17:05:55 +09001420 symbol_conf.cumulate_callchain = false;
1421 }
Andi Kleenfa94c362014-11-12 18:05:22 -08001422 if (branch_call_mode) {
Andi Kleen09a6a1b2014-11-17 17:58:54 -08001423 callchain_param.key = CCKEY_ADDRESS;
Zou Wei6fa9c3e2020-04-26 20:38:03 +08001424 callchain_param.branch_callstack = true;
Andi Kleenfa94c362014-11-12 18:05:22 -08001425 symbol_conf.use_callchain = true;
1426 callchain_register_param(&callchain_param);
1427 if (sort_order == NULL)
1428 sort_order = "srcline,symbol,dso";
1429 }
Stephane Eranian993ac882012-03-08 23:47:47 +01001430
Stephane Eranianf4f7e282013-01-24 16:10:36 +01001431 if (report.mem_mode) {
Namhyung Kim55369fc2013-04-01 20:35:20 +09001432 if (sort__mode == SORT_MODE__BRANCH) {
Namhyung Kima4210142013-12-20 14:11:12 +09001433 pr_err("branch and mem mode incompatible\n");
Stephane Eranianf4f7e282013-01-24 16:10:36 +01001434 goto error;
1435 }
Namhyung Kimafab87b2013-04-03 21:26:11 +09001436 sort__mode = SORT_MODE__MEMORY;
Namhyung Kim793aaaa2013-10-30 17:05:55 +09001437 symbol_conf.cumulate_callchain = false;
Stephane Eranianf4f7e282013-01-24 16:10:36 +01001438 }
Stephane Eraniana68c2c52012-03-08 23:47:48 +01001439
Namhyung Kim42514462016-02-25 00:13:48 +09001440 if (symbol_conf.report_hierarchy) {
1441 /* disable incompatible options */
Namhyung Kim42514462016-02-25 00:13:48 +09001442 symbol_conf.cumulate_callchain = false;
1443
1444 if (field_order) {
1445 pr_err("Error: --hierarchy and --fields options cannot be used together\n");
1446 parse_options_usage(report_usage, options, "F", 1);
1447 parse_options_usage(NULL, options, "hierarchy", 0);
1448 goto error;
1449 }
1450
Jiri Olsa52225032016-05-03 13:54:42 +02001451 perf_hpp_list.need_collapse = true;
Namhyung Kim42514462016-02-25 00:13:48 +09001452 }
1453
Seokho Song712d36d2017-12-05 01:02:44 +09001454 if (report.use_stdio)
1455 use_browser = 0;
1456 else if (report.use_tui)
1457 use_browser = 1;
1458 else if (report.use_gtk)
1459 use_browser = 2;
1460
Namhyung Kimb138f422015-05-10 00:19:43 +09001461 /* Force tty output for header output and per-thread stat. */
1462 if (report.header || report.header_only || report.show_threads)
Jiri Olsa5cfe2c82013-12-09 11:02:49 +01001463 use_browser = 0;
David Carrillo-Cisneros114f7092017-07-17 21:25:47 -07001464 if (report.header || report.header_only)
1465 report.tool.show_feat_hdr = SHOW_FEAT_HEADER;
1466 if (report.show_full_info)
1467 report.tool.show_feat_hdr = SHOW_FEAT_HEADER_FULL_INFO;
Jiri Olsa930f8b32018-01-07 17:03:56 +01001468 if (report.stats_mode || report.tasks_mode)
Jiri Olsaa4a4d0a2018-01-07 17:03:55 +01001469 use_browser = 0;
Jiri Olsa930f8b32018-01-07 17:03:56 +01001470 if (report.stats_mode && report.tasks_mode) {
Arnaldo Carvalho de Melo6439d7d2018-01-09 15:25:03 -03001471 pr_err("Error: --tasks and --mmaps can't be used together with --stats\n");
Jiri Olsa930f8b32018-01-07 17:03:56 +01001472 goto error;
1473 }
Jiri Olsa5cfe2c82013-12-09 11:02:49 +01001474
Jin Yao6f7164f2019-11-07 15:47:17 +08001475 if (report.total_cycles_mode) {
1476 if (sort__mode != SORT_MODE__BRANCH)
1477 report.total_cycles_mode = false;
Jin Yao7fa46cb2019-11-07 15:47:19 +08001478 else
Jin Yao848a5e52019-11-18 22:08:49 +08001479 sort_order = NULL;
Jin Yao6f7164f2019-11-07 15:47:17 +08001480 }
1481
Namhyung Kim4bceffb2013-11-01 16:33:12 +09001482 if (strcmp(input_name, "-") != 0)
1483 setup_browser(true);
Namhyung Kim22af9692014-04-16 11:04:51 +09001484 else
Namhyung Kim4bceffb2013-11-01 16:33:12 +09001485 use_browser = 0;
Namhyung Kim4bceffb2013-11-01 16:33:12 +09001486
Jin Yaoec6ae742018-11-30 21:54:56 +08001487 if (sort_order && strstr(sort_order, "ipc")) {
1488 parse_options_usage(report_usage, options, "s", 1);
1489 goto error;
1490 }
1491
1492 if (sort_order && strstr(sort_order, "symbol")) {
1493 if (sort__mode == SORT_MODE__BRANCH) {
1494 snprintf(sort_tmp, sizeof(sort_tmp), "%s,%s",
1495 sort_order, "ipc_lbr");
1496 report.symbol_ipc = true;
1497 } else {
1498 snprintf(sort_tmp, sizeof(sort_tmp), "%s,%s",
1499 sort_order, "ipc_null");
1500 }
1501
1502 sort_order = sort_tmp;
1503 }
1504
Jin Yao5e3b8102020-02-20 09:36:15 +08001505 if ((last_key != K_SWITCH_INPUT_DATA && last_key != K_RELOAD) &&
Jin Yao0feba172019-12-20 09:37:19 +08001506 (setup_sorting(session->evlist) < 0)) {
Jiri Olsa98878042016-01-18 10:24:06 +01001507 if (sort_order)
1508 parse_options_usage(report_usage, options, "s", 1);
1509 if (field_order)
1510 parse_options_usage(sort_order ? NULL : report_usage,
1511 options, "F", 1);
1512 goto error;
1513 }
1514
Namhyung Kim27fafab2017-02-17 17:17:39 +09001515 if ((report.header || report.header_only) && !quiet) {
Jiri Olsa5cfe2c82013-12-09 11:02:49 +01001516 perf_session__fprintf_info(session, stdout,
1517 report.show_full_info);
Taeung Song07a716f2015-06-30 17:15:24 +09001518 if (report.header_only) {
1519 ret = 0;
1520 goto error;
1521 }
Jiri Olsa930f8b32018-01-07 17:03:56 +01001522 } else if (use_browser == 0 && !quiet &&
1523 !report.stats_mode && !report.tasks_mode) {
Jiri Olsa5cfe2c82013-12-09 11:02:49 +01001524 fputs("# To display the perf.data header info, please use --header/--header-only options.\n#\n",
1525 stdout);
1526 }
1527
Arnaldo Carvalho de Meloef7b93a2010-05-11 23:18:06 -03001528 /*
Arnaldo Carvalho de Melo6692c262013-03-28 11:34:10 -03001529 * Only in the TUI browser we are doing integrated annotation,
Arnaldo Carvalho de Meloef7b93a2010-05-11 23:18:06 -03001530 * so don't allocate extra space that won't be used in the stdio
1531 * implementation.
1532 */
Jin Yao6f7164f2019-11-07 15:47:17 +08001533 if (ui__has_annotation() || report.symbol_ipc ||
1534 report.total_cycles_mode) {
Arnaldo Carvalho de Melob01141f2016-08-25 16:09:21 -03001535 ret = symbol__annotation_init();
1536 if (ret < 0)
1537 goto error;
Arnaldo Carvalho de Melo80d50ca2010-08-05 19:28:27 -03001538 /*
1539 * For searching by name on the "Browse map details".
1540 * providing it only in verbose mode not to bloat too
1541 * much struct symbol.
1542 */
Namhyung Kimbb963e12017-02-17 17:17:38 +09001543 if (verbose > 0) {
Arnaldo Carvalho de Melo80d50ca2010-08-05 19:28:27 -03001544 /*
1545 * XXX: Need to provide a less kludgy way to ask for
1546 * more space per symbol, the u32 is for the index on
1547 * the ui browser.
1548 * See symbol__browser_index.
1549 */
1550 symbol_conf.priv_size += sizeof(u32);
1551 symbol_conf.sort_by_name = true;
1552 }
Ravi Bangoria73840832020-02-13 12:13:03 +05301553 annotation_config__init(&report.annotation_opts);
Arnaldo Carvalho de Melo80d50ca2010-08-05 19:28:27 -03001554 }
Arnaldo Carvalho de Melo655000e2009-12-15 20:04:40 -02001555
Namhyung Kim0a7e6d12014-08-12 15:40:45 +09001556 if (symbol__init(&session->header.env) < 0)
Stephane Eranian993ac882012-03-08 23:47:47 +01001557 goto error;
Ingo Molnar53cb8bc2009-05-26 09:17:18 +02001558
Jin Yao284c4e12019-03-01 18:13:06 +08001559 if (report.time_str) {
1560 ret = perf_time__parse_for_ranges(report.time_str, session,
1561 &report.ptime_range,
1562 &report.range_size,
1563 &report.range_num);
1564 if (ret < 0)
Jin Yao0a3cc3a2018-01-10 23:00:32 +08001565 goto error;
Adrian Hunter4885c902019-06-04 16:00:01 +03001566
1567 itrace_synth_opts__set_time_range(&itrace_synth_opts,
1568 report.ptime_range,
1569 report.range_num);
David Ahern46690a82016-11-29 10:15:46 -07001570 }
1571
Wang YanQingea85ab22018-03-08 11:28:50 +08001572 if (session->tevent.pevent &&
Tzvetomir Stoyanov (VMware)ece2a4f2018-08-08 14:02:55 -04001573 tep_set_function_resolver(session->tevent.pevent,
1574 machine__resolve_kernel_addr,
1575 &session->machines.host) < 0) {
Wang YanQingea85ab22018-03-08 11:28:50 +08001576 pr_err("%s: failed to set libtraceevent function resolver\n",
1577 __func__);
1578 return -1;
1579 }
1580
Namhyung Kim08e71542013-04-03 21:26:19 +09001581 sort__setup_elide(stdout);
Arnaldo Carvalho de Melo25903402009-06-30 19:01:20 -03001582
Stephane Eranian993ac882012-03-08 23:47:47 +01001583 ret = __cmd_report(&report);
Jin Yao5e3b8102020-02-20 09:36:15 +08001584 if (ret == K_SWITCH_INPUT_DATA || ret == K_RELOAD) {
Feng Tangad0de092013-02-03 14:38:21 +08001585 perf_session__delete(session);
Jin Yao0feba172019-12-20 09:37:19 +08001586 last_key = K_SWITCH_INPUT_DATA;
Feng Tangad0de092013-02-03 14:38:21 +08001587 goto repeat;
1588 } else
1589 ret = 0;
1590
Stephane Eranian993ac882012-03-08 23:47:47 +01001591error:
Adrian Hunter4885c902019-06-04 16:00:01 +03001592 if (report.ptime_range) {
1593 itrace_synth_opts__clear_time_range(&itrace_synth_opts);
Jin Yao284c4e12019-03-01 18:13:06 +08001594 zfree(&report.ptime_range);
Adrian Hunter4885c902019-06-04 16:00:01 +03001595 }
Jin Yao6f7164f2019-11-07 15:47:17 +08001596
Jin Yaocca0cc72020-02-02 22:16:54 +08001597 if (report.block_reports) {
1598 block_info__free_report(report.block_reports,
1599 report.nr_block_reports);
1600 report.block_reports = NULL;
1601 }
Jin Yao6f7164f2019-11-07 15:47:17 +08001602
Alexey Budankovcb62c6f2019-03-18 20:45:11 +03001603 zstd_fini(&(session->zstd_data));
Stephane Eranian993ac882012-03-08 23:47:47 +01001604 perf_session__delete(session);
1605 return ret;
Ingo Molnar53cb8bc2009-05-26 09:17:18 +02001606}