projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
perf intel-pt: Fix displaying PEBS-via-PT with registers
[linux-block.git] / tools / perf / builtin-script.c
CommitLineData
b2441318 1// SPDX-License-Identifier: GPL-2.0
5f9c39dc
FW		 2#include "builtin.h"
3
0f31c019 4#include "util/counts.h"
b7eead86 5#include "util/debug.h"
4a3cec84 6#include "util/dso.h"
4b6ab94e 7#include <subcmd/exec-cmd.h>
b7eead86 8#include "util/header.h"
4b6ab94e 9#include <subcmd/parse-options.h>
fc36f948 10#include "util/perf_regs.h"
b7eead86 11#include "util/session.h"
45694aa7 12#include "util/tool.h"
1101f69a 13#include "util/map.h"
97b9d866 14#include "util/srcline.h"
5f9c39dc
FW		 15#include "util/symbol.h"
16#include "util/thread.h"
cf72344d 17#include "util/trace-event.h"
1424dc96
DA		 18#include "util/evlist.h"
19#include "util/evsel.h"
ca125277 20#include "util/evsel_fprintf.h"
d2360442 21#include "util/evswitch.h"
36385be5 22#include "util/sort.h"
f5fc1412 23#include "util/data.h"
7a680eb9 24#include "util/auxtrace.h"
cfc8874a
JO		 25#include "util/cpumap.h"
26#include "util/thread_map.h"
27#include "util/stat.h"
4bd1bef8 28#include "util/color.h"
a067558e 29#include "util/string2.h"
e216708d 30#include "util/thread-stack.h"
a91f4c47 31#include "util/time-utils.h"
06c3f2aa 32#include "util/path.h"
fa0d9846 33#include "ui/ui.h"
fea01392 34#include "print_binary.h"
3ab481a1 35#include "archinsn.h"
5d67be97 36#include <linux/bitmap.h>
877a7a11 37#include <linux/kernel.h>
6125cc8d 38#include <linux/stringify.h>
bd48c63e 39#include <linux/time64.h>
7f7c536f 40#include <linux/zalloc.h>
3ab481a1 41#include <sys/utsname.h>
cfc8874a 42#include "asm/bug.h"
c19ac912 43#include "util/mem-events.h"
48d02a1d 44#include "util/dump-insn.h"
76b31a29 45#include <dirent.h>
a43783ae 46#include <errno.h>
fd20e811 47#include <inttypes.h>
9607ad3a 48#include <signal.h>
391e4206 49#include <sys/param.h>
7a8ef4c4
ACM		 50#include <sys/types.h>
51#include <sys/stat.h>
bafae98e 52#include <fcntl.h>
7a8ef4c4 53#include <unistd.h>
b585ebdb 54#include <subcmd/pager.h>
453fa030 55#include <perf/evlist.h>
6ef81c55 56#include <linux/err.h>
aeb00b1a 57#include "util/record.h"
2da39f1c 58#include "util/util.h"
c1a604df 59#include "perf.h"
5f9c39dc 60
3052ba56 61#include <linux/ctype.h>
3d689ed6 62
956ffd02
TZ		 63static char const *script_name;
64static char const *generate_script_lang;
90b10f47 65static bool reltime;
26567ed7 66static bool deltatime;
90b10f47 67static u64 initial_time;
26567ed7 68static u64 previous_time;
ffabd99e 69static bool debug_mode;
e1889d75 70static u64 last_timestamp;
6fcf7ddb 71static u64 nr_unordered;
c0230b2b 72static bool no_callchain;
47390ae2 73static bool latency_format;
317df650 74static bool system_wide;
400ea6d3 75static bool print_flags;
5d67be97
AB		 76static const char *cpu_list;
77static DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
91a2c3d5 78static struct perf_stat_config stat_config;
48d02a1d 79static int max_blocks;
3ab481a1 80static bool native_arch;
956ffd02 81
44cbe729 82unsigned int scripting_max_stack = PERF_MAX_STACK_DEPTH;
03cd1fed 83
745f43e3
DA		 84enum perf_output_field {
85 PERF_OUTPUT_COMM = 1U << 0,
86 PERF_OUTPUT_TID = 1U << 1,
87 PERF_OUTPUT_PID = 1U << 2,
88 PERF_OUTPUT_TIME = 1U << 3,
89 PERF_OUTPUT_CPU = 1U << 4,
90 PERF_OUTPUT_EVNAME = 1U << 5,
91 PERF_OUTPUT_TRACE = 1U << 6,
787bef17
DA		 92 PERF_OUTPUT_IP = 1U << 7,
93 PERF_OUTPUT_SYM = 1U << 8,
610723f2 94 PERF_OUTPUT_DSO = 1U << 9,
7cec0922 95 PERF_OUTPUT_ADDR = 1U << 10,
a978f2ab 96 PERF_OUTPUT_SYMOFFSET = 1U << 11,
cc8fae1d 97 PERF_OUTPUT_SRCLINE = 1U << 12,
535aeaae 98 PERF_OUTPUT_PERIOD = 1U << 13,
fc36f948 99 PERF_OUTPUT_IREGS = 1U << 14,
dc323ce8
SE		 100 PERF_OUTPUT_BRSTACK = 1U << 15,
101 PERF_OUTPUT_BRSTACKSYM = 1U << 16,
94ddddfa
JO		 102 PERF_OUTPUT_DATA_SRC = 1U << 17,
103 PERF_OUTPUT_WEIGHT = 1U << 18,
30372f04 104 PERF_OUTPUT_BPF_OUTPUT = 1U << 19,
e216708d 105 PERF_OUTPUT_CALLINDENT = 1U << 20,
224e2c97
AK		 106 PERF_OUTPUT_INSN = 1U << 21,
107 PERF_OUTPUT_INSNLEN = 1U << 22,
48d02a1d 108 PERF_OUTPUT_BRSTACKINSN = 1U << 23,
106dacd8 109 PERF_OUTPUT_BRSTACKOFF = 1U << 24,
47e78084 110 PERF_OUTPUT_SYNTH = 1U << 25,
49d58f04 111 PERF_OUTPUT_PHYS_ADDR = 1U << 26,
b1491ace 112 PERF_OUTPUT_UREGS = 1U << 27,
4bd1bef8 113 PERF_OUTPUT_METRIC = 1U << 28,
28a0b398 114 PERF_OUTPUT_MISC = 1U << 29,
dd2e18e9 115 PERF_OUTPUT_SRCCODE = 1U << 30,
68fb45bf 116 PERF_OUTPUT_IPC = 1U << 31,
745f43e3
DA		 117};
118
119struct output_option {
120 const char *str;
121 enum perf_output_field field;
122} all_output_options[] = {
123 {.str = "comm", .field = PERF_OUTPUT_COMM},
124 {.str = "tid", .field = PERF_OUTPUT_TID},
125 {.str = "pid", .field = PERF_OUTPUT_PID},
126 {.str = "time", .field = PERF_OUTPUT_TIME},
127 {.str = "cpu", .field = PERF_OUTPUT_CPU},
128 {.str = "event", .field = PERF_OUTPUT_EVNAME},
129 {.str = "trace", .field = PERF_OUTPUT_TRACE},
787bef17 130 {.str = "ip", .field = PERF_OUTPUT_IP},
c0230b2b 131 {.str = "sym", .field = PERF_OUTPUT_SYM},
610723f2 132 {.str = "dso", .field = PERF_OUTPUT_DSO},
7cec0922 133 {.str = "addr", .field = PERF_OUTPUT_ADDR},
a978f2ab 134 {.str = "symoff", .field = PERF_OUTPUT_SYMOFFSET},
cc8fae1d 135 {.str = "srcline", .field = PERF_OUTPUT_SRCLINE},
535aeaae 136 {.str = "period", .field = PERF_OUTPUT_PERIOD},
fc36f948 137 {.str = "iregs", .field = PERF_OUTPUT_IREGS},
b1491ace 138 {.str = "uregs", .field = PERF_OUTPUT_UREGS},
dc323ce8
SE		 139 {.str = "brstack", .field = PERF_OUTPUT_BRSTACK},
140 {.str = "brstacksym", .field = PERF_OUTPUT_BRSTACKSYM},
94ddddfa
JO		 141 {.str = "data_src", .field = PERF_OUTPUT_DATA_SRC},
142 {.str = "weight", .field = PERF_OUTPUT_WEIGHT},
30372f04 143 {.str = "bpf-output", .field = PERF_OUTPUT_BPF_OUTPUT},
e216708d 144 {.str = "callindent", .field = PERF_OUTPUT_CALLINDENT},
224e2c97
AK		 145 {.str = "insn", .field = PERF_OUTPUT_INSN},
146 {.str = "insnlen", .field = PERF_OUTPUT_INSNLEN},
48d02a1d 147 {.str = "brstackinsn", .field = PERF_OUTPUT_BRSTACKINSN},
106dacd8 148 {.str = "brstackoff", .field = PERF_OUTPUT_BRSTACKOFF},
47e78084 149 {.str = "synth", .field = PERF_OUTPUT_SYNTH},
49d58f04 150 {.str = "phys_addr", .field = PERF_OUTPUT_PHYS_ADDR},
4bd1bef8 151 {.str = "metric", .field = PERF_OUTPUT_METRIC},
28a0b398 152 {.str = "misc", .field = PERF_OUTPUT_MISC},
dd2e18e9 153 {.str = "srccode", .field = PERF_OUTPUT_SRCCODE},
68fb45bf 154 {.str = "ipc", .field = PERF_OUTPUT_IPC},
745f43e3
DA		 155};
156
1405720d
AH		 157enum {
158 OUTPUT_TYPE_SYNTH = PERF_TYPE_MAX,
159 OUTPUT_TYPE_MAX
160};
161
745f43e3 162/* default set to maintain compatibility with current format */
2c9e45f7
DA		 163static struct {
164 bool user_set;
9cbdb702 165 bool wildcard_set;
a6ffaf91 166 unsigned int print_ip_opts;
2c9e45f7
DA		 167 u64 fields;
168 u64 invalid_fields;
4b6ac811 169 u64 user_set_fields;
b5164085 170 u64 user_unset_fields;
1405720d 171} output[OUTPUT_TYPE_MAX] = {
2c9e45f7
DA		 172
173 [PERF_TYPE_HARDWARE] = {
174 .user_set = false,
175
176 .fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
177 PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
787bef17 178 PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
7903a708
SD		 179 PERF_OUTPUT_SYM | PERF_OUTPUT_SYMOFFSET |
180 PERF_OUTPUT_DSO | PERF_OUTPUT_PERIOD,
2c9e45f7 181
30372f04 182 .invalid_fields = PERF_OUTPUT_TRACE | PERF_OUTPUT_BPF_OUTPUT,
2c9e45f7
DA		 183 },
184
185 [PERF_TYPE_SOFTWARE] = {
186 .user_set = false,
187
188 .fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
189 PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
787bef17 190 PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
7903a708
SD		 191 PERF_OUTPUT_SYM | PERF_OUTPUT_SYMOFFSET |
192 PERF_OUTPUT_DSO | PERF_OUTPUT_PERIOD |
193 PERF_OUTPUT_BPF_OUTPUT,
2c9e45f7
DA		 194
195 .invalid_fields = PERF_OUTPUT_TRACE,
196 },
197
198 [PERF_TYPE_TRACEPOINT] = {
199 .user_set = false,
200
201 .fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
202 PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
30372f04 203 PERF_OUTPUT_EVNAME | PERF_OUTPUT_TRACE
2c9e45f7 204 },
0817a6a3 205
fad76d43
ST		 206 [PERF_TYPE_HW_CACHE] = {
207 .user_set = false,
208
209 .fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
210 PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
211 PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
212 PERF_OUTPUT_SYM | PERF_OUTPUT_SYMOFFSET |
213 PERF_OUTPUT_DSO | PERF_OUTPUT_PERIOD,
214
215 .invalid_fields = PERF_OUTPUT_TRACE | PERF_OUTPUT_BPF_OUTPUT,
216 },
217
0817a6a3
AS		 218 [PERF_TYPE_RAW] = {
219 .user_set = false,
220
221 .fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
222 PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
787bef17 223 PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
7903a708
SD		 224 PERF_OUTPUT_SYM | PERF_OUTPUT_SYMOFFSET |
225 PERF_OUTPUT_DSO | PERF_OUTPUT_PERIOD |
226 PERF_OUTPUT_ADDR | PERF_OUTPUT_DATA_SRC |
227 PERF_OUTPUT_WEIGHT | PERF_OUTPUT_PHYS_ADDR,
0817a6a3 228
30372f04 229 .invalid_fields = PERF_OUTPUT_TRACE | PERF_OUTPUT_BPF_OUTPUT,
0817a6a3 230 },
27cfef00
WN		 231
232 [PERF_TYPE_BREAKPOINT] = {
233 .user_set = false,
234
235 .fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
236 PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
237 PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
7903a708
SD		 238 PERF_OUTPUT_SYM | PERF_OUTPUT_SYMOFFSET |
239 PERF_OUTPUT_DSO | PERF_OUTPUT_PERIOD,
27cfef00 240
30372f04 241 .invalid_fields = PERF_OUTPUT_TRACE | PERF_OUTPUT_BPF_OUTPUT,
27cfef00 242 },
1405720d
AH		 243
244 [OUTPUT_TYPE_SYNTH] = {
245 .user_set = false,
246
247 .fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
248 PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
249 PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
7903a708
SD		 250 PERF_OUTPUT_SYM | PERF_OUTPUT_SYMOFFSET |
251 PERF_OUTPUT_DSO | PERF_OUTPUT_SYNTH,
1405720d
AH		 252
253 .invalid_fields = PERF_OUTPUT_TRACE | PERF_OUTPUT_BPF_OUTPUT,
254 },
1424dc96 255};
745f43e3 256
32dcd021 257struct evsel_script {
642ee1c6
ACM		 258 char *filename;
259 FILE *fp;
260 u64 samples;
4bd1bef8
AK		 261 /* For metric output */
262 u64 val;
263 int gnum;
642ee1c6
ACM		 264};
265
32dcd021 266static inline struct evsel_script *evsel_script(struct evsel *evsel)
4bd1bef8 267{
32dcd021 268 return (struct evsel_script *)evsel->priv;
4bd1bef8
AK		 269}
270
32dcd021 271static struct evsel_script *perf_evsel_script__new(struct evsel *evsel,
8ceb41d7 272 struct perf_data *data)
642ee1c6 273{
32dcd021 274 struct evsel_script *es = zalloc(sizeof(*es));
642ee1c6
ACM		 275
276 if (es != NULL) {
8ab2e96d 277 if (asprintf(&es->filename, "%s.%s.dump", data->file.path, evsel__name(evsel)) < 0)
642ee1c6
ACM		 278 goto out_free;
279 es->fp = fopen(es->filename, "w");
280 if (es->fp == NULL)
281 goto out_free_filename;
642ee1c6
ACM		 282 }
283
284 return es;
285out_free_filename:
286 zfree(&es->filename);
287out_free:
288 free(es);
289 return NULL;
290}
291
32dcd021 292static void perf_evsel_script__delete(struct evsel_script *es)
642ee1c6
ACM		 293{
294 zfree(&es->filename);
295 fclose(es->fp);
296 es->fp = NULL;
297 free(es);
298}
299
32dcd021 300static int perf_evsel_script__fprintf(struct evsel_script *es, FILE *fp)
642ee1c6
ACM		 301{
302 struct stat st;
303
304 fstat(fileno(es->fp), &st);
305 return fprintf(fp, "[ perf script: Wrote %.3f MB %s (%" PRIu64 " samples) ]\n",
306 st.st_size / 1024.0 / 1024.0, es->filename, es->samples);
307}
308
1405720d
AH		 309static inline int output_type(unsigned int type)
310{
311 switch (type) {
312 case PERF_TYPE_SYNTH:
313 return OUTPUT_TYPE_SYNTH;
314 default:
315 return type;
316 }
317}
318
319static inline unsigned int attr_type(unsigned int type)
320{
321 switch (type) {
322 case OUTPUT_TYPE_SYNTH:
323 return PERF_TYPE_SYNTH;
324 default:
325 return type;
326 }
327}
328
2c9e45f7
DA		 329static bool output_set_by_user(void)
330{
331 int j;
1405720d 332 for (j = 0; j < OUTPUT_TYPE_MAX; ++j) {
2c9e45f7
DA		 333 if (output[j].user_set)
334 return true;
335 }
336 return false;
337}
745f43e3 338
9cbdb702
DA		 339static const char *output_field2str(enum perf_output_field field)
340{
341 int i, imax = ARRAY_SIZE(all_output_options);
342 const char *str = "";
343
344 for (i = 0; i < imax; ++i) {
345 if (all_output_options[i].field == field) {
346 str = all_output_options[i].str;
347 break;
348 }
349 }
350 return str;
351}
352
1405720d 353#define PRINT_FIELD(x) (output[output_type(attr->type)].fields & PERF_OUTPUT_##x)
1424dc96 354
ec98b6df
ACM		 355static int evsel__do_check_stype(struct evsel *evsel, u64 sample_type, const char *sample_msg,
356 enum perf_output_field field, bool allow_user_set)
1424dc96 357{
1fc632ce 358 struct perf_event_attr *attr = &evsel->core.attr;
1405720d 359 int type = output_type(attr->type);
9cbdb702
DA		 360 const char *evname;
361
362 if (attr->sample_type & sample_type)
363 return 0;
364
4b6ac811 365 if (output[type].user_set_fields & field) {
6d5cdd64
AH		 366 if (allow_user_set)
367 return 0;
8ab2e96d 368 evname = evsel__name(evsel);
9cbdb702
DA		 369 pr_err("Samples for '%s' event do not have %s attribute set. "
370 "Cannot print '%s' field.\n",
371 evname, sample_msg, output_field2str(field));
372 return -1;
373 }
374
375 /* user did not ask for it explicitly so remove from the default list */
376 output[type].fields &= ~field;
8ab2e96d 377 evname = evsel__name(evsel);
9cbdb702
DA		 378 pr_debug("Samples for '%s' event do not have %s attribute set. "
379 "Skipping '%s' field.\n",
380 evname, sample_msg, output_field2str(field));
381
382 return 0;
383}
384
ec98b6df
ACM		 385static int evsel__check_stype(struct evsel *evsel, u64 sample_type, const char *sample_msg,
386 enum perf_output_field field)
6d5cdd64 387{
ec98b6df 388 return evsel__do_check_stype(evsel, sample_type, sample_msg, field, false);
6d5cdd64
AH		 389}
390
ec98b6df 391static int perf_evsel__check_attr(struct evsel *evsel, struct perf_session *session)
9cbdb702 392{
1fc632ce 393 struct perf_event_attr *attr = &evsel->core.attr;
6d5cdd64
AH		 394 bool allow_user_set;
395
e099eba8
JO		 396 if (perf_header__has_feat(&session->header, HEADER_STAT))
397 return 0;
398
6d5cdd64
AH		 399 allow_user_set = perf_header__has_feat(&session->header,
400 HEADER_AUXTRACE);
9cbdb702 401
1424dc96 402 if (PRINT_FIELD(TRACE) &&
ec98b6df 403 !perf_session__has_traces(session, "record -R"))
1424dc96
DA		 404 return -EINVAL;
405
787bef17 406 if (PRINT_FIELD(IP)) {
ec98b6df 407 if (evsel__check_stype(evsel, PERF_SAMPLE_IP, "IP", PERF_OUTPUT_IP))
1424dc96 408 return -EINVAL;
1424dc96 409 }
7cec0922
DA		 410
411 if (PRINT_FIELD(ADDR) &&
ec98b6df 412 evsel__do_check_stype(evsel, PERF_SAMPLE_ADDR, "ADDR", PERF_OUTPUT_ADDR, allow_user_set))
7cec0922
DA		 413 return -EINVAL;
414
94ddddfa 415 if (PRINT_FIELD(DATA_SRC) &&
ec98b6df 416 evsel__check_stype(evsel, PERF_SAMPLE_DATA_SRC, "DATA_SRC", PERF_OUTPUT_DATA_SRC))
94ddddfa
JO		 417 return -EINVAL;
418
419 if (PRINT_FIELD(WEIGHT) &&
ec98b6df 420 evsel__check_stype(evsel, PERF_SAMPLE_WEIGHT, "WEIGHT", PERF_OUTPUT_WEIGHT))
94ddddfa
JO		 421 return -EINVAL;
422
37fed3de 423 if (PRINT_FIELD(SYM) &&
ec98b6df 424 !(evsel->core.attr.sample_type & (PERF_SAMPLE_IP|PERF_SAMPLE_ADDR))) {
7cec0922 425 pr_err("Display of symbols requested but neither sample IP nor "
37fed3de 426 "sample address\navailable. Hence, no addresses to convert "
7cec0922 427 "to symbols.\n");
787bef17
DA		 428 return -EINVAL;
429 }
a978f2ab
AN		 430 if (PRINT_FIELD(SYMOFFSET) && !PRINT_FIELD(SYM)) {
431 pr_err("Display of offsets requested but symbol is not"
432 "selected.\n");
433 return -EINVAL;
434 }
37fed3de 435 if (PRINT_FIELD(DSO) &&
ec98b6df 436 !(evsel->core.attr.sample_type & (PERF_SAMPLE_IP|PERF_SAMPLE_ADDR))) {
37fed3de 437 pr_err("Display of DSO requested but no address to convert.\n");
610723f2
DA		 438 return -EINVAL;
439 }
dd2e18e9 440 if ((PRINT_FIELD(SRCLINE) || PRINT_FIELD(SRCCODE)) && !PRINT_FIELD(IP)) {
cc8fae1d
AH		 441 pr_err("Display of source line number requested but sample IP is not\n"
442 "selected. Hence, no address to lookup the source line number.\n");
443 return -EINVAL;
444 }
0cd032d3 445 if (PRINT_FIELD(BRSTACKINSN) && !allow_user_set &&
48d02a1d
AK		 446 !(perf_evlist__combined_branch_type(session->evlist) &
447 PERF_SAMPLE_BRANCH_ANY)) {
448 pr_err("Display of branch stack assembler requested, but non all-branch filter set\n"
449 "Hint: run 'perf record -b ...'\n");
450 return -EINVAL;
451 }
1424dc96 452 if ((PRINT_FIELD(PID) || PRINT_FIELD(TID)) &&
ec98b6df 453 evsel__check_stype(evsel, PERF_SAMPLE_TID, "TID", PERF_OUTPUT_TID|PERF_OUTPUT_PID))
1424dc96 454 return -EINVAL;
1424dc96
DA		 455
456 if (PRINT_FIELD(TIME) &&
ec98b6df 457 evsel__check_stype(evsel, PERF_SAMPLE_TIME, "TIME", PERF_OUTPUT_TIME))
1424dc96 458 return -EINVAL;
1424dc96
DA		 459
460 if (PRINT_FIELD(CPU) &&
ec98b6df 461 evsel__do_check_stype(evsel, PERF_SAMPLE_CPU, "CPU", PERF_OUTPUT_CPU, allow_user_set))
1424dc96 462 return -EINVAL;
9cbdb702 463
fc36f948 464 if (PRINT_FIELD(IREGS) &&
add07ccd 465 evsel__do_check_stype(evsel, PERF_SAMPLE_REGS_INTR, "IREGS", PERF_OUTPUT_IREGS, allow_user_set))
fc36f948
SE		 466 return -EINVAL;
467
b1491ace 468 if (PRINT_FIELD(UREGS) &&
ec98b6df 469 evsel__check_stype(evsel, PERF_SAMPLE_REGS_USER, "UREGS", PERF_OUTPUT_UREGS))
b1491ace
AK		 470 return -EINVAL;
471
49d58f04 472 if (PRINT_FIELD(PHYS_ADDR) &&
ec98b6df 473 evsel__check_stype(evsel, PERF_SAMPLE_PHYS_ADDR, "PHYS_ADDR", PERF_OUTPUT_PHYS_ADDR))
49d58f04
KL		 474 return -EINVAL;
475
9cbdb702
DA		 476 return 0;
477}
478
7ea95727
AH		 479static void set_print_ip_opts(struct perf_event_attr *attr)
480{
1405720d 481 unsigned int type = output_type(attr->type);
7ea95727
AH		 482
483 output[type].print_ip_opts = 0;
484 if (PRINT_FIELD(IP))
e20ab86e 485 output[type].print_ip_opts |= EVSEL__PRINT_IP;
7ea95727
AH		 486
487 if (PRINT_FIELD(SYM))
e20ab86e 488 output[type].print_ip_opts |= EVSEL__PRINT_SYM;
7ea95727
AH		 489
490 if (PRINT_FIELD(DSO))
e20ab86e 491 output[type].print_ip_opts |= EVSEL__PRINT_DSO;
7ea95727
AH		 492
493 if (PRINT_FIELD(SYMOFFSET))
e20ab86e 494 output[type].print_ip_opts |= EVSEL__PRINT_SYMOFFSET;
cc8fae1d
AH		 495
496 if (PRINT_FIELD(SRCLINE))
e20ab86e 497 output[type].print_ip_opts |= EVSEL__PRINT_SRCLINE;
7ea95727
AH		 498}
499
9cbdb702
DA		 500/*
501 * verify all user requested events exist and the samples
502 * have the expected data
503 */
504static int perf_session__check_output_opt(struct perf_session *session)
505{
40f20e50 506 unsigned int j;
32dcd021 507 struct evsel *evsel;
9cbdb702 508
1405720d
AH		 509 for (j = 0; j < OUTPUT_TYPE_MAX; ++j) {
510 evsel = perf_session__find_first_evtype(session, attr_type(j));
9cbdb702
DA		 511
512 /*
513 * even if fields is set to 0 (ie., show nothing) event must
514 * exist if user explicitly includes it on the command line
515 */
1405720d
AH		 516 if (!evsel && output[j].user_set && !output[j].wildcard_set &&
517 j != OUTPUT_TYPE_SYNTH) {
9cbdb702 518 pr_err("%s events do not exist. "
701516ae 519 "Remove corresponding -F option to proceed.\n",
9cbdb702
DA		 520 event_type(j));
521 return -1;
522 }
523
524 if (evsel && output[j].fields &&
525 perf_evsel__check_attr(evsel, session))
526 return -1;
a6ffaf91
DA		 527
528 if (evsel == NULL)
529 continue;
530
1fc632ce 531 set_print_ip_opts(&evsel->core.attr);
1424dc96
DA		 532 }
533
98526ee7
AH		 534 if (!no_callchain) {
535 bool use_callchain = false;
71ac899b 536 bool not_pipe = false;
98526ee7 537
e5cadb93 538 evlist__for_each_entry(session->evlist, evsel) {
71ac899b 539 not_pipe = true;
27de9b2b 540 if (evsel__has_callchain(evsel)) {
98526ee7
AH		 541 use_callchain = true;
542 break;
543 }
544 }
71ac899b 545 if (not_pipe && !use_callchain)
98526ee7
AH		 546 symbol_conf.use_callchain = false;
547 }
548
80b8b496
DA		 549 /*
550 * set default for tracepoints to print symbols only
551 * if callchains are present
552 */
553 if (symbol_conf.use_callchain &&
554 !output[PERF_TYPE_TRACEPOINT].user_set) {
80b8b496 555 j = PERF_TYPE_TRACEPOINT;
80b8b496 556
e5cadb93 557 evlist__for_each_entry(session->evlist, evsel) {
1fc632ce 558 if (evsel->core.attr.type != j)
40f20e50
HK		 559 continue;
560
27de9b2b 561 if (evsel__has_callchain(evsel)) {
40f20e50
HK		 562 output[j].fields |= PERF_OUTPUT_IP;
563 output[j].fields |= PERF_OUTPUT_SYM;
7903a708 564 output[j].fields |= PERF_OUTPUT_SYMOFFSET;
40f20e50 565 output[j].fields |= PERF_OUTPUT_DSO;
1fc632ce 566 set_print_ip_opts(&evsel->core.attr);
40f20e50
HK		 567 goto out;
568 }
80b8b496
DA		 569 }
570 }
571
572out:
1424dc96
DA		 573 return 0;
574}
745f43e3 575
9add8fe8
MW		 576static int perf_sample__fprintf_regs(struct regs_dump *regs, uint64_t mask,
577 FILE *fp
578)
b1491ace 579{
b1491ace 580 unsigned i = 0, r;
a1a58707 581 int printed = 0;
b1491ace
AK		 582
583 if (!regs || !regs->regs)
a1a58707 584 return 0;
b1491ace 585
a1a58707 586 printed += fprintf(fp, " ABI:%" PRIu64 " ", regs->abi);
b1491ace
AK		 587
588 for_each_set_bit(r, (unsigned long *) &mask, sizeof(mask) * 8) {
589 u64 val = regs->regs[i++];
a1a58707 590 printed += fprintf(fp, "%5s:0x%"PRIx64" ", perf_reg_name(r), val);
b1491ace 591 }
a1a58707
ACM		 592
593 return printed;
b1491ace
AK		 594}
595
9add8fe8
MW		 596static int perf_sample__fprintf_iregs(struct perf_sample *sample,
597 struct perf_event_attr *attr, FILE *fp)
598{
599 return perf_sample__fprintf_regs(&sample->intr_regs,
600 attr->sample_regs_intr, fp);
601}
602
603static int perf_sample__fprintf_uregs(struct perf_sample *sample,
604 struct perf_event_attr *attr, FILE *fp)
605{
606 return perf_sample__fprintf_regs(&sample->user_regs,
607 attr->sample_regs_user, fp);
608}
609
a1a58707
ACM		 610static int perf_sample__fprintf_start(struct perf_sample *sample,
611 struct thread *thread,
32dcd021 612 struct evsel *evsel,
28a0b398 613 u32 type, FILE *fp)
c70c94b4 614{
1fc632ce 615 struct perf_event_attr *attr = &evsel->core.attr;
c70c94b4 616 unsigned long secs;
745f43e3 617 unsigned long long nsecs;
a1a58707 618 int printed = 0;
745f43e3
DA		 619
620 if (PRINT_FIELD(COMM)) {
621 if (latency_format)
a1a58707 622 printed += fprintf(fp, "%8.8s ", thread__comm_str(thread));
b879833c 623 else if (PRINT_FIELD(IP) && evsel__has_callchain(evsel) && symbol_conf.use_callchain)
a1a58707 624 printed += fprintf(fp, "%s ", thread__comm_str(thread));
745f43e3 625 else
a1a58707 626 printed += fprintf(fp, "%16s ", thread__comm_str(thread));
745f43e3 627 }
c70c94b4 628
745f43e3 629 if (PRINT_FIELD(PID) && PRINT_FIELD(TID))
a1a58707 630 printed += fprintf(fp, "%5d/%-5d ", sample->pid, sample->tid);
745f43e3 631 else if (PRINT_FIELD(PID))
a1a58707 632 printed += fprintf(fp, "%5d ", sample->pid);
745f43e3 633 else if (PRINT_FIELD(TID))
a1a58707 634 printed += fprintf(fp, "%5d ", sample->tid);
745f43e3
DA		 635
636 if (PRINT_FIELD(CPU)) {
637 if (latency_format)
a1a58707 638 printed += fprintf(fp, "%3d ", sample->cpu);
745f43e3 639 else
a1a58707 640 printed += fprintf(fp, "[%03d] ", sample->cpu);
745f43e3 641 }
c70c94b4 642
28a0b398
JO		 643 if (PRINT_FIELD(MISC)) {
644 int ret = 0;
645
646 #define has(m) \
647 (sample->misc & PERF_RECORD_MISC_##m) == PERF_RECORD_MISC_##m
648
649 if (has(KERNEL))
650 ret += fprintf(fp, "K");
651 if (has(USER))
652 ret += fprintf(fp, "U");
653 if (has(HYPERVISOR))
654 ret += fprintf(fp, "H");
655 if (has(GUEST_KERNEL))
656 ret += fprintf(fp, "G");
657 if (has(GUEST_USER))
658 ret += fprintf(fp, "g");
659
660 switch (type) {
661 case PERF_RECORD_MMAP:
662 case PERF_RECORD_MMAP2:
663 if (has(MMAP_DATA))
664 ret += fprintf(fp, "M");
665 break;
666 case PERF_RECORD_COMM:
667 if (has(COMM_EXEC))
668 ret += fprintf(fp, "E");
669 break;
670 case PERF_RECORD_SWITCH:
671 case PERF_RECORD_SWITCH_CPU_WIDE:
bf30cc18 672 if (has(SWITCH_OUT)) {
28a0b398 673 ret += fprintf(fp, "S");
bf30cc18
AB		 674 if (sample->misc & PERF_RECORD_MISC_SWITCH_OUT_PREEMPT)
675 ret += fprintf(fp, "p");
676 }
28a0b398
JO		 677 default:
678 break;
679 }
680
681 #undef has
682
683 ret += fprintf(fp, "%*s", 6 - ret, " ");
684 printed += ret;
685 }
686
745f43e3 687 if (PRINT_FIELD(TIME)) {
90b10f47
AK		 688 u64 t = sample->time;
689 if (reltime) {
690 if (!initial_time)
691 initial_time = sample->time;
692 t = sample->time - initial_time;
26567ed7
HPP		 693 } else if (deltatime) {
694 if (previous_time)
695 t = sample->time - previous_time;
696 else {
697 t = 0;
698 }
699 previous_time = sample->time;
90b10f47
AK		 700 }
701 nsecs = t;
bd48c63e
ACM		 702 secs = nsecs / NSEC_PER_SEC;
703 nsecs -= secs * NSEC_PER_SEC;
99620a5d 704
52bab886 705 if (symbol_conf.nanosecs)
a1a58707 706 printed += fprintf(fp, "%5lu.%09llu: ", secs, nsecs);
99620a5d
NK		 707 else {
708 char sample_time[32];
90b10f47 709 timestamp__scnprintf_usec(t, sample_time, sizeof(sample_time));
a1a58707 710 printed += fprintf(fp, "%12s: ", sample_time);
99620a5d 711 }
745f43e3 712 }
a1a58707
ACM		 713
714 return printed;
c70c94b4
DA		 715}
716
dc323ce8
SE		 717static inline char
718mispred_str(struct branch_entry *br)
719{
720 if (!(br->flags.mispred || br->flags.predicted))
721 return '-';
722
723 return br->flags.predicted ? 'P' : 'M';
724}
725
a1a58707
ACM		 726static int perf_sample__fprintf_brstack(struct perf_sample *sample,
727 struct thread *thread,
728 struct perf_event_attr *attr, FILE *fp)
dc323ce8
SE		 729{
730 struct branch_stack *br = sample->branch_stack;
42bbabed 731 struct branch_entry *entries = perf_sample__branch_entries(sample);
55b9b508
MS		 732 struct addr_location alf, alt;
733 u64 i, from, to;
a1a58707 734 int printed = 0;
dc323ce8
SE		 735
736 if (!(br && br->nr))
a1a58707 737 return 0;
dc323ce8
SE		 738
739 for (i = 0; i < br->nr; i++) {
42bbabed
KL		 740 from = entries[i].from;
741 to = entries[i].to;
55b9b508
MS		 742
743 if (PRINT_FIELD(DSO)) {
744 memset(&alf, 0, sizeof(alf));
745 memset(&alt, 0, sizeof(alt));
692d0e63
AH		 746 thread__find_map_fb(thread, sample->cpumode, from, &alf);
747 thread__find_map_fb(thread, sample->cpumode, to, &alt);
55b9b508
MS		 748 }
749
a1a58707 750 printed += fprintf(fp, " 0x%"PRIx64, from);
55b9b508 751 if (PRINT_FIELD(DSO)) {
a1a58707
ACM		 752 printed += fprintf(fp, "(");
753 printed += map__fprintf_dsoname(alf.map, fp);
754 printed += fprintf(fp, ")");
55b9b508
MS		 755 }
756
a1a58707 757 printed += fprintf(fp, "/0x%"PRIx64, to);
55b9b508 758 if (PRINT_FIELD(DSO)) {
a1a58707
ACM		 759 printed += fprintf(fp, "(");
760 printed += map__fprintf_dsoname(alt.map, fp);
761 printed += fprintf(fp, ")");
55b9b508
MS		 762 }
763
a1a58707 764 printed += fprintf(fp, "/%c/%c/%c/%d ",
42bbabed
KL		 765 mispred_str(entries + i),
766 entries[i].flags.in_tx ? 'X' : '-',
767 entries[i].flags.abort ? 'A' : '-',
768 entries[i].flags.cycles);
dc323ce8 769 }
a1a58707
ACM		 770
771 return printed;
dc323ce8
SE		 772}
773
a1a58707
ACM		 774static int perf_sample__fprintf_brstacksym(struct perf_sample *sample,
775 struct thread *thread,
776 struct perf_event_attr *attr, FILE *fp)
dc323ce8
SE		 777{
778 struct branch_stack *br = sample->branch_stack;
42bbabed 779 struct branch_entry *entries = perf_sample__branch_entries(sample);
dc323ce8 780 struct addr_location alf, alt;
dc323ce8 781 u64 i, from, to;
a1a58707 782 int printed = 0;
dc323ce8
SE		 783
784 if (!(br && br->nr))
a1a58707 785 return 0;
dc323ce8
SE		 786
787 for (i = 0; i < br->nr; i++) {
788
789 memset(&alf, 0, sizeof(alf));
790 memset(&alt, 0, sizeof(alt));
42bbabed
KL		 791 from = entries[i].from;
792 to = entries[i].to;
dc323ce8 793
692d0e63
AH		 794 thread__find_symbol_fb(thread, sample->cpumode, from, &alf);
795 thread__find_symbol_fb(thread, sample->cpumode, to, &alt);
dc323ce8 796
a1a58707 797 printed += symbol__fprintf_symname_offs(alf.sym, &alf, fp);
55b9b508 798 if (PRINT_FIELD(DSO)) {
a1a58707
ACM		 799 printed += fprintf(fp, "(");
800 printed += map__fprintf_dsoname(alf.map, fp);
801 printed += fprintf(fp, ")");
55b9b508 802 }
a1a58707
ACM		 803 printed += fprintf(fp, "%c", '/');
804 printed += symbol__fprintf_symname_offs(alt.sym, &alt, fp);
55b9b508 805 if (PRINT_FIELD(DSO)) {
a1a58707
ACM		 806 printed += fprintf(fp, "(");
807 printed += map__fprintf_dsoname(alt.map, fp);
808 printed += fprintf(fp, ")");
55b9b508 809 }
a1a58707 810 printed += fprintf(fp, "/%c/%c/%c/%d ",
42bbabed
KL		 811 mispred_str(entries + i),
812 entries[i].flags.in_tx ? 'X' : '-',
813 entries[i].flags.abort ? 'A' : '-',
814 entries[i].flags.cycles);
dc323ce8 815 }
a1a58707
ACM		 816
817 return printed;
dc323ce8
SE		 818}
819
a1a58707
ACM		 820static int perf_sample__fprintf_brstackoff(struct perf_sample *sample,
821 struct thread *thread,
822 struct perf_event_attr *attr, FILE *fp)
106dacd8
MS		 823{
824 struct branch_stack *br = sample->branch_stack;
42bbabed 825 struct branch_entry *entries = perf_sample__branch_entries(sample);
106dacd8
MS		 826 struct addr_location alf, alt;
827 u64 i, from, to;
a1a58707 828 int printed = 0;
106dacd8
MS		 829
830 if (!(br && br->nr))
a1a58707 831 return 0;
106dacd8
MS		 832
833 for (i = 0; i < br->nr; i++) {
834
835 memset(&alf, 0, sizeof(alf));
836 memset(&alt, 0, sizeof(alt));
42bbabed
KL		 837 from = entries[i].from;
838 to = entries[i].to;
106dacd8 839
692d0e63 840 if (thread__find_map_fb(thread, sample->cpumode, from, &alf) &&
71a84b5a 841 !alf.map->dso->adjust_symbols)
106dacd8
MS		 842 from = map__map_ip(alf.map, from);
843
692d0e63 844 if (thread__find_map_fb(thread, sample->cpumode, to, &alt) &&
71a84b5a 845 !alt.map->dso->adjust_symbols)
106dacd8
MS		 846 to = map__map_ip(alt.map, to);
847
a1a58707 848 printed += fprintf(fp, " 0x%"PRIx64, from);
106dacd8 849 if (PRINT_FIELD(DSO)) {
a1a58707
ACM		 850 printed += fprintf(fp, "(");
851 printed += map__fprintf_dsoname(alf.map, fp);
852 printed += fprintf(fp, ")");
106dacd8 853 }
a1a58707 854 printed += fprintf(fp, "/0x%"PRIx64, to);
106dacd8 855 if (PRINT_FIELD(DSO)) {
a1a58707
ACM		 856 printed += fprintf(fp, "(");
857 printed += map__fprintf_dsoname(alt.map, fp);
858 printed += fprintf(fp, ")");
106dacd8 859 }
a1a58707 860 printed += fprintf(fp, "/%c/%c/%c/%d ",
42bbabed
KL		 861 mispred_str(entries + i),
862 entries[i].flags.in_tx ? 'X' : '-',
863 entries[i].flags.abort ? 'A' : '-',
864 entries[i].flags.cycles);
106dacd8 865 }
a1a58707
ACM		 866
867 return printed;
106dacd8 868}
48d02a1d
AK		 869#define MAXBB 16384UL
870
871static int grab_bb(u8 *buffer, u64 start, u64 end,
872 struct machine *machine, struct thread *thread,
873 bool *is64bit, u8 *cpumode, bool last)
874{
875 long offset, len;
876 struct addr_location al;
877 bool kernel;
878
879 if (!start || !end)
880 return 0;
881
882 kernel = machine__kernel_ip(machine, start);
883 if (kernel)
884 *cpumode = PERF_RECORD_MISC_KERNEL;
885 else
886 *cpumode = PERF_RECORD_MISC_USER;
887
888 /*
889 * Block overlaps between kernel and user.
890 * This can happen due to ring filtering
891 * On Intel CPUs the entry into the kernel is filtered,
892 * but the exit is not. Let the caller patch it up.
893 */
894 if (kernel != machine__kernel_ip(machine, end)) {
5ce2c5b4 895 pr_debug("\tblock %" PRIx64 "-%" PRIx64 " transfers between kernel and user\n", start, end);
48d02a1d
AK		 896 return -ENXIO;
897 }
898
899 memset(&al, 0, sizeof(al));
900 if (end - start > MAXBB - MAXINSN) {
901 if (last)
5ce2c5b4 902 pr_debug("\tbrstack does not reach to final jump (%" PRIx64 "-%" PRIx64 ")\n", start, end);
48d02a1d 903 else
5ce2c5b4 904 pr_debug("\tblock %" PRIx64 "-%" PRIx64 " (%" PRIu64 ") too long to dump\n", start, end, end - start);
48d02a1d
AK		 905 return 0;
906 }
907
71a84b5a 908 if (!thread__find_map(thread, *cpumode, start, &al) || !al.map->dso) {
5ce2c5b4 909 pr_debug("\tcannot resolve %" PRIx64 "-%" PRIx64 "\n", start, end);
48d02a1d
AK		 910 return 0;
911 }
912 if (al.map->dso->data.status == DSO_DATA_STATUS_ERROR) {
5ce2c5b4 913 pr_debug("\tcannot resolve %" PRIx64 "-%" PRIx64 "\n", start, end);
48d02a1d
AK		 914 return 0;
915 }
916
917 /* Load maps to ensure dso->is_64_bit has been updated */
918 map__load(al.map);
919
920 offset = al.map->map_ip(al.map, start);
921 len = dso__data_read_offset(al.map->dso, machine, offset, (u8 *)buffer,
922 end - start + MAXINSN);
923
924 *is64bit = al.map->dso->is_64_bit;
925 if (len <= 0)
5ce2c5b4 926 pr_debug("\tcannot fetch code for block at %" PRIx64 "-%" PRIx64 "\n",
48d02a1d
AK		 927 start, end);
928 return len;
929}
930
540a63ea
ACM		 931static int map__fprintf_srccode(struct map *map, u64 addr, FILE *fp, struct srccode_state *state)
932{
933 char *srcfile;
934 int ret = 0;
935 unsigned line;
936 int len;
937 char *srccode;
938
939 if (!map || !map->dso)
940 return 0;
941 srcfile = get_srcline_split(map->dso,
942 map__rip_2objdump(map, addr),
943 &line);
944 if (!srcfile)
945 return 0;
946
947 /* Avoid redundant printing */
948 if (state &&
949 state->srcfile &&
950 !strcmp(state->srcfile, srcfile) &&
951 state->line == line) {
952 free(srcfile);
953 return 0;
954 }
955
956 srccode = find_sourceline(srcfile, line, &len);
957 if (!srccode)
958 goto out_free_line;
959
960 ret = fprintf(fp, "|%-8d %.*s", line, len, srccode);
961
962 if (state) {
963 state->srcfile = srcfile;
964 state->line = line;
965 }
966 return ret;
967
968out_free_line:
969 free(srcfile);
970 return ret;
971}
972
dd2e18e9
AK		 973static int print_srccode(struct thread *thread, u8 cpumode, uint64_t addr)
974{
975 struct addr_location al;
976 int ret = 0;
977
978 memset(&al, 0, sizeof(al));
979 thread__find_map(thread, cpumode, addr, &al);
980 if (!al.map)
981 return 0;
982 ret = map__fprintf_srccode(al.map, al.addr, stdout,
983 &thread->srccode_state);
984 if (ret)
985 ret += printf("\n");
986 return ret;
987}
988
a1a58707
ACM		 989static int ip__fprintf_jump(uint64_t ip, struct branch_entry *en,
990 struct perf_insn *x, u8 *inbuf, int len,
fe57120e 991 int insn, FILE *fp, int *total_cycles)
48d02a1d 992{
a1a58707
ACM		 993 int printed = fprintf(fp, "\t%016" PRIx64 "\t%-30s\t#%s%s%s%s", ip,
994 dump_insn(x, ip, inbuf, len, NULL),
995 en->flags.predicted ? " PRED" : "",
996 en->flags.mispred ? " MISPRED" : "",
997 en->flags.in_tx ? " INTX" : "",
998 en->flags.abort ? " ABORT" : "");
48d02a1d 999 if (en->flags.cycles) {
fe57120e
AK		 1000 *total_cycles += en->flags.cycles;
1001 printed += fprintf(fp, " %d cycles [%d]", en->flags.cycles, *total_cycles);
48d02a1d 1002 if (insn)
a1a58707 1003 printed += fprintf(fp, " %.2f IPC", (float)insn / en->flags.cycles);
48d02a1d 1004 }
a1a58707 1005 return printed + fprintf(fp, "\n");
48d02a1d
AK		 1006}
1007
a1a58707
ACM		 1008static int ip__fprintf_sym(uint64_t addr, struct thread *thread,
1009 u8 cpumode, int cpu, struct symbol **lastsym,
1010 struct perf_event_attr *attr, FILE *fp)
48d02a1d
AK		 1011{
1012 struct addr_location al;
a1a58707 1013 int off, printed = 0;
48d02a1d
AK		 1014
1015 memset(&al, 0, sizeof(al));
1016
404eb5a4
ACM		 1017 thread__find_map(thread, cpumode, addr, &al);
1018
48d02a1d 1019 if ((*lastsym) && al.addr >= (*lastsym)->start && al.addr < (*lastsym)->end)
a1a58707 1020 return 0;
48d02a1d
AK		 1021
1022 al.cpu = cpu;
1023 al.sym = NULL;
1024 if (al.map)
1025 al.sym = map__find_symbol(al.map, al.addr);
1026
1027 if (!al.sym)
a1a58707 1028 return 0;
48d02a1d
AK		 1029
1030 if (al.addr < al.sym->end)
1031 off = al.addr - al.sym->start;
1032 else
1033 off = al.addr - al.map->start - al.sym->start;
a1a58707 1034 printed += fprintf(fp, "\t%s", al.sym->name);
48d02a1d 1035 if (off)
a1a58707
ACM		 1036 printed += fprintf(fp, "%+d", off);
1037 printed += fprintf(fp, ":");
48d02a1d 1038 if (PRINT_FIELD(SRCLINE))
a1a58707
ACM		 1039 printed += map__fprintf_srcline(al.map, al.addr, "\t", fp);
1040 printed += fprintf(fp, "\n");
48d02a1d 1041 *lastsym = al.sym;
a1a58707
ACM		 1042
1043 return printed;
48d02a1d
AK		 1044}
1045
a1a58707
ACM		 1046static int perf_sample__fprintf_brstackinsn(struct perf_sample *sample,
1047 struct thread *thread,
1048 struct perf_event_attr *attr,
1049 struct machine *machine, FILE *fp)
48d02a1d
AK		 1050{
1051 struct branch_stack *br = sample->branch_stack;
42bbabed 1052 struct branch_entry *entries = perf_sample__branch_entries(sample);
48d02a1d 1053 u64 start, end;
a1a58707 1054 int i, insn, len, nr, ilen, printed = 0;
48d02a1d
AK		 1055 struct perf_insn x;
1056 u8 buffer[MAXBB];
1057 unsigned off;
1058 struct symbol *lastsym = NULL;
fe57120e 1059 int total_cycles = 0;
48d02a1d
AK		 1060
1061 if (!(br && br->nr))
a1a58707 1062 return 0;
48d02a1d
AK		 1063 nr = br->nr;
1064 if (max_blocks && nr > max_blocks + 1)
1065 nr = max_blocks + 1;
1066
1067 x.thread = thread;
1068 x.cpu = sample->cpu;
1069
a1a58707 1070 printed += fprintf(fp, "%c", '\n');
48d02a1d
AK		 1071
1072 /* Handle first from jump, of which we don't know the entry. */
42bbabed
KL		 1073 len = grab_bb(buffer, entries[nr-1].from,
1074 entries[nr-1].from,
48d02a1d
AK		 1075 machine, thread, &x.is64bit, &x.cpumode, false);
1076 if (len > 0) {
42bbabed 1077 printed += ip__fprintf_sym(entries[nr - 1].from, thread,
a1a58707 1078 x.cpumode, x.cpu, &lastsym, attr, fp);
42bbabed 1079 printed += ip__fprintf_jump(entries[nr - 1].from, &entries[nr - 1],
fe57120e 1080 &x, buffer, len, 0, fp, &total_cycles);
dd2e18e9 1081 if (PRINT_FIELD(SRCCODE))
42bbabed 1082 printed += print_srccode(thread, x.cpumode, entries[nr - 1].from);
48d02a1d
AK		 1083 }
1084
1085 /* Print all blocks */
1086 for (i = nr - 2; i >= 0; i--) {
42bbabed 1087 if (entries[i].from || entries[i].to)
48d02a1d 1088 pr_debug("%d: %" PRIx64 "-%" PRIx64 "\n", i,
42bbabed
KL		 1089 entries[i].from,
1090 entries[i].to);
1091 start = entries[i + 1].to;
1092 end = entries[i].from;
48d02a1d
AK		 1093
1094 len = grab_bb(buffer, start, end, machine, thread, &x.is64bit, &x.cpumode, false);
1095 /* Patch up missing kernel transfers due to ring filters */
1096 if (len == -ENXIO && i > 0) {
42bbabed 1097 end = entries[--i].from;
48d02a1d
AK		 1098 pr_debug("\tpatching up to %" PRIx64 "-%" PRIx64 "\n", start, end);
1099 len = grab_bb(buffer, start, end, machine, thread, &x.is64bit, &x.cpumode, false);
1100 }
1101 if (len <= 0)
1102 continue;
1103
1104 insn = 0;
e98df280 1105 for (off = 0; off < (unsigned)len; off += ilen) {
48d02a1d
AK		 1106 uint64_t ip = start + off;
1107
a1a58707 1108 printed += ip__fprintf_sym(ip, thread, x.cpumode, x.cpu, &lastsym, attr, fp);
48d02a1d 1109 if (ip == end) {
42bbabed 1110 printed += ip__fprintf_jump(ip, &entries[i], &x, buffer + off, len - off, ++insn, fp,
fe57120e 1111 &total_cycles);
dd2e18e9
AK		 1112 if (PRINT_FIELD(SRCCODE))
1113 printed += print_srccode(thread, x.cpumode, ip);
48d02a1d
AK		 1114 break;
1115 } else {
e98df280 1116 ilen = 0;
a1a58707
ACM		 1117 printed += fprintf(fp, "\t%016" PRIx64 "\t%s\n", ip,
1118 dump_insn(&x, ip, buffer + off, len - off, &ilen));
48d02a1d
AK		 1119 if (ilen == 0)
1120 break;
dd2e18e9
AK		 1121 if (PRINT_FIELD(SRCCODE))
1122 print_srccode(thread, x.cpumode, ip);
48d02a1d
AK		 1123 insn++;
1124 }
1125 }
5172672d 1126 if (off != end - start)
e98df280 1127 printed += fprintf(fp, "\tmismatch of LBR data and executable\n");
48d02a1d
AK		 1128 }
1129
1130 /*
1131 * Hit the branch? In this case we are already done, and the target
1132 * has not been executed yet.
1133 */
42bbabed 1134 if (entries[0].from == sample->ip)
a1a58707 1135 goto out;
42bbabed 1136 if (entries[0].flags.abort)
a1a58707 1137 goto out;
48d02a1d
AK		 1138
1139 /*
1140 * Print final block upto sample
61f61159
AK		 1141 *
1142 * Due to pipeline delays the LBRs might be missing a branch
1143 * or two, which can result in very large or negative blocks
1144 * between final branch and sample. When this happens just
1145 * continue walking after the last TO until we hit a branch.
48d02a1d 1146 */
42bbabed 1147 start = entries[0].to;
48d02a1d 1148 end = sample->ip;
61f61159
AK		 1149 if (end < start) {
1150 /* Missing jump. Scan 128 bytes for the next branch */
1151 end = start + 128;
1152 }
48d02a1d 1153 len = grab_bb(buffer, start, end, machine, thread, &x.is64bit, &x.cpumode, true);
a1a58707 1154 printed += ip__fprintf_sym(start, thread, x.cpumode, x.cpu, &lastsym, attr, fp);
48d02a1d
AK		 1155 if (len <= 0) {
1156 /* Print at least last IP if basic block did not work */
1157 len = grab_bb(buffer, sample->ip, sample->ip,
1158 machine, thread, &x.is64bit, &x.cpumode, false);
1159 if (len <= 0)
a1a58707 1160 goto out;
a1a58707 1161 printed += fprintf(fp, "\t%016" PRIx64 "\t%s\n", sample->ip,
48d02a1d 1162 dump_insn(&x, sample->ip, buffer, len, NULL));
dd2e18e9
AK		 1163 if (PRINT_FIELD(SRCCODE))
1164 print_srccode(thread, x.cpumode, sample->ip);
a1a58707 1165 goto out;
48d02a1d
AK		 1166 }
1167 for (off = 0; off <= end - start; off += ilen) {
e98df280 1168 ilen = 0;
a1a58707
ACM		 1169 printed += fprintf(fp, "\t%016" PRIx64 "\t%s\n", start + off,
1170 dump_insn(&x, start + off, buffer + off, len - off, &ilen));
48d02a1d
AK		 1171 if (ilen == 0)
1172 break;
61f61159
AK		 1173 if (arch_is_branch(buffer + off, len - off, x.is64bit) && start + off != sample->ip) {
1174 /*
1175 * Hit a missing branch. Just stop.
1176 */
1177 printed += fprintf(fp, "\t... not reaching sample ...\n");
1178 break;
1179 }
dd2e18e9
AK		 1180 if (PRINT_FIELD(SRCCODE))
1181 print_srccode(thread, x.cpumode, start + off);
48d02a1d 1182 }
a1a58707
ACM		 1183out:
1184 return printed;
48d02a1d 1185}
dc323ce8 1186
a1a58707
ACM		 1187static int perf_sample__fprintf_addr(struct perf_sample *sample,
1188 struct thread *thread,
1189 struct perf_event_attr *attr, FILE *fp)
7cec0922
DA		 1190{
1191 struct addr_location al;
a1a58707 1192 int printed = fprintf(fp, "%16" PRIx64, sample->addr);
7cec0922
DA		 1193
1194 if (!sample_addr_correlates_sym(attr))
a1a58707 1195 goto out;
7cec0922 1196
c2740a87 1197 thread__resolve(thread, &al, sample);
7cec0922
DA		 1198
1199 if (PRINT_FIELD(SYM)) {
a1a58707 1200 printed += fprintf(fp, " ");
a978f2ab 1201 if (PRINT_FIELD(SYMOFFSET))
a1a58707 1202 printed += symbol__fprintf_symname_offs(al.sym, &al, fp);
a978f2ab 1203 else
a1a58707 1204 printed += symbol__fprintf_symname(al.sym, fp);
7cec0922
DA		 1205 }
1206
1207 if (PRINT_FIELD(DSO)) {
a1a58707
ACM		 1208 printed += fprintf(fp, " (");
1209 printed += map__fprintf_dsoname(al.map, fp);
1210 printed += fprintf(fp, ")");
7cec0922 1211 }
a1a58707
ACM		 1212out:
1213 return printed;
7cec0922
DA		 1214}
1215
99f753f0 1216static const char *resolve_branch_sym(struct perf_sample *sample,
32dcd021 1217 struct evsel *evsel,
99f753f0
AK		 1218 struct thread *thread,
1219 struct addr_location *al,
1220 u64 *ip)
1221{
1222 struct addr_location addr_al;
1fc632ce 1223 struct perf_event_attr *attr = &evsel->core.attr;
99f753f0
AK		 1224 const char *name = NULL;
1225
1226 if (sample->flags & (PERF_IP_FLAG_CALL | PERF_IP_FLAG_TRACE_BEGIN)) {
1227 if (sample_addr_correlates_sym(attr)) {
1228 thread__resolve(thread, &addr_al, sample);
1229 if (addr_al.sym)
1230 name = addr_al.sym->name;
1231 else
1232 *ip = sample->addr;
1233 } else {
1234 *ip = sample->addr;
1235 }
1236 } else if (sample->flags & (PERF_IP_FLAG_RETURN | PERF_IP_FLAG_TRACE_END)) {
1237 if (al->sym)
1238 name = al->sym->name;
1239 else
1240 *ip = sample->ip;
1241 }
1242 return name;
1243}
1244
a1a58707 1245static int perf_sample__fprintf_callindent(struct perf_sample *sample,
32dcd021 1246 struct evsel *evsel,
a1a58707
ACM		 1247 struct thread *thread,
1248 struct addr_location *al, FILE *fp)
e216708d 1249{
1fc632ce 1250 struct perf_event_attr *attr = &evsel->core.attr;
256d92bc 1251 size_t depth = thread_stack__depth(thread, sample->cpu);
e216708d
AH		 1252 const char *name = NULL;
1253 static int spacing;
1254 int len = 0;
a78cdee6 1255 int dlen = 0;
e216708d
AH		 1256 u64 ip = 0;
1257
1258 /*
1259 * The 'return' has already been popped off the stack so the depth has
1260 * to be adjusted to match the 'call'.
1261 */
1262 if (thread->ts && sample->flags & PERF_IP_FLAG_RETURN)
1263 depth += 1;
1264
99f753f0 1265 name = resolve_branch_sym(sample, evsel, thread, al, &ip);
e216708d 1266
a78cdee6
AK		 1267 if (PRINT_FIELD(DSO) && !(PRINT_FIELD(IP) || PRINT_FIELD(ADDR))) {
1268 dlen += fprintf(fp, "(");
1269 dlen += map__fprintf_dsoname(al->map, fp);
1270 dlen += fprintf(fp, ")\t");
1271 }
1272
e216708d 1273 if (name)
a1a58707 1274 len = fprintf(fp, "%*s%s", (int)depth * 4, "", name);
e216708d 1275 else if (ip)
a1a58707 1276 len = fprintf(fp, "%*s%16" PRIx64, (int)depth * 4, "", ip);
e216708d
AH		 1277
1278 if (len < 0)
a1a58707 1279 return len;
e216708d
AH		 1280
1281 /*
1282 * Try to keep the output length from changing frequently so that the
1283 * output lines up more nicely.
1284 */
1285 if (len > spacing || (len && len < spacing - 52))
1286 spacing = round_up(len + 4, 32);
1287
1288 if (len < spacing)
a1a58707
ACM		 1289 len += fprintf(fp, "%*s", spacing - len, "");
1290
a78cdee6 1291 return len + dlen;
e216708d
AH		 1292}
1293
3ab481a1
AK		 1294__weak void arch_fetch_insn(struct perf_sample *sample __maybe_unused,
1295 struct thread *thread __maybe_unused,
1296 struct machine *machine __maybe_unused)
1297{
1298}
1299
a1a58707
ACM		 1300static int perf_sample__fprintf_insn(struct perf_sample *sample,
1301 struct perf_event_attr *attr,
1302 struct thread *thread,
1303 struct machine *machine, FILE *fp)
224e2c97 1304{
a1a58707
ACM		 1305 int printed = 0;
1306
3ab481a1
AK		 1307 if (sample->insn_len == 0 && native_arch)
1308 arch_fetch_insn(sample, thread, machine);
1309
224e2c97 1310 if (PRINT_FIELD(INSNLEN))
a1a58707 1311 printed += fprintf(fp, " ilen: %d", sample->insn_len);
3ab481a1 1312 if (PRINT_FIELD(INSN) && sample->insn_len) {
224e2c97
AK		 1313 int i;
1314
a1a58707 1315 printed += fprintf(fp, " insn:");
224e2c97 1316 for (i = 0; i < sample->insn_len; i++)
a1a58707 1317 printed += fprintf(fp, " %02x", (unsigned char)sample->insn[i]);
224e2c97 1318 }
48d02a1d 1319 if (PRINT_FIELD(BRSTACKINSN))
a1a58707
ACM		 1320 printed += perf_sample__fprintf_brstackinsn(sample, thread, attr, machine, fp);
1321
1322 return printed;
224e2c97
AK		 1323}
1324
68fb45bf
AH		 1325static int perf_sample__fprintf_ipc(struct perf_sample *sample,
1326 struct perf_event_attr *attr, FILE *fp)
1327{
1328 unsigned int ipc;
1329
1330 if (!PRINT_FIELD(IPC) || !sample->cyc_cnt || !sample->insn_cnt)
1331 return 0;
1332
1333 ipc = (sample->insn_cnt * 100) / sample->cyc_cnt;
1334
1335 return fprintf(fp, " \t IPC: %u.%02u (%" PRIu64 "/%" PRIu64 ") ",
1336 ipc / 100, ipc % 100, sample->insn_cnt, sample->cyc_cnt);
1337}
1338
a1a58707 1339static int perf_sample__fprintf_bts(struct perf_sample *sample,
32dcd021 1340 struct evsel *evsel,
a1a58707
ACM		 1341 struct thread *thread,
1342 struct addr_location *al,
1343 struct machine *machine, FILE *fp)
95582596 1344{
1fc632ce 1345 struct perf_event_attr *attr = &evsel->core.attr;
1405720d 1346 unsigned int type = output_type(attr->type);
8066be5f 1347 bool print_srcline_last = false;
a1a58707 1348 int printed = 0;
95582596 1349
e216708d 1350 if (PRINT_FIELD(CALLINDENT))
a1a58707 1351 printed += perf_sample__fprintf_callindent(sample, evsel, thread, al, fp);
e216708d 1352
95582596
AN		 1353 /* print branch_from information */
1354 if (PRINT_FIELD(IP)) {
1405720d 1355 unsigned int print_opts = output[type].print_ip_opts;
e557b674 1356 struct callchain_cursor *cursor = NULL;
8066be5f 1357
6f736735 1358 if (symbol_conf.use_callchain && sample->callchain &&
e557b674 1359 thread__resolve_callchain(al->thread, &callchain_cursor, evsel,
6f736735 1360 sample, NULL, NULL, scripting_max_stack) == 0)
e557b674 1361 cursor = &callchain_cursor;
6f736735
ACM		 1362
1363 if (cursor == NULL) {
a1a58707 1364 printed += fprintf(fp, " ");
e20ab86e 1365 if (print_opts & EVSEL__PRINT_SRCLINE) {
8066be5f 1366 print_srcline_last = true;
e20ab86e 1367 print_opts &= ~EVSEL__PRINT_SRCLINE;
8066be5f 1368 }
6f736735 1369 } else
a1a58707 1370 printed += fprintf(fp, "\n");
6f736735 1371
9620bc36
ACM		 1372 printed += sample__fprintf_sym(sample, al, 0, print_opts, cursor,
1373 symbol_conf.bt_stop_list, fp);
95582596
AN		 1374 }
1375
95582596 1376 /* print branch_to information */
243be3dd 1377 if (PRINT_FIELD(ADDR) ||
1fc632ce 1378 ((evsel->core.attr.sample_type & PERF_SAMPLE_ADDR) &&
1405720d 1379 !output[type].user_set)) {
a1a58707
ACM		 1380 printed += fprintf(fp, " => ");
1381 printed += perf_sample__fprintf_addr(sample, thread, attr, fp);
578bea40 1382 }
95582596 1383
68fb45bf
AH		 1384 printed += perf_sample__fprintf_ipc(sample, attr, fp);
1385
8066be5f 1386 if (print_srcline_last)
a1a58707 1387 printed += map__fprintf_srcline(al->map, al->addr, "\n ", fp);
224e2c97 1388
a1a58707 1389 printed += perf_sample__fprintf_insn(sample, attr, thread, machine, fp);
dd2e18e9
AK		 1390 printed += fprintf(fp, "\n");
1391 if (PRINT_FIELD(SRCCODE)) {
1392 int ret = map__fprintf_srccode(al->map, al->addr, stdout,
1393 &thread->srccode_state);
1394 if (ret) {
1395 printed += ret;
1396 printed += printf("\n");
1397 }
1398 }
1399 return printed;
95582596
AN		 1400}
1401
055cd33d
AH		 1402static struct {
1403 u32 flags;
1404 const char *name;
1405} sample_flags[] = {
1406 {PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CALL, "call"},
1407 {PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_RETURN, "return"},
1408 {PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CONDITIONAL, "jcc"},
1409 {PERF_IP_FLAG_BRANCH, "jmp"},
1410 {PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CALL | PERF_IP_FLAG_INTERRUPT, "int"},
1411 {PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_RETURN | PERF_IP_FLAG_INTERRUPT, "iret"},
1412 {PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CALL | PERF_IP_FLAG_SYSCALLRET, "syscall"},
1413 {PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_RETURN | PERF_IP_FLAG_SYSCALLRET, "sysret"},
1414 {PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_ASYNC, "async"},
1415 {PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CALL | PERF_IP_FLAG_ASYNC | PERF_IP_FLAG_INTERRUPT, "hw int"},
1416 {PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_TX_ABORT, "tx abrt"},
1417 {PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_TRACE_BEGIN, "tr strt"},
1418 {PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_TRACE_END, "tr end"},
1419 {0, NULL}
1420};
1421
62cb1b88
AH		 1422static const char *sample_flags_to_name(u32 flags)
1423{
1424 int i;
1425
1426 for (i = 0; sample_flags[i].name ; i++) {
1427 if (sample_flags[i].flags == flags)
1428 return sample_flags[i].name;
1429 }
1430
1431 return NULL;
1432}
1433
a1a58707 1434static int perf_sample__fprintf_flags(u32 flags, FILE *fp)
400ea6d3
AH		 1435{
1436 const char *chars = PERF_IP_FLAG_CHARS;
1437 const int n = strlen(PERF_IP_FLAG_CHARS);
055cd33d
AH		 1438 bool in_tx = flags & PERF_IP_FLAG_IN_TX;
1439 const char *name = NULL;
400ea6d3
AH		 1440 char str[33];
1441 int i, pos = 0;
1442
62cb1b88
AH		 1443 name = sample_flags_to_name(flags & ~PERF_IP_FLAG_IN_TX);
1444 if (name)
1445 return fprintf(fp, " %-15s%4s ", name, in_tx ? "(x)" : "");
1446
1447 if (flags & PERF_IP_FLAG_TRACE_BEGIN) {
1448 name = sample_flags_to_name(flags & ~(PERF_IP_FLAG_IN_TX | PERF_IP_FLAG_TRACE_BEGIN));
1449 if (name)
1450 return fprintf(fp, " tr strt %-7s%4s ", name, in_tx ? "(x)" : "");
1451 }
1452
1453 if (flags & PERF_IP_FLAG_TRACE_END) {
1454 name = sample_flags_to_name(flags & ~(PERF_IP_FLAG_IN_TX | PERF_IP_FLAG_TRACE_END));
1455 if (name)
1456 return fprintf(fp, " tr end %-7s%4s ", name, in_tx ? "(x)" : "");
055cd33d
AH		 1457 }
1458
400ea6d3
AH		 1459 for (i = 0; i < n; i++, flags >>= 1) {
1460 if (flags & 1)
1461 str[pos++] = chars[i];
1462 }
1463 for (; i < 32; i++, flags >>= 1) {
1464 if (flags & 1)
1465 str[pos++] = '?';
1466 }
1467 str[pos] = 0;
055cd33d 1468
62cb1b88 1469 return fprintf(fp, " %-19s ", str);
400ea6d3
AH		 1470}
1471
30372f04
WN		 1472struct printer_data {
1473 int line_no;
1474 bool hit_nul;
1475 bool is_printable;
1476};
1477
923d0c9a
ACM		 1478static int sample__fprintf_bpf_output(enum binary_printer_ops op,
1479 unsigned int val,
1480 void *extra, FILE *fp)
30372f04
WN		 1481{
1482 unsigned char ch = (unsigned char)val;
1483 struct printer_data *printer_data = extra;
923d0c9a 1484 int printed = 0;
30372f04
WN		 1485
1486 switch (op) {
1487 case BINARY_PRINT_DATA_BEGIN:
923d0c9a 1488 printed += fprintf(fp, "\n");
30372f04
WN		 1489 break;
1490 case BINARY_PRINT_LINE_BEGIN:
923d0c9a 1491 printed += fprintf(fp, "%17s", !printer_data->line_no ? "BPF output:" :
30372f04
WN		 1492 " ");
1493 break;
1494 case BINARY_PRINT_ADDR:
923d0c9a 1495 printed += fprintf(fp, " %04x:", val);
30372f04
WN		 1496 break;
1497 case BINARY_PRINT_NUM_DATA:
923d0c9a 1498 printed += fprintf(fp, " %02x", val);
30372f04
WN		 1499 break;
1500 case BINARY_PRINT_NUM_PAD:
923d0c9a 1501 printed += fprintf(fp, " ");
30372f04
WN		 1502 break;
1503 case BINARY_PRINT_SEP:
923d0c9a 1504 printed += fprintf(fp, " ");
30372f04
WN		 1505 break;
1506 case BINARY_PRINT_CHAR_DATA:
1507 if (printer_data->hit_nul && ch)
1508 printer_data->is_printable = false;
1509
1510 if (!isprint(ch)) {
923d0c9a 1511 printed += fprintf(fp, "%c", '.');
30372f04
WN		 1512
1513 if (!printer_data->is_printable)
1514 break;
1515
1516 if (ch == '\0')
1517 printer_data->hit_nul = true;
1518 else
1519 printer_data->is_printable = false;
1520 } else {
923d0c9a 1521 printed += fprintf(fp, "%c", ch);
30372f04
WN		 1522 }
1523 break;
1524 case BINARY_PRINT_CHAR_PAD:
923d0c9a 1525 printed += fprintf(fp, " ");
30372f04
WN		 1526 break;
1527 case BINARY_PRINT_LINE_END:
923d0c9a 1528 printed += fprintf(fp, "\n");
30372f04
WN		 1529 printer_data->line_no++;
1530 break;
1531 case BINARY_PRINT_DATA_END:
1532 default:
1533 break;
1534 }
923d0c9a
ACM		 1535
1536 return printed;
30372f04
WN		 1537}
1538
a1a58707 1539static int perf_sample__fprintf_bpf_output(struct perf_sample *sample, FILE *fp)
30372f04
WN		 1540{
1541 unsigned int nr_bytes = sample->raw_size;
1542 struct printer_data printer_data = {0, false, true};
a1a58707
ACM		 1543 int printed = binary__fprintf(sample->raw_data, nr_bytes, 8,
1544 sample__fprintf_bpf_output, &printer_data, fp);
30372f04
WN		 1545
1546 if (printer_data.is_printable && printer_data.hit_nul)
a1a58707
ACM		 1547 printed += fprintf(fp, "%17s \"%s\"\n", "BPF string:", (char *)(sample->raw_data));
1548
1549 return printed;
30372f04
WN		 1550}
1551
a1a58707 1552static int perf_sample__fprintf_spacing(int len, int spacing, FILE *fp)
65c5e18f
AH		 1553{
1554 if (len > 0 && len < spacing)
a1a58707
ACM		 1555 return fprintf(fp, "%*s", spacing - len, "");
1556
1557 return 0;
65c5e18f
AH		 1558}
1559
a1a58707 1560static int perf_sample__fprintf_pt_spacing(int len, FILE *fp)
65c5e18f 1561{
a1a58707 1562 return perf_sample__fprintf_spacing(len, 34, fp);
65c5e18f
AH		 1563}
1564
a1a58707 1565static int perf_sample__fprintf_synth_ptwrite(struct perf_sample *sample, FILE *fp)
65c5e18f
AH		 1566{
1567 struct perf_synth_intel_ptwrite *data = perf_sample__synth_ptr(sample);
1568 int len;
1569
1570 if (perf_sample__bad_synth_size(sample, *data))
a1a58707 1571 return 0;
65c5e18f 1572
a1a58707 1573 len = fprintf(fp, " IP: %u payload: %#" PRIx64 " ",
65c5e18f 1574 data->ip, le64_to_cpu(data->payload));
a1a58707 1575 return len + perf_sample__fprintf_pt_spacing(len, fp);
65c5e18f
AH		 1576}
1577
a1a58707 1578static int perf_sample__fprintf_synth_mwait(struct perf_sample *sample, FILE *fp)
65c5e18f
AH		 1579{
1580 struct perf_synth_intel_mwait *data = perf_sample__synth_ptr(sample);
1581 int len;
1582
1583 if (perf_sample__bad_synth_size(sample, *data))
a1a58707 1584 return 0;
65c5e18f 1585
a1a58707
ACM		 1586 len = fprintf(fp, " hints: %#x extensions: %#x ",
1587 data->hints, data->extensions);
1588 return len + perf_sample__fprintf_pt_spacing(len, fp);
65c5e18f
AH		 1589}
1590
a1a58707 1591static int perf_sample__fprintf_synth_pwre(struct perf_sample *sample, FILE *fp)
65c5e18f
AH		 1592{
1593 struct perf_synth_intel_pwre *data = perf_sample__synth_ptr(sample);
1594 int len;
1595
1596 if (perf_sample__bad_synth_size(sample, *data))
a1a58707 1597 return 0;
65c5e18f 1598
a1a58707
ACM		 1599 len = fprintf(fp, " hw: %u cstate: %u sub-cstate: %u ",
1600 data->hw, data->cstate, data->subcstate);
1601 return len + perf_sample__fprintf_pt_spacing(len, fp);
65c5e18f
AH		 1602}
1603
a1a58707 1604static int perf_sample__fprintf_synth_exstop(struct perf_sample *sample, FILE *fp)
65c5e18f
AH		 1605{
1606 struct perf_synth_intel_exstop *data = perf_sample__synth_ptr(sample);
1607 int len;
1608
1609 if (perf_sample__bad_synth_size(sample, *data))
a1a58707 1610 return 0;
65c5e18f 1611
a1a58707
ACM		 1612 len = fprintf(fp, " IP: %u ", data->ip);
1613 return len + perf_sample__fprintf_pt_spacing(len, fp);
65c5e18f
AH		 1614}
1615
a1a58707 1616static int perf_sample__fprintf_synth_pwrx(struct perf_sample *sample, FILE *fp)
65c5e18f
AH		 1617{
1618 struct perf_synth_intel_pwrx *data = perf_sample__synth_ptr(sample);
1619 int len;
1620
1621 if (perf_sample__bad_synth_size(sample, *data))
a1a58707 1622 return 0;
65c5e18f 1623
a1a58707 1624 len = fprintf(fp, " deepest cstate: %u last cstate: %u wake reason: %#x ",
65c5e18f
AH		 1625 data->deepest_cstate, data->last_cstate,
1626 data->wake_reason);
a1a58707 1627 return len + perf_sample__fprintf_pt_spacing(len, fp);
65c5e18f
AH		 1628}
1629
a1a58707 1630static int perf_sample__fprintf_synth_cbr(struct perf_sample *sample, FILE *fp)
65c5e18f
AH		 1631{
1632 struct perf_synth_intel_cbr *data = perf_sample__synth_ptr(sample);
1633 unsigned int percent, freq;
1634 int len;
1635
1636 if (perf_sample__bad_synth_size(sample, *data))
a1a58707 1637 return 0;
65c5e18f
AH		 1638
1639 freq = (le32_to_cpu(data->freq) + 500) / 1000;
a1a58707 1640 len = fprintf(fp, " cbr: %2u freq: %4u MHz ", data->cbr, freq);
65c5e18f
AH		 1641 if (data->max_nonturbo) {
1642 percent = (5 + (1000 * data->cbr) / data->max_nonturbo) / 10;
a1a58707 1643 len += fprintf(fp, "(%3u%%) ", percent);
65c5e18f 1644 }
a1a58707 1645 return len + perf_sample__fprintf_pt_spacing(len, fp);
65c5e18f
AH		 1646}
1647
a1a58707 1648static int perf_sample__fprintf_synth(struct perf_sample *sample,
32dcd021 1649 struct evsel *evsel, FILE *fp)
47e78084 1650{
1fc632ce 1651 switch (evsel->core.attr.config) {
65c5e18f 1652 case PERF_SYNTH_INTEL_PTWRITE:
a1a58707 1653 return perf_sample__fprintf_synth_ptwrite(sample, fp);
65c5e18f 1654 case PERF_SYNTH_INTEL_MWAIT:
a1a58707 1655 return perf_sample__fprintf_synth_mwait(sample, fp);
65c5e18f 1656 case PERF_SYNTH_INTEL_PWRE:
a1a58707 1657 return perf_sample__fprintf_synth_pwre(sample, fp);
65c5e18f 1658 case PERF_SYNTH_INTEL_EXSTOP:
a1a58707 1659 return perf_sample__fprintf_synth_exstop(sample, fp);
65c5e18f 1660 case PERF_SYNTH_INTEL_PWRX:
a1a58707 1661 return perf_sample__fprintf_synth_pwrx(sample, fp);
65c5e18f 1662 case PERF_SYNTH_INTEL_CBR:
a1a58707 1663 return perf_sample__fprintf_synth_cbr(sample, fp);
47e78084
AH		 1664 default:
1665 break;
1666 }
a1a58707
ACM		 1667
1668 return 0;
47e78084
AH		 1669}
1670
809e9423
JO		 1671struct perf_script {
1672 struct perf_tool tool;
1673 struct perf_session *session;
1674 bool show_task_events;
1675 bool show_mmap_events;
1676 bool show_switch_events;
96a44bbc 1677 bool show_namespace_events;
3d7c27b6 1678 bool show_lost_events;
3233b37a 1679 bool show_round_events;
490c8cc9 1680 bool show_bpf_events;
160d4af9 1681 bool show_cgroup_events;
cfc8874a 1682 bool allocated;
a14390fd 1683 bool per_event_dump;
680d125c 1684 bool stitch_lbr;
f90a2417 1685 struct evswitch evswitch;
f854839b 1686 struct perf_cpu_map *cpus;
9749b90e 1687 struct perf_thread_map *threads;
9cdbc409 1688 int name_width;
a91f4c47 1689 const char *time_str;
cc2ef584
JY		 1690 struct perf_time_interval *ptime_range;
1691 int range_size;
2ab046cd 1692 int range_num;
809e9423
JO		 1693};
1694
63503dba 1695static int perf_evlist__max_name_len(struct evlist *evlist)
9cdbc409 1696{
32dcd021 1697 struct evsel *evsel;
9cdbc409
JO		 1698 int max = 0;
1699
e5cadb93 1700 evlist__for_each_entry(evlist, evsel) {
8ab2e96d 1701 int len = strlen(evsel__name(evsel));
9cdbc409
JO		 1702
1703 max = MAX(len, max);
1704 }
1705
1706 return max;
1707}
1708
a1a58707 1709static int data_src__fprintf(u64 data_src, FILE *fp)
c19ac912
JO		 1710{
1711 struct mem_info mi = { .data_src.val = data_src };
1712 char decode[100];
1713 char out[100];
1714 static int maxlen;
1715 int len;
1716
1717 perf_script__meminfo_scnprintf(decode, 100, &mi);
1718
1719 len = scnprintf(out, 100, "%16" PRIx64 " %s", data_src, decode);
1720 if (maxlen < len)
1721 maxlen = len;
1722
a1a58707 1723 return fprintf(fp, "%-*s", maxlen, out);
c19ac912
JO		 1724}
1725
4bd1bef8
AK		 1726struct metric_ctx {
1727 struct perf_sample *sample;
1728 struct thread *thread;
32dcd021 1729 struct evsel *evsel;
4bd1bef8
AK		 1730 FILE *fp;
1731};
1732
6ca9a082
JO		 1733static void script_print_metric(struct perf_stat_config *config __maybe_unused,
1734 void *ctx, const char *color,
4bd1bef8
AK		 1735 const char *fmt,
1736 const char *unit, double val)
1737{
1738 struct metric_ctx *mctx = ctx;
1739
1740 if (!fmt)
1741 return;
1742 perf_sample__fprintf_start(mctx->sample, mctx->thread, mctx->evsel,
28a0b398 1743 PERF_RECORD_SAMPLE, mctx->fp);
4bd1bef8
AK		 1744 fputs("\tmetric: ", mctx->fp);
1745 if (color)
1746 color_fprintf(mctx->fp, color, fmt, val);
1747 else
1748 printf(fmt, val);
1749 fprintf(mctx->fp, " %s\n", unit);
1750}
1751
6ca9a082
JO		 1752static void script_new_line(struct perf_stat_config *config __maybe_unused,
1753 void *ctx)
4bd1bef8
AK		 1754{
1755 struct metric_ctx *mctx = ctx;
1756
1757 perf_sample__fprintf_start(mctx->sample, mctx->thread, mctx->evsel,
28a0b398 1758 PERF_RECORD_SAMPLE, mctx->fp);
4bd1bef8
AK		 1759 fputs("\tmetric: ", mctx->fp);
1760}
1761
1762static void perf_sample__fprint_metric(struct perf_script *script,
1763 struct thread *thread,
32dcd021 1764 struct evsel *evsel,
4bd1bef8
AK		 1765 struct perf_sample *sample,
1766 FILE *fp)
1767{
1768 struct perf_stat_output_ctx ctx = {
1769 .print_metric = script_print_metric,
1770 .new_line = script_new_line,
1771 .ctx = &(struct metric_ctx) {
1772 .sample = sample,
1773 .thread = thread,
1774 .evsel = evsel,
1775 .fp = fp,
1776 },
1777 .force_header = false,
1778 };
32dcd021 1779 struct evsel *ev2;
4bd1bef8
AK		 1780 u64 val;
1781
4bd1bef8
AK		 1782 if (!evsel->stats)
1783 perf_evlist__alloc_stats(script->session->evlist, false);
1784 if (evsel_script(evsel->leader)->gnum++ == 0)
1785 perf_stat__reset_shadow_stats();
1786 val = sample->period * evsel->scale;
1787 perf_stat__update_shadow_stats(evsel,
1788 val,
1fcd0394
JY		 1789 sample->cpu,
1790 &rt_stat);
4bd1bef8 1791 evsel_script(evsel)->val = val;
5643b1a5 1792 if (evsel_script(evsel->leader)->gnum == evsel->leader->core.nr_members) {
4bd1bef8 1793 for_each_group_member (ev2, evsel->leader) {
6ca9a082 1794 perf_stat__print_shadow_stats(&stat_config, ev2,
4bd1bef8
AK		 1795 evsel_script(ev2)->val,
1796 sample->cpu,
1797 &ctx,
e0128b30
JY		 1798 NULL,
1799 &rt_stat);
4bd1bef8
AK		 1800 }
1801 evsel_script(evsel->leader)->gnum = 0;
1802 }
1803}
1804
99f753f0 1805static bool show_event(struct perf_sample *sample,
32dcd021 1806 struct evsel *evsel,
99f753f0
AK		 1807 struct thread *thread,
1808 struct addr_location *al)
1809{
256d92bc 1810 int depth = thread_stack__depth(thread, sample->cpu);
99f753f0
AK		 1811
1812 if (!symbol_conf.graph_function)
1813 return true;
1814
1815 if (thread->filter) {
1816 if (depth <= thread->filter_entry_depth) {
1817 thread->filter = false;
1818 return false;
1819 }
1820 return true;
1821 } else {
1822 const char *s = symbol_conf.graph_function;
1823 u64 ip;
1824 const char *name = resolve_branch_sym(sample, evsel, thread, al,
1825 &ip);
1826 unsigned nlen;
1827
1828 if (!name)
1829 return false;
1830 nlen = strlen(name);
1831 while (*s) {
1832 unsigned len = strcspn(s, ",");
1833 if (nlen == len && !strncmp(name, s, len)) {
1834 thread->filter = true;
1835 thread->filter_entry_depth = depth;
1836 return true;
1837 }
1838 s += len;
1839 if (*s == ',')
1840 s++;
1841 }
1842 return false;
1843 }
1844}
1845
a3dff304 1846static void process_event(struct perf_script *script,
32dcd021 1847 struct perf_sample *sample, struct evsel *evsel,
48d02a1d
AK		 1848 struct addr_location *al,
1849 struct machine *machine)
be6d842a 1850{
f9d5d549 1851 struct thread *thread = al->thread;
1fc632ce 1852 struct perf_event_attr *attr = &evsel->core.attr;
1405720d 1853 unsigned int type = output_type(attr->type);
32dcd021 1854 struct evsel_script *es = evsel->priv;
642ee1c6 1855 FILE *fp = es->fp;
1424dc96 1856
1405720d 1857 if (output[type].fields == 0)
1424dc96
DA		 1858 return;
1859
99f753f0
AK		 1860 if (!show_event(sample, evsel, thread, al))
1861 return;
1862
8829e56f
ACM		 1863 if (evswitch__discard(&script->evswitch, evsel))
1864 return;
dd41f660 1865
642ee1c6
ACM		 1866 ++es->samples;
1867
28a0b398
JO		 1868 perf_sample__fprintf_start(sample, thread, evsel,
1869 PERF_RECORD_SAMPLE, fp);
745f43e3 1870
535aeaae 1871 if (PRINT_FIELD(PERIOD))
69c71252 1872 fprintf(fp, "%10" PRIu64 " ", sample->period);
535aeaae 1873
e944d3d7 1874 if (PRINT_FIELD(EVNAME)) {
8ab2e96d 1875 const char *evname = evsel__name(evsel);
9cdbc409
JO		 1876
1877 if (!script->name_width)
1878 script->name_width = perf_evlist__max_name_len(script->session->evlist);
1879
69c71252 1880 fprintf(fp, "%*s: ", script->name_width, evname ?: "[unknown]");
e944d3d7
NK		 1881 }
1882
400ea6d3 1883 if (print_flags)
a1a58707 1884 perf_sample__fprintf_flags(sample->flags, fp);
400ea6d3 1885
95582596 1886 if (is_bts_event(attr)) {
a1a58707 1887 perf_sample__fprintf_bts(sample, evsel, thread, al, machine, fp);
95582596
AN		 1888 return;
1889 }
1890
96167167 1891 if (PRINT_FIELD(TRACE) && sample->raw_data) {
894f3f17
ACM		 1892 event_format__fprintf(evsel->tp_format, sample->cpu,
1893 sample->raw_data, sample->raw_size, fp);
1894 }
47e78084
AH		 1895
1896 if (attr->type == PERF_TYPE_SYNTH && PRINT_FIELD(SYNTH))
a1a58707 1897 perf_sample__fprintf_synth(sample, evsel, fp);
47e78084 1898
7cec0922 1899 if (PRINT_FIELD(ADDR))
a1a58707 1900 perf_sample__fprintf_addr(sample, thread, attr, fp);
7cec0922 1901
94ddddfa 1902 if (PRINT_FIELD(DATA_SRC))
a1a58707 1903 data_src__fprintf(sample->data_src, fp);
94ddddfa
JO		 1904
1905 if (PRINT_FIELD(WEIGHT))
a1a58707 1906 fprintf(fp, "%16" PRIu64, sample->weight);
94ddddfa 1907
787bef17 1908 if (PRINT_FIELD(IP)) {
e557b674 1909 struct callchain_cursor *cursor = NULL;
6f736735 1910
680d125c
KL		 1911 if (script->stitch_lbr)
1912 al->thread->lbr_stitch_enable = true;
1913
92231521 1914 if (symbol_conf.use_callchain && sample->callchain &&
e557b674 1915 thread__resolve_callchain(al->thread, &callchain_cursor, evsel,
6f736735 1916 sample, NULL, NULL, scripting_max_stack) == 0)
e557b674 1917 cursor = &callchain_cursor;
a6ffaf91 1918
a1a58707 1919 fputc(cursor ? '\n' : ' ', fp);
9620bc36
ACM		 1920 sample__fprintf_sym(sample, al, 0, output[type].print_ip_opts, cursor,
1921 symbol_conf.bt_stop_list, fp);
c0230b2b
DA		 1922 }
1923
fc36f948 1924 if (PRINT_FIELD(IREGS))
a1a58707 1925 perf_sample__fprintf_iregs(sample, attr, fp);
fc36f948 1926
b1491ace 1927 if (PRINT_FIELD(UREGS))
a1a58707 1928 perf_sample__fprintf_uregs(sample, attr, fp);
b1491ace 1929
dc323ce8 1930 if (PRINT_FIELD(BRSTACK))
a1a58707 1931 perf_sample__fprintf_brstack(sample, thread, attr, fp);
dc323ce8 1932 else if (PRINT_FIELD(BRSTACKSYM))
a1a58707 1933 perf_sample__fprintf_brstacksym(sample, thread, attr, fp);
106dacd8 1934 else if (PRINT_FIELD(BRSTACKOFF))
a1a58707 1935 perf_sample__fprintf_brstackoff(sample, thread, attr, fp);
dc323ce8 1936
c754c382 1937 if (evsel__is_bpf_output(evsel) && PRINT_FIELD(BPF_OUTPUT))
a1a58707
ACM		 1938 perf_sample__fprintf_bpf_output(sample, fp);
1939 perf_sample__fprintf_insn(sample, attr, thread, machine, fp);
49d58f04
KL		 1940
1941 if (PRINT_FIELD(PHYS_ADDR))
69c71252 1942 fprintf(fp, "%16" PRIx64, sample->phys_addr);
68fb45bf
AH		 1943
1944 perf_sample__fprintf_ipc(sample, attr, fp);
1945
69c71252 1946 fprintf(fp, "\n");
4bd1bef8 1947
dd2e18e9
AK		 1948 if (PRINT_FIELD(SRCCODE)) {
1949 if (map__fprintf_srccode(al->map, al->addr, stdout,
1950 &thread->srccode_state))
1951 printf("\n");
1952 }
1953
4bd1bef8
AK		 1954 if (PRINT_FIELD(METRIC))
1955 perf_sample__fprint_metric(script, thread, evsel, sample, fp);
7ee40678
MW		 1956
1957 if (verbose)
1958 fflush(fp);
be6d842a
DA		 1959}
1960
956ffd02
TZ		 1961static struct scripting_ops *scripting_ops;
1962
32dcd021 1963static void __process_stat(struct evsel *counter, u64 tstamp)
36e33c53 1964{
a2f354e3 1965 int nthreads = perf_thread_map__nr(counter->core.threads);
5eb88f04 1966 int ncpus = evsel__nr_cpus(counter);
36e33c53
JO		 1967 int cpu, thread;
1968 static int header_printed;
1969
648b5af3 1970 if (counter->core.system_wide)
36e33c53
JO		 1971 nthreads = 1;
1972
1973 if (!header_printed) {
1974 printf("%3s %8s %15s %15s %15s %15s %s\n",
1975 "CPU", "THREAD", "VAL", "ENA", "RUN", "TIME", "EVENT");
1976 header_printed = 1;
1977 }
1978
1979 for (thread = 0; thread < nthreads; thread++) {
1980 for (cpu = 0; cpu < ncpus; cpu++) {
1981 struct perf_counts_values *counts;
1982
1983 counts = perf_counts(counter->counts, cpu, thread);
1984
1985 printf("%3d %8d %15" PRIu64 " %15" PRIu64 " %15" PRIu64 " %15" PRIu64 " %s\n",
d400bd3a 1986 counter->core.cpus->map[cpu],
a2f354e3 1987 perf_thread_map__pid(counter->core.threads, thread),
36e33c53
JO		 1988 counts->val,
1989 counts->ena,
1990 counts->run,
1991 tstamp,
8ab2e96d 1992 evsel__name(counter));
36e33c53
JO		 1993 }
1994 }
1995}
1996
32dcd021 1997static void process_stat(struct evsel *counter, u64 tstamp)
e099eba8
JO		 1998{
1999 if (scripting_ops && scripting_ops->process_stat)
2000 scripting_ops->process_stat(&stat_config, counter, tstamp);
36e33c53
JO		 2001 else
2002 __process_stat(counter, tstamp);
e099eba8
JO		 2003}
2004
2005static void process_stat_interval(u64 tstamp)
2006{
2007 if (scripting_ops && scripting_ops->process_stat_interval)
2008 scripting_ops->process_stat_interval(tstamp);
2009}
2010
956ffd02
TZ		 2011static void setup_scripting(void)
2012{
16c632de 2013 setup_perl_scripting();
7e4b21b8 2014 setup_python_scripting();
956ffd02
TZ		 2015}
2016
d445dd2a
AH		 2017static int flush_scripting(void)
2018{
2aaecfc5 2019 return scripting_ops ? scripting_ops->flush_script() : 0;
d445dd2a
AH		 2020}
2021
956ffd02
TZ		 2022static int cleanup_scripting(void)
2023{
133dc4c3 2024 pr_debug("\nperf script stopped\n");
3824a4e8 2025
2aaecfc5 2026 return scripting_ops ? scripting_ops->stop_script() : 0;
956ffd02
TZ		 2027}
2028
e87e5481
AK		 2029static bool filter_cpu(struct perf_sample *sample)
2030{
1a2725f3 2031 if (cpu_list && sample->cpu != (u32)-1)
e87e5481
AK		 2032 return !test_bit(sample->cpu, cpu_bitmap);
2033 return false;
2034}
2035
809e9423 2036static int process_sample_event(struct perf_tool *tool,
d20deb64 2037 union perf_event *event,
8115d60c 2038 struct perf_sample *sample,
32dcd021 2039 struct evsel *evsel,
743eb868 2040 struct machine *machine)
5f9c39dc 2041{
809e9423 2042 struct perf_script *scr = container_of(tool, struct perf_script, tool);
e7984b7b 2043 struct addr_location al;
5f9c39dc 2044
2ab046cd
JY		 2045 if (perf_time__ranges_skip_sample(scr->ptime_range, scr->range_num,
2046 sample->time)) {
a91f4c47 2047 return 0;
2ab046cd 2048 }
a91f4c47 2049
1424dc96
DA		 2050 if (debug_mode) {
2051 if (sample->time < last_timestamp) {
2052 pr_err("Samples misordered, previous: %" PRIu64
2053 " this: %" PRIu64 "\n", last_timestamp,
2054 sample->time);
2055 nr_unordered++;
e1889d75 2056 }
1424dc96
DA		 2057 last_timestamp = sample->time;
2058 return 0;
5f9c39dc 2059 }
5d67be97 2060
bb3eb566 2061 if (machine__resolve(machine, &al, sample) < 0) {
e7984b7b
DA		 2062 pr_err("problem processing %d event, skipping it.\n",
2063 event->header.type);
2064 return -1;
2065 }
2066
2067 if (al.filtered)
b91fc39f 2068 goto out_put;
e7984b7b 2069
e87e5481 2070 if (filter_cpu(sample))
b91fc39f 2071 goto out_put;
5d67be97 2072
2aaecfc5
JO		 2073 if (scripting_ops)
2074 scripting_ops->process_event(event, sample, evsel, &al);
2075 else
48d02a1d 2076 process_event(scr, sample, evsel, &al, machine);
2aaecfc5 2077
b91fc39f
ACM		 2078out_put:
2079 addr_location__put(&al);
5f9c39dc
FW		 2080 return 0;
2081}
2082
7ea95727 2083static int process_attr(struct perf_tool *tool, union perf_event *event,
63503dba 2084 struct evlist **pevlist)
7ea95727
AH		 2085{
2086 struct perf_script *scr = container_of(tool, struct perf_script, tool);
63503dba 2087 struct evlist *evlist;
32dcd021 2088 struct evsel *evsel, *pos;
0d71a2b2 2089 u64 sample_type;
7ea95727 2090 int err;
32dcd021 2091 static struct evsel_script *es;
7ea95727
AH		 2092
2093 err = perf_event__process_attr(tool, event, pevlist);
2094 if (err)
2095 return err;
2096
2097 evlist = *pevlist;
515dbe48 2098 evsel = evlist__last(*pevlist);
7ea95727 2099
a3af66f5
RB		 2100 if (!evsel->priv) {
2101 if (scr->per_event_dump) {
2102 evsel->priv = perf_evsel_script__new(evsel,
2103 scr->session->data);
2104 } else {
2105 es = zalloc(sizeof(*es));
2106 if (!es)
2107 return -ENOMEM;
2108 es->fp = stdout;
2109 evsel->priv = es;
2110 }
2111 }
2112
1fc632ce
JO		 2113 if (evsel->core.attr.type >= PERF_TYPE_MAX &&
2114 evsel->core.attr.type != PERF_TYPE_SYNTH)
7ea95727
AH		 2115 return 0;
2116
e5cadb93 2117 evlist__for_each_entry(evlist, pos) {
1fc632ce 2118 if (pos->core.attr.type == evsel->core.attr.type && pos != evsel)
7ea95727
AH		 2119 return 0;
2120 }
2121
0d71a2b2 2122 if (evsel->core.attr.sample_type) {
d2b5a315 2123 err = perf_evsel__check_attr(evsel, scr->session);
0d71a2b2
JO		 2124 if (err)
2125 return err;
2126 }
d2b5a315 2127
0d71a2b2
JO		 2128 /*
2129 * Check if we need to enable callchains based
2130 * on events sample_type.
2131 */
2132 sample_type = perf_evlist__combined_sample_type(evlist);
2133 callchain_param_setup(sample_type);
53fb1894 2134
b5164085
AH		 2135 /* Enable fields for callchain entries */
2136 if (symbol_conf.use_callchain &&
2137 (sample_type & PERF_SAMPLE_CALLCHAIN ||
2138 sample_type & PERF_SAMPLE_BRANCH_STACK ||
2139 (sample_type & PERF_SAMPLE_REGS_USER &&
2140 sample_type & PERF_SAMPLE_STACK_USER))) {
2141 int type = output_type(evsel->core.attr.type);
2142
2143 if (!(output[type].user_unset_fields & PERF_OUTPUT_IP))
2144 output[type].fields |= PERF_OUTPUT_IP;
2145 if (!(output[type].user_unset_fields & PERF_OUTPUT_SYM))
2146 output[type].fields |= PERF_OUTPUT_SYM;
53fb1894
JO		 2147 }
2148 set_print_ip_opts(&evsel->core.attr);
0d71a2b2 2149 return 0;
7ea95727
AH		 2150}
2151
1a2725f3
AH		 2152static int print_event_with_time(struct perf_tool *tool,
2153 union perf_event *event,
2154 struct perf_sample *sample,
2155 struct machine *machine,
2156 pid_t pid, pid_t tid, u64 timestamp)
ad7ebb9a 2157{
ad7ebb9a
NK		 2158 struct perf_script *script = container_of(tool, struct perf_script, tool);
2159 struct perf_session *session = script->session;
32dcd021 2160 struct evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
1a2725f3 2161 struct thread *thread = NULL;
ad7ebb9a 2162
1a2725f3
AH		 2163 if (evsel && !evsel->core.attr.sample_id_all) {
2164 sample->cpu = 0;
2165 sample->time = timestamp;
2166 sample->pid = pid;
2167 sample->tid = tid;
ad7ebb9a
NK		 2168 }
2169
1a2725f3
AH		 2170 if (filter_cpu(sample))
2171 return 0;
ad7ebb9a 2172
1a2725f3
AH		 2173 if (tid != -1)
2174 thread = machine__findnew_thread(machine, pid, tid);
2175
2176 if (thread && evsel) {
e87e5481 2177 perf_sample__fprintf_start(sample, thread, evsel,
1a2725f3 2178 event->header.type, stdout);
e87e5481 2179 }
1a2725f3
AH		 2180
2181 perf_event__fprintf(event, stdout);
2182
b91fc39f 2183 thread__put(thread);
1a2725f3
AH		 2184
2185 return 0;
2186}
2187
2188static int print_event(struct perf_tool *tool, union perf_event *event,
2189 struct perf_sample *sample, struct machine *machine,
2190 pid_t pid, pid_t tid)
2191{
2192 return print_event_with_time(tool, event, sample, machine, pid, tid, 0);
2193}
2194
2195static int process_comm_event(struct perf_tool *tool,
2196 union perf_event *event,
2197 struct perf_sample *sample,
2198 struct machine *machine)
2199{
2200 if (perf_event__process_comm(tool, event, sample, machine) < 0)
2201 return -1;
2202
2203 return print_event(tool, event, sample, machine, event->comm.pid,
2204 event->comm.tid);
ad7ebb9a
NK		 2205}
2206
96a44bbc
HB		 2207static int process_namespaces_event(struct perf_tool *tool,
2208 union perf_event *event,
2209 struct perf_sample *sample,
2210 struct machine *machine)
2211{
96a44bbc 2212 if (perf_event__process_namespaces(tool, event, sample, machine) < 0)
1a2725f3 2213 return -1;
96a44bbc 2214
1a2725f3
AH		 2215 return print_event(tool, event, sample, machine, event->namespaces.pid,
2216 event->namespaces.tid);
96a44bbc
HB		 2217}
2218
160d4af9
NK		 2219static int process_cgroup_event(struct perf_tool *tool,
2220 union perf_event *event,
2221 struct perf_sample *sample,
2222 struct machine *machine)
2223{
160d4af9 2224 if (perf_event__process_cgroup(tool, event, sample, machine) < 0)
1a2725f3 2225 return -1;
160d4af9 2226
1a2725f3
AH		 2227 return print_event(tool, event, sample, machine, sample->pid,
2228 sample->tid);
160d4af9
NK		 2229}
2230
ad7ebb9a
NK		 2231static int process_fork_event(struct perf_tool *tool,
2232 union perf_event *event,
2233 struct perf_sample *sample,
2234 struct machine *machine)
2235{
ad7ebb9a
NK		 2236 if (perf_event__process_fork(tool, event, sample, machine) < 0)
2237 return -1;
2238
1a2725f3
AH		 2239 return print_event_with_time(tool, event, sample, machine,
2240 event->fork.pid, event->fork.tid,
2241 event->fork.time);
ad7ebb9a
NK		 2242}
2243static int process_exit_event(struct perf_tool *tool,
2244 union perf_event *event,
2245 struct perf_sample *sample,
2246 struct machine *machine)
2247{
1a2725f3
AH		 2248 /* Print before 'exit' deletes anything */
2249 if (print_event_with_time(tool, event, sample, machine, event->fork.pid,
2250 event->fork.tid, event->fork.time))
ad7ebb9a 2251 return -1;
ad7ebb9a 2252
1a2725f3 2253 return perf_event__process_exit(tool, event, sample, machine);
ad7ebb9a
NK		 2254}
2255
ba1ddf42
NK		 2256static int process_mmap_event(struct perf_tool *tool,
2257 union perf_event *event,
2258 struct perf_sample *sample,
2259 struct machine *machine)
2260{
ba1ddf42
NK		 2261 if (perf_event__process_mmap(tool, event, sample, machine) < 0)
2262 return -1;
2263
1a2725f3
AH		 2264 return print_event(tool, event, sample, machine, event->mmap.pid,
2265 event->mmap.tid);
ba1ddf42
NK		 2266}
2267
2268static int process_mmap2_event(struct perf_tool *tool,
2269 union perf_event *event,
2270 struct perf_sample *sample,
2271 struct machine *machine)
2272{
ba1ddf42
NK		 2273 if (perf_event__process_mmap2(tool, event, sample, machine) < 0)
2274 return -1;
2275
1a2725f3
AH		 2276 return print_event(tool, event, sample, machine, event->mmap2.pid,
2277 event->mmap2.tid);
ba1ddf42
NK		 2278}
2279
7c14898b
AH		 2280static int process_switch_event(struct perf_tool *tool,
2281 union perf_event *event,
2282 struct perf_sample *sample,
2283 struct machine *machine)
2284{
7c14898b 2285 struct perf_script *script = container_of(tool, struct perf_script, tool);
7c14898b
AH		 2286
2287 if (perf_event__process_switch(tool, event, sample, machine) < 0)
2288 return -1;
2289
5bf83c29
AH		 2290 if (scripting_ops && scripting_ops->process_switch)
2291 scripting_ops->process_switch(event, sample, machine);
2292
2293 if (!script->show_switch_events)
2294 return 0;
2295
1a2725f3
AH		 2296 return print_event(tool, event, sample, machine, sample->pid,
2297 sample->tid);
7c14898b
AH		 2298}
2299
3d7c27b6
JO		 2300static int
2301process_lost_event(struct perf_tool *tool,
2302 union perf_event *event,
2303 struct perf_sample *sample,
2304 struct machine *machine)
2305{
1a2725f3
AH		 2306 return print_event(tool, event, sample, machine, sample->pid,
2307 sample->tid);
3d7c27b6
JO		 2308}
2309
3233b37a
JO		 2310static int
2311process_finished_round_event(struct perf_tool *tool __maybe_unused,
2312 union perf_event *event,
2313 struct ordered_events *oe __maybe_unused)
2314
2315{
2316 perf_event__fprintf(event, stdout);
2317 return 0;
2318}
2319
490c8cc9
JO		 2320static int
2321process_bpf_events(struct perf_tool *tool __maybe_unused,
2322 union perf_event *event,
2323 struct perf_sample *sample,
2324 struct machine *machine)
2325{
490c8cc9
JO		 2326 if (machine__process_ksymbol(machine, event, sample) < 0)
2327 return -1;
2328
1a2725f3
AH		 2329 return print_event(tool, event, sample, machine, sample->pid,
2330 sample->tid);
490c8cc9
JO		 2331}
2332
1d037ca1 2333static void sig_handler(int sig __maybe_unused)
c239da3b
TZ		 2334{
2335 session_done = 1;
2336}
2337
a14390fd
ACM		 2338static void perf_script__fclose_per_event_dump(struct perf_script *script)
2339{
63503dba 2340 struct evlist *evlist = script->session->evlist;
32dcd021 2341 struct evsel *evsel;
a14390fd
ACM		 2342
2343 evlist__for_each_entry(evlist, evsel) {
2344 if (!evsel->priv)
2345 break;
642ee1c6 2346 perf_evsel_script__delete(evsel->priv);
a14390fd
ACM		 2347 evsel->priv = NULL;
2348 }
2349}
2350
2351static int perf_script__fopen_per_event_dump(struct perf_script *script)
2352{
32dcd021 2353 struct evsel *evsel;
a14390fd
ACM		 2354
2355 evlist__for_each_entry(script->session->evlist, evsel) {
fa48c892
ACM		 2356 /*
2357 * Already setup? I.e. we may be called twice in cases like
2358 * Intel PT, one for the intel_pt// and dummy events, then
2359 * for the evsels syntheized from the auxtrace info.
2360 *
2361 * Ses perf_script__process_auxtrace_info.
2362 */
2363 if (evsel->priv != NULL)
2364 continue;
2365
8ceb41d7 2366 evsel->priv = perf_evsel_script__new(evsel, script->session->data);
a14390fd
ACM		 2367 if (evsel->priv == NULL)
2368 goto out_err_fclose;
2369 }
2370
2371 return 0;
2372
2373out_err_fclose:
2374 perf_script__fclose_per_event_dump(script);
2375 return -1;
2376}
2377
2378static int perf_script__setup_per_event_dump(struct perf_script *script)
2379{
32dcd021
JO		 2380 struct evsel *evsel;
2381 static struct evsel_script es_stdout;
a14390fd
ACM		 2382
2383 if (script->per_event_dump)
2384 return perf_script__fopen_per_event_dump(script);
2385
642ee1c6
ACM		 2386 es_stdout.fp = stdout;
2387
a14390fd 2388 evlist__for_each_entry(script->session->evlist, evsel)
642ee1c6 2389 evsel->priv = &es_stdout;
a14390fd
ACM		 2390
2391 return 0;
2392}
2393
642ee1c6
ACM		 2394static void perf_script__exit_per_event_dump_stats(struct perf_script *script)
2395{
32dcd021 2396 struct evsel *evsel;
642ee1c6
ACM		 2397
2398 evlist__for_each_entry(script->session->evlist, evsel) {
32dcd021 2399 struct evsel_script *es = evsel->priv;
642ee1c6
ACM		 2400
2401 perf_evsel_script__fprintf(es, stdout);
2402 perf_evsel_script__delete(es);
2403 evsel->priv = NULL;
2404 }
2405}
2406
6f3e5eda 2407static int __cmd_script(struct perf_script *script)
5f9c39dc 2408{
6fcf7ddb
FW		 2409 int ret;
2410
c239da3b
TZ		 2411 signal(SIGINT, sig_handler);
2412
8bf8c6da
TJ		 2413 perf_stat__init_shadow_stats();
2414
ad7ebb9a
NK		 2415 /* override event processing functions */
2416 if (script->show_task_events) {
2417 script->tool.comm = process_comm_event;
2418 script->tool.fork = process_fork_event;
2419 script->tool.exit = process_exit_event;
2420 }
ba1ddf42
NK		 2421 if (script->show_mmap_events) {
2422 script->tool.mmap = process_mmap_event;
2423 script->tool.mmap2 = process_mmap2_event;
2424 }
5bf83c29 2425 if (script->show_switch_events || (scripting_ops && scripting_ops->process_switch))
7c14898b 2426 script->tool.context_switch = process_switch_event;
96a44bbc
HB		 2427 if (script->show_namespace_events)
2428 script->tool.namespaces = process_namespaces_event;
160d4af9
NK		 2429 if (script->show_cgroup_events)
2430 script->tool.cgroup = process_cgroup_event;
3d7c27b6
JO		 2431 if (script->show_lost_events)
2432 script->tool.lost = process_lost_event;
3233b37a
JO		 2433 if (script->show_round_events) {
2434 script->tool.ordered_events = false;
2435 script->tool.finished_round = process_finished_round_event;
2436 }
490c8cc9 2437 if (script->show_bpf_events) {
3f604b5f
ACM		 2438 script->tool.ksymbol = process_bpf_events;
2439 script->tool.bpf = process_bpf_events;
490c8cc9 2440 }
ad7ebb9a 2441
a14390fd
ACM		 2442 if (perf_script__setup_per_event_dump(script)) {
2443 pr_err("Couldn't create the per event dump files\n");
2444 return -1;
2445 }
2446
b7b61cbe 2447 ret = perf_session__process_events(script->session);
6fcf7ddb 2448
a14390fd 2449 if (script->per_event_dump)
642ee1c6 2450 perf_script__exit_per_event_dump_stats(script);
a14390fd 2451
6d8afb56 2452 if (debug_mode)
9486aa38 2453 pr_err("Misordered timestamps: %" PRIu64 "\n", nr_unordered);
6fcf7ddb
FW		 2454
2455 return ret;
5f9c39dc
FW		 2456}
2457
956ffd02
TZ		 2458struct script_spec {
2459 struct list_head node;
2460 struct scripting_ops *ops;
6549a8c0 2461 char spec[];
956ffd02
TZ		 2462};
2463
eccdfe2d 2464static LIST_HEAD(script_specs);
956ffd02
TZ		 2465
2466static struct script_spec *script_spec__new(const char *spec,
2467 struct scripting_ops *ops)
2468{
2469 struct script_spec *s = malloc(sizeof(*s) + strlen(spec) + 1);
2470
2471 if (s != NULL) {
2472 strcpy(s->spec, spec);
2473 s->ops = ops;
2474 }
2475
2476 return s;
2477}
2478
956ffd02
TZ		 2479static void script_spec__add(struct script_spec *s)
2480{
2481 list_add_tail(&s->node, &script_specs);
2482}
2483
2484static struct script_spec *script_spec__find(const char *spec)
2485{
2486 struct script_spec *s;
2487
2488 list_for_each_entry(s, &script_specs, node)
2489 if (strcasecmp(s->spec, spec) == 0)
2490 return s;
2491 return NULL;
2492}
2493
956ffd02
TZ		 2494int script_spec_register(const char *spec, struct scripting_ops *ops)
2495{
2496 struct script_spec *s;
2497
2498 s = script_spec__find(spec);
2499 if (s)
2500 return -1;
2501
8560bae0 2502 s = script_spec__new(spec, ops);
956ffd02
TZ		 2503 if (!s)
2504 return -1;
8560bae0
TS		 2505 else
2506 script_spec__add(s);
956ffd02
TZ		 2507
2508 return 0;
2509}
2510
2511static struct scripting_ops *script_spec__lookup(const char *spec)
2512{
2513 struct script_spec *s = script_spec__find(spec);
2514 if (!s)
2515 return NULL;
2516
2517 return s->ops;
2518}
2519
2520static void list_available_languages(void)
2521{
2522 struct script_spec *s;
2523
2524 fprintf(stderr, "\n");
2525 fprintf(stderr, "Scripting language extensions (used in "
133dc4c3 2526 "perf script -s [spec:]script.[spec]):\n\n");
956ffd02
TZ		 2527
2528 list_for_each_entry(s, &script_specs, node)
2529 fprintf(stderr, " %-42s [%s]\n", s->spec, s->ops->name);
2530
2531 fprintf(stderr, "\n");
2532}
2533
1d037ca1
IT		 2534static int parse_scriptname(const struct option *opt __maybe_unused,
2535 const char *str, int unset __maybe_unused)
956ffd02
TZ		 2536{
2537 char spec[PATH_MAX];
2538 const char *script, *ext;
2539 int len;
2540
f526d68b 2541 if (strcmp(str, "lang") == 0) {
956ffd02 2542 list_available_languages();
f526d68b 2543 exit(0);
956ffd02
TZ		 2544 }
2545
2546 script = strchr(str, ':');
2547 if (script) {
2548 len = script - str;
2549 if (len >= PATH_MAX) {
2550 fprintf(stderr, "invalid language specifier");
2551 return -1;
2552 }
2553 strncpy(spec, str, len);
2554 spec[len] = '\0';
2555 scripting_ops = script_spec__lookup(spec);
2556 if (!scripting_ops) {
2557 fprintf(stderr, "invalid language specifier");
2558 return -1;
2559 }
2560 script++;
2561 } else {
2562 script = str;
d1e95bb5 2563 ext = strrchr(script, '.');
956ffd02
TZ		 2564 if (!ext) {
2565 fprintf(stderr, "invalid script extension");
2566 return -1;
2567 }
2568 scripting_ops = script_spec__lookup(++ext);
2569 if (!scripting_ops) {
2570 fprintf(stderr, "invalid script extension");
2571 return -1;
2572 }
2573 }
2574
2575 script_name = strdup(script);
2576
2577 return 0;
2578}
2579
1d037ca1
IT		 2580static int parse_output_fields(const struct option *opt __maybe_unused,
2581 const char *arg, int unset __maybe_unused)
745f43e3 2582{
49346e85 2583 char *tok, *strtok_saveptr = NULL;
50ca19ae 2584 int i, imax = ARRAY_SIZE(all_output_options);
2c9e45f7 2585 int j;
745f43e3
DA		 2586 int rc = 0;
2587 char *str = strdup(arg);
1424dc96 2588 int type = -1;
36ce5651 2589 enum { DEFAULT, SET, ADD, REMOVE } change = DEFAULT;
745f43e3
DA		 2590
2591 if (!str)
2592 return -ENOMEM;
2593
2c9e45f7
DA		 2594 /* first word can state for which event type the user is specifying
2595 * the fields. If no type exists, the specified fields apply to all
2596 * event types found in the file minus the invalid fields for a type.
1424dc96 2597 */
2c9e45f7
DA		 2598 tok = strchr(str, ':');
2599 if (tok) {
2600 *tok = '\0';
2601 tok++;
2602 if (!strcmp(str, "hw"))
2603 type = PERF_TYPE_HARDWARE;
2604 else if (!strcmp(str, "sw"))
2605 type = PERF_TYPE_SOFTWARE;
2606 else if (!strcmp(str, "trace"))
2607 type = PERF_TYPE_TRACEPOINT;
0817a6a3
AS		 2608 else if (!strcmp(str, "raw"))
2609 type = PERF_TYPE_RAW;
27cfef00
WN		 2610 else if (!strcmp(str, "break"))
2611 type = PERF_TYPE_BREAKPOINT;
1405720d
AH		 2612 else if (!strcmp(str, "synth"))
2613 type = OUTPUT_TYPE_SYNTH;
2c9e45f7
DA		 2614 else {
2615 fprintf(stderr, "Invalid event type in field string.\n");
38efb539
RR		 2616 rc = -EINVAL;
2617 goto out;
2c9e45f7
DA		 2618 }
2619
2620 if (output[type].user_set)
2621 pr_warning("Overriding previous field request for %s events.\n",
2622 event_type(type));
2623
6ef362fd
JO		 2624 /* Don't override defaults for +- */
2625 if (strchr(tok, '+') || strchr(tok, '-'))
2626 goto parse;
2627
2c9e45f7
DA		 2628 output[type].fields = 0;
2629 output[type].user_set = true;
9cbdb702 2630 output[type].wildcard_set = false;
2c9e45f7
DA		 2631
2632 } else {
2633 tok = str;
2634 if (strlen(str) == 0) {
2635 fprintf(stderr,
2636 "Cannot set fields to 'none' for all event types.\n");
2637 rc = -EINVAL;
2638 goto out;
2639 }
2640
36ce5651
AK		 2641 /* Don't override defaults for +- */
2642 if (strchr(str, '+') || strchr(str, '-'))
2643 goto parse;
2644
2c9e45f7
DA		 2645 if (output_set_by_user())
2646 pr_warning("Overriding previous field request for all events.\n");
2647
1405720d 2648 for (j = 0; j < OUTPUT_TYPE_MAX; ++j) {
2c9e45f7
DA		 2649 output[j].fields = 0;
2650 output[j].user_set = true;
9cbdb702 2651 output[j].wildcard_set = true;
2c9e45f7 2652 }
745f43e3
DA		 2653 }
2654
36ce5651 2655parse:
49346e85 2656 for (tok = strtok_r(tok, ",", &strtok_saveptr); tok; tok = strtok_r(NULL, ",", &strtok_saveptr)) {
36ce5651
AK		 2657 if (*tok == '+') {
2658 if (change == SET)
2659 goto out_badmix;
2660 change = ADD;
2661 tok++;
2662 } else if (*tok == '-') {
2663 if (change == SET)
2664 goto out_badmix;
2665 change = REMOVE;
2666 tok++;
2667 } else {
2668 if (change != SET && change != DEFAULT)
2669 goto out_badmix;
2670 change = SET;
2671 }
2672
745f43e3 2673 for (i = 0; i < imax; ++i) {
2c9e45f7 2674 if (strcmp(tok, all_output_options[i].str) == 0)
745f43e3 2675 break;
745f43e3 2676 }
400ea6d3 2677 if (i == imax && strcmp(tok, "flags") == 0) {
36ce5651 2678 print_flags = change == REMOVE ? false : true;
400ea6d3
AH		 2679 continue;
2680 }
745f43e3 2681 if (i == imax) {
2c9e45f7 2682 fprintf(stderr, "Invalid field requested.\n");
745f43e3 2683 rc = -EINVAL;
2c9e45f7 2684 goto out;
745f43e3
DA		 2685 }
2686
2c9e45f7
DA		 2687 if (type == -1) {
2688 /* add user option to all events types for
2689 * which it is valid
2690 */
1405720d 2691 for (j = 0; j < OUTPUT_TYPE_MAX; ++j) {
2c9e45f7
DA		 2692 if (output[j].invalid_fields & all_output_options[i].field) {
2693 pr_warning("\'%s\' not valid for %s events. Ignoring.\n",
2694 all_output_options[i].str, event_type(j));
36ce5651 2695 } else {
4b6ac811 2696 if (change == REMOVE) {
36ce5651 2697 output[j].fields &= ~all_output_options[i].field;
4b6ac811 2698 output[j].user_set_fields &= ~all_output_options[i].field;
b5164085 2699 output[j].user_unset_fields |= all_output_options[i].field;
4b6ac811 2700 } else {
36ce5651 2701 output[j].fields |= all_output_options[i].field;
4b6ac811 2702 output[j].user_set_fields |= all_output_options[i].field;
b5164085 2703 output[j].user_unset_fields &= ~all_output_options[i].field;
4b6ac811 2704 }
37fed3de
AK		 2705 output[j].user_set = true;
2706 output[j].wildcard_set = true;
36ce5651 2707 }
2c9e45f7
DA		 2708 }
2709 } else {
2710 if (output[type].invalid_fields & all_output_options[i].field) {
2711 fprintf(stderr, "\'%s\' not valid for %s events.\n",
2712 all_output_options[i].str, event_type(type));
2713
2714 rc = -EINVAL;
2715 goto out;
2716 }
6ef362fd
JO		 2717 if (change == REMOVE)
2718 output[type].fields &= ~all_output_options[i].field;
2719 else
2720 output[type].fields |= all_output_options[i].field;
37fed3de
AK		 2721 output[type].user_set = true;
2722 output[type].wildcard_set = true;
2c9e45f7 2723 }
745f43e3
DA		 2724 }
2725
2c9e45f7
DA		 2726 if (type >= 0) {
2727 if (output[type].fields == 0) {
2728 pr_debug("No fields requested for %s type. "
2729 "Events will not be displayed.\n", event_type(type));
2730 }
2731 }
36ce5651 2732 goto out;
745f43e3 2733
36ce5651
AK		 2734out_badmix:
2735 fprintf(stderr, "Cannot mix +-field with overridden fields\n");
2736 rc = -EINVAL;
2c9e45f7 2737out:
745f43e3
DA		 2738 free(str);
2739 return rc;
2740}
2741
a5e8e825
ACM		 2742#define for_each_lang(scripts_path, scripts_dir, lang_dirent) \
2743 while ((lang_dirent = readdir(scripts_dir)) != NULL) \
2744 if ((lang_dirent->d_type == DT_DIR || \
2745 (lang_dirent->d_type == DT_UNKNOWN && \
2746 is_directory(scripts_path, lang_dirent))) && \
2747 (strcmp(lang_dirent->d_name, ".")) && \
2748 (strcmp(lang_dirent->d_name, "..")))
2749
2750#define for_each_script(lang_path, lang_dir, script_dirent) \
2751 while ((script_dirent = readdir(lang_dir)) != NULL) \
2752 if (script_dirent->d_type != DT_DIR && \
2753 (script_dirent->d_type != DT_UNKNOWN || \
2754 !is_directory(lang_path, script_dirent)))
4b9c0c59
TZ		 2755
2756
2757#define RECORD_SUFFIX "-record"
2758#define REPORT_SUFFIX "-report"
2759
2760struct script_desc {
2761 struct list_head node;
2762 char *name;
2763 char *half_liner;
2764 char *args;
2765};
2766
eccdfe2d 2767static LIST_HEAD(script_descs);
4b9c0c59
TZ		 2768
2769static struct script_desc *script_desc__new(const char *name)
2770{
2771 struct script_desc *s = zalloc(sizeof(*s));
2772
b5b87312 2773 if (s != NULL && name)
4b9c0c59
TZ		 2774 s->name = strdup(name);
2775
2776 return s;
2777}
2778
2779static void script_desc__delete(struct script_desc *s)
2780{
74cf249d
ACM		 2781 zfree(&s->name);
2782 zfree(&s->half_liner);
2783 zfree(&s->args);
4b9c0c59
TZ		 2784 free(s);
2785}
2786
2787static void script_desc__add(struct script_desc *s)
2788{
2789 list_add_tail(&s->node, &script_descs);
2790}
2791
2792static struct script_desc *script_desc__find(const char *name)
2793{
2794 struct script_desc *s;
2795
2796 list_for_each_entry(s, &script_descs, node)
2797 if (strcasecmp(s->name, name) == 0)
2798 return s;
2799 return NULL;
2800}
2801
2802static struct script_desc *script_desc__findnew(const char *name)
2803{
2804 struct script_desc *s = script_desc__find(name);
2805
2806 if (s)
2807 return s;
2808
2809 s = script_desc__new(name);
2810 if (!s)
2ec5cab6 2811 return NULL;
4b9c0c59
TZ		 2812
2813 script_desc__add(s);
2814
2815 return s;
4b9c0c59
TZ		 2816}
2817
965bb6be 2818static const char *ends_with(const char *str, const char *suffix)
4b9c0c59
TZ		 2819{
2820 size_t suffix_len = strlen(suffix);
965bb6be 2821 const char *p = str;
4b9c0c59
TZ		 2822
2823 if (strlen(str) > suffix_len) {
2824 p = str + strlen(str) - suffix_len;
2825 if (!strncmp(p, suffix, suffix_len))
2826 return p;
2827 }
2828
2829 return NULL;
2830}
2831
4b9c0c59
TZ		 2832static int read_script_info(struct script_desc *desc, const char *filename)
2833{
2834 char line[BUFSIZ], *p;
2835 FILE *fp;
2836
2837 fp = fopen(filename, "r");
2838 if (!fp)
2839 return -1;
2840
2841 while (fgets(line, sizeof(line), fp)) {
32858480 2842 p = skip_spaces(line);
4b9c0c59
TZ		 2843 if (strlen(p) == 0)
2844 continue;
2845 if (*p != '#')
2846 continue;
2847 p++;
2848 if (strlen(p) && *p == '!')
2849 continue;
2850
32858480 2851 p = skip_spaces(p);
4b9c0c59
TZ		 2852 if (strlen(p) && p[strlen(p) - 1] == '\n')
2853 p[strlen(p) - 1] = '\0';
2854
2855 if (!strncmp(p, "description:", strlen("description:"))) {
2856 p += strlen("description:");
32858480 2857 desc->half_liner = strdup(skip_spaces(p));
4b9c0c59
TZ		 2858 continue;
2859 }
2860
2861 if (!strncmp(p, "args:", strlen("args:"))) {
2862 p += strlen("args:");
32858480 2863 desc->args = strdup(skip_spaces(p));
4b9c0c59
TZ		 2864 continue;
2865 }
2866 }
2867
2868 fclose(fp);
2869
2870 return 0;
2871}
2872
38efb539
RR		 2873static char *get_script_root(struct dirent *script_dirent, const char *suffix)
2874{
2875 char *script_root, *str;
2876
2877 script_root = strdup(script_dirent->d_name);
2878 if (!script_root)
2879 return NULL;
2880
2881 str = (char *)ends_with(script_root, suffix);
2882 if (!str) {
2883 free(script_root);
2884 return NULL;
2885 }
2886
2887 *str = '\0';
2888 return script_root;
2889}
2890
1d037ca1
IT		 2891static int list_available_scripts(const struct option *opt __maybe_unused,
2892 const char *s __maybe_unused,
2893 int unset __maybe_unused)
4b9c0c59 2894{
a5e8e825 2895 struct dirent *script_dirent, *lang_dirent;
4b9c0c59
TZ		 2896 char scripts_path[MAXPATHLEN];
2897 DIR *scripts_dir, *lang_dir;
2898 char script_path[MAXPATHLEN];
2899 char lang_path[MAXPATHLEN];
2900 struct script_desc *desc;
2901 char first_half[BUFSIZ];
2902 char *script_root;
4b9c0c59 2903
46113a54 2904 snprintf(scripts_path, MAXPATHLEN, "%s/scripts", get_argv_exec_path());
4b9c0c59
TZ		 2905
2906 scripts_dir = opendir(scripts_path);
88ded4d8
HK		 2907 if (!scripts_dir) {
2908 fprintf(stdout,
2909 "open(%s) failed.\n"
2910 "Check \"PERF_EXEC_PATH\" env to set scripts dir.\n",
2911 scripts_path);
2912 exit(-1);
2913 }
4b9c0c59 2914
a5e8e825 2915 for_each_lang(scripts_path, scripts_dir, lang_dirent) {
77f18153
JO		 2916 scnprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path,
2917 lang_dirent->d_name);
4b9c0c59
TZ		 2918 lang_dir = opendir(lang_path);
2919 if (!lang_dir)
2920 continue;
2921
a5e8e825
ACM		 2922 for_each_script(lang_path, lang_dir, script_dirent) {
2923 script_root = get_script_root(script_dirent, REPORT_SUFFIX);
38efb539 2924 if (script_root) {
4b9c0c59 2925 desc = script_desc__findnew(script_root);
77f18153
JO		 2926 scnprintf(script_path, MAXPATHLEN, "%s/%s",
2927 lang_path, script_dirent->d_name);
4b9c0c59 2928 read_script_info(desc, script_path);
38efb539 2929 free(script_root);
4b9c0c59 2930 }
4b9c0c59
TZ		 2931 }
2932 }
2933
2934 fprintf(stdout, "List of available trace scripts:\n");
2935 list_for_each_entry(desc, &script_descs, node) {
2936 sprintf(first_half, "%s %s", desc->name,
2937 desc->args ? desc->args : "");
2938 fprintf(stdout, " %-36s %s\n", first_half,
2939 desc->half_liner ? desc->half_liner : "");
2940 }
2941
2942 exit(0);
2943}
2944
49e639e2
FT		 2945/*
2946 * Some scripts specify the required events in their "xxx-record" file,
2947 * this function will check if the events in perf.data match those
2948 * mentioned in the "xxx-record".
2949 *
2950 * Fixme: All existing "xxx-record" are all in good formats "-e event ",
2951 * which is covered well now. And new parsing code should be added to
2952 * cover the future complexing formats like event groups etc.
2953 */
2954static int check_ev_match(char *dir_name, char *scriptname,
2955 struct perf_session *session)
2956{
2957 char filename[MAXPATHLEN], evname[128];
2958 char line[BUFSIZ], *p;
32dcd021 2959 struct evsel *pos;
49e639e2
FT		 2960 int match, len;
2961 FILE *fp;
2962
77f18153 2963 scnprintf(filename, MAXPATHLEN, "%s/bin/%s-record", dir_name, scriptname);
49e639e2
FT		 2964
2965 fp = fopen(filename, "r");
2966 if (!fp)
2967 return -1;
2968
2969 while (fgets(line, sizeof(line), fp)) {
32858480 2970 p = skip_spaces(line);
49e639e2
FT		 2971 if (*p == '#')
2972 continue;
2973
2974 while (strlen(p)) {
2975 p = strstr(p, "-e");
2976 if (!p)
2977 break;
2978
2979 p += 2;
32858480 2980 p = skip_spaces(p);
49e639e2
FT		 2981 len = strcspn(p, " \t");
2982 if (!len)
2983 break;
2984
2985 snprintf(evname, len + 1, "%s", p);
2986
2987 match = 0;
e5cadb93 2988 evlist__for_each_entry(session->evlist, pos) {
8ab2e96d 2989 if (!strcmp(evsel__name(pos), evname)) {
49e639e2
FT		 2990 match = 1;
2991 break;
2992 }
2993 }
2994
2995 if (!match) {
2996 fclose(fp);
2997 return -1;
2998 }
2999 }
3000 }
3001
3002 fclose(fp);
3003 return 0;
3004}
3005
e5f3705e
FT		 3006/*
3007 * Return -1 if none is found, otherwise the actual scripts number.
3008 *
3009 * Currently the only user of this function is the script browser, which
3010 * will list all statically runnable scripts, select one, execute it and
3011 * show the output in a perf browser.
3012 */
905e4aff
AK		 3013int find_scripts(char **scripts_array, char **scripts_path_array, int num,
3014 int pathlen)
e5f3705e 3015{
a5e8e825 3016 struct dirent *script_dirent, *lang_dirent;
49e639e2 3017 char scripts_path[MAXPATHLEN], lang_path[MAXPATHLEN];
e5f3705e 3018 DIR *scripts_dir, *lang_dir;
49e639e2 3019 struct perf_session *session;
8ceb41d7 3020 struct perf_data data = {
2d4f2799
JO		 3021 .path = input_name,
3022 .mode = PERF_DATA_MODE_READ,
f5fc1412 3023 };
e5f3705e
FT		 3024 char *temp;
3025 int i = 0;
3026
8ceb41d7 3027 session = perf_session__new(&data, false, NULL);
6ef81c55
MI		 3028 if (IS_ERR(session))
3029 return PTR_ERR(session);
49e639e2 3030
46113a54 3031 snprintf(scripts_path, MAXPATHLEN, "%s/scripts", get_argv_exec_path());
e5f3705e
FT		 3032
3033 scripts_dir = opendir(scripts_path);
49e639e2
FT		 3034 if (!scripts_dir) {
3035 perf_session__delete(session);
e5f3705e 3036 return -1;
49e639e2 3037 }
e5f3705e 3038
a5e8e825 3039 for_each_lang(scripts_path, scripts_dir, lang_dirent) {
77f18153
JO		 3040 scnprintf(lang_path, MAXPATHLEN, "%s/%s", scripts_path,
3041 lang_dirent->d_name);
90ce61b9 3042#ifndef HAVE_LIBPERL_SUPPORT
e5f3705e
FT		 3043 if (strstr(lang_path, "perl"))
3044 continue;
3045#endif
90ce61b9 3046#ifndef HAVE_LIBPYTHON_SUPPORT
e5f3705e
FT		 3047 if (strstr(lang_path, "python"))
3048 continue;
3049#endif
3050
3051 lang_dir = opendir(lang_path);
3052 if (!lang_dir)
3053 continue;
3054
a5e8e825 3055 for_each_script(lang_path, lang_dir, script_dirent) {
e5f3705e 3056 /* Skip those real time scripts: xxxtop.p[yl] */
a5e8e825 3057 if (strstr(script_dirent->d_name, "top."))
e5f3705e 3058 continue;
905e4aff
AK		 3059 if (i >= num)
3060 break;
3061 snprintf(scripts_path_array[i], pathlen, "%s/%s",
3062 lang_path,
a5e8e825
ACM		 3063 script_dirent->d_name);
3064 temp = strchr(script_dirent->d_name, '.');
e5f3705e 3065 snprintf(scripts_array[i],
a5e8e825
ACM		 3066 (temp - script_dirent->d_name) + 1,
3067 "%s", script_dirent->d_name);
49e639e2
FT		 3068
3069 if (check_ev_match(lang_path,
3070 scripts_array[i], session))
3071 continue;
3072
e5f3705e
FT		 3073 i++;
3074 }
49e639e2 3075 closedir(lang_dir);
e5f3705e
FT		 3076 }
3077
49e639e2
FT		 3078 closedir(scripts_dir);
3079 perf_session__delete(session);
e5f3705e
FT		 3080 return i;
3081}
3082
3875294f
TZ		 3083static char *get_script_path(const char *script_root, const char *suffix)
3084{
a5e8e825 3085 struct dirent *script_dirent, *lang_dirent;
3875294f
TZ		 3086 char scripts_path[MAXPATHLEN];
3087 char script_path[MAXPATHLEN];
3088 DIR *scripts_dir, *lang_dir;
3089 char lang_path[MAXPATHLEN];
38efb539 3090 char *__script_root;
3875294f 3091
46113a54 3092 snprintf(scripts_path, MAXPATHLEN, "%s/scripts", get_argv_exec_path());
3875294f
TZ		 3093
3094 scripts_dir = opendir(scripts_path);
3095 if (!scripts_dir)
3096 return NULL;
3097
a5e8e825 3098 for_each_lang(scripts_path, scripts_dir, lang_dirent) {
77f18153
JO		 3099 scnprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path,
3100 lang_dirent->d_name);
3875294f
TZ		 3101 lang_dir = opendir(lang_path);
3102 if (!lang_dir)
3103 continue;
3104
a5e8e825
ACM		 3105 for_each_script(lang_path, lang_dir, script_dirent) {
3106 __script_root = get_script_root(script_dirent, suffix);
38efb539
RR		 3107 if (__script_root && !strcmp(script_root, __script_root)) {
3108 free(__script_root);
946ef2a2 3109 closedir(scripts_dir);
77f18153
JO		 3110 scnprintf(script_path, MAXPATHLEN, "%s/%s",
3111 lang_path, script_dirent->d_name);
27486a85 3112 closedir(lang_dir);
38efb539 3113 return strdup(script_path);
3875294f
TZ		 3114 }
3115 free(__script_root);
3116 }
946ef2a2 3117 closedir(lang_dir);
3875294f 3118 }
946ef2a2 3119 closedir(scripts_dir);
3875294f 3120
38efb539 3121 return NULL;
3875294f
TZ		 3122}
3123
b5b87312
TZ		 3124static bool is_top_script(const char *script_path)
3125{
965bb6be 3126 return ends_with(script_path, "top") == NULL ? false : true;
b5b87312
TZ		 3127}
3128
3129static int has_required_arg(char *script_path)
3130{
3131 struct script_desc *desc;
3132 int n_args = 0;
3133 char *p;
3134
3135 desc = script_desc__new(NULL);
3136
3137 if (read_script_info(desc, script_path))
3138 goto out;
3139
3140 if (!desc->args)
3141 goto out;
3142
3143 for (p = desc->args; *p; p++)
3144 if (*p == '<')
3145 n_args++;
3146out:
3147 script_desc__delete(desc);
3148
3149 return n_args;
3150}
3151
69b6470e
ACM		 3152static int have_cmd(int argc, const char **argv)
3153{
3154 char **__argv = malloc(sizeof(const char *) * argc);
3155
3156 if (!__argv) {
3157 pr_err("malloc failed\n");
3158 return -1;
3159 }
3160
3161 memcpy(__argv, argv, sizeof(const char *) * argc);
3162 argc = parse_options(argc, (const char **)__argv, record_options,
3163 NULL, PARSE_OPT_STOP_AT_NON_OPTION);
3164 free(__argv);
5f9c39dc 3165
69b6470e
ACM		 3166 system_wide = (argc == 0);
3167
3168 return 0;
3169}
3170
7322d6c9
JO		 3171static void script__setup_sample_type(struct perf_script *script)
3172{
3173 struct perf_session *session = script->session;
3174 u64 sample_type = perf_evlist__combined_sample_type(session->evlist);
3175
3176 if (symbol_conf.use_callchain || symbol_conf.cumulate_callchain) {
3177 if ((sample_type & PERF_SAMPLE_REGS_USER) &&
eabad8c6 3178 (sample_type & PERF_SAMPLE_STACK_USER)) {
7322d6c9 3179 callchain_param.record_mode = CALLCHAIN_DWARF;
eabad8c6
ACM		 3180 dwarf_callchain_users = true;
3181 } else if (sample_type & PERF_SAMPLE_BRANCH_STACK)
7322d6c9
JO		 3182 callchain_param.record_mode = CALLCHAIN_LBR;
3183 else
3184 callchain_param.record_mode = CALLCHAIN_FP;
3185 }
680d125c
KL		 3186
3187 if (script->stitch_lbr && (callchain_param.record_mode != CALLCHAIN_LBR)) {
3188 pr_warning("Can't find LBR callchain. Switch off --stitch-lbr.\n"
3189 "Please apply --call-graph lbr when recording.\n");
3190 script->stitch_lbr = false;
3191 }
7322d6c9
JO		 3192}
3193
89f1688a
JO		 3194static int process_stat_round_event(struct perf_session *session,
3195 union perf_event *event)
e099eba8 3196{
72932371 3197 struct perf_record_stat_round *round = &event->stat_round;
32dcd021 3198 struct evsel *counter;
e099eba8 3199
e5cadb93 3200 evlist__for_each_entry(session->evlist, counter) {
e099eba8
JO		 3201 perf_stat_process_counter(&stat_config, counter);
3202 process_stat(counter, round->time);
3203 }
3204
3205 process_stat_interval(round->time);
3206 return 0;
3207}
3208
89f1688a
JO		 3209static int process_stat_config_event(struct perf_session *session __maybe_unused,
3210 union perf_event *event)
91a2c3d5
JO		 3211{
3212 perf_event__read_stat_config(&stat_config, &event->stat_config);
3213 return 0;
3214}
3215
cfc8874a
JO		 3216static int set_maps(struct perf_script *script)
3217{
63503dba 3218 struct evlist *evlist = script->session->evlist;
cfc8874a
JO		 3219
3220 if (!script->cpus || !script->threads)
3221 return 0;
3222
3223 if (WARN_ONCE(script->allocated, "stats double allocation\n"))
3224 return -EINVAL;
3225
453fa030 3226 perf_evlist__set_maps(&evlist->core, script->cpus, script->threads);
cfc8874a
JO		 3227
3228 if (perf_evlist__alloc_stats(evlist, true))
3229 return -ENOMEM;
3230
3231 script->allocated = true;
3232 return 0;
3233}
3234
3235static
89f1688a
JO		 3236int process_thread_map_event(struct perf_session *session,
3237 union perf_event *event)
cfc8874a 3238{
89f1688a 3239 struct perf_tool *tool = session->tool;
cfc8874a
JO		 3240 struct perf_script *script = container_of(tool, struct perf_script, tool);
3241
3242 if (script->threads) {
3243 pr_warning("Extra thread map event, ignoring.\n");
3244 return 0;
3245 }
3246
3247 script->threads = thread_map__new_event(&event->thread_map);
3248 if (!script->threads)
3249 return -ENOMEM;
3250
3251 return set_maps(script);
3252}
3253
3254static
89f1688a
JO		 3255int process_cpu_map_event(struct perf_session *session,
3256 union perf_event *event)
cfc8874a 3257{
89f1688a 3258 struct perf_tool *tool = session->tool;
cfc8874a
JO		 3259 struct perf_script *script = container_of(tool, struct perf_script, tool);
3260
3261 if (script->cpus) {
3262 pr_warning("Extra cpu map event, ignoring.\n");
3263 return 0;
3264 }
3265
3266 script->cpus = cpu_map__new_data(&event->cpu_map.data);
3267 if (!script->cpus)
3268 return -ENOMEM;
3269
3270 return set_maps(script);
3271}
3272
89f1688a
JO		 3273static int process_feature_event(struct perf_session *session,
3274 union perf_event *event)
92ead7ee
RB		 3275{
3276 if (event->feat.feat_id < HEADER_LAST_FEATURE)
89f1688a 3277 return perf_event__process_feature(session, event);
92ead7ee
RB		 3278 return 0;
3279}
3280
fa48c892 3281#ifdef HAVE_AUXTRACE_SUPPORT
89f1688a
JO		 3282static int perf_script__process_auxtrace_info(struct perf_session *session,
3283 union perf_event *event)
fa48c892 3284{
89f1688a
JO		 3285 struct perf_tool *tool = session->tool;
3286
3287 int ret = perf_event__process_auxtrace_info(session, event);
fa48c892
ACM		 3288
3289 if (ret == 0) {
3290 struct perf_script *script = container_of(tool, struct perf_script, tool);
3291
3292 ret = perf_script__setup_per_event_dump(script);
3293 }
3294
3295 return ret;
3296}
3297#else
3298#define perf_script__process_auxtrace_info 0
3299#endif
3300
b585ebdb
AK		 3301static int parse_insn_trace(const struct option *opt __maybe_unused,
3302 const char *str __maybe_unused,
3303 int unset __maybe_unused)
3304{
3305 parse_output_fields(NULL, "+insn,-event,-period", 0);
3306 itrace_parse_synth_opts(opt, "i0ns", 0);
52bab886 3307 symbol_conf.nanosecs = true;
b585ebdb
AK		 3308 return 0;
3309}
3310
3311static int parse_xed(const struct option *opt __maybe_unused,
3312 const char *str __maybe_unused,
3313 int unset __maybe_unused)
3314{
8c3e05c8
AK		 3315 if (isatty(1))
3316 force_pager("xed -F insn: -A -64 | less");
3317 else
3318 force_pager("xed -F insn: -A -64");
b585ebdb
AK		 3319 return 0;
3320}
3321
d1b1552e
AK		 3322static int parse_call_trace(const struct option *opt __maybe_unused,
3323 const char *str __maybe_unused,
3324 int unset __maybe_unused)
3325{
3326 parse_output_fields(NULL, "-ip,-addr,-event,-period,+callindent", 0);
3327 itrace_parse_synth_opts(opt, "cewp", 0);
52bab886 3328 symbol_conf.nanosecs = true;
1c492422 3329 symbol_conf.pad_output_len_dso = 50;
d1b1552e
AK		 3330 return 0;
3331}
3332
3333static int parse_callret_trace(const struct option *opt __maybe_unused,
3334 const char *str __maybe_unused,
3335 int unset __maybe_unused)
3336{
3337 parse_output_fields(NULL, "-ip,-addr,-event,-period,+callindent,+flags", 0);
3338 itrace_parse_synth_opts(opt, "crewp", 0);
52bab886 3339 symbol_conf.nanosecs = true;
d1b1552e
AK		 3340 return 0;
3341}
3342
b0ad8ea6 3343int cmd_script(int argc, const char **argv)
69b6470e
ACM		 3344{
3345 bool show_full_info = false;
e90debdd
JO		 3346 bool header = false;
3347 bool header_only = false;
6cc870f0 3348 bool script_started = false;
69b6470e
ACM		 3349 char *rec_script_path = NULL;
3350 char *rep_script_path = NULL;
3351 struct perf_session *session;
4eb06815
AK		 3352 struct itrace_synth_opts itrace_synth_opts = {
3353 .set = false,
3354 .default_no_sample = true,
3355 };
3ab481a1 3356 struct utsname uts;
69b6470e
ACM		 3357 char *script_path = NULL;
3358 const char **__argv;
6cc870f0 3359 int i, j, err = 0;
6f3e5eda
AH		 3360 struct perf_script script = {
3361 .tool = {
3362 .sample = process_sample_event,
3363 .mmap = perf_event__process_mmap,
3364 .mmap2 = perf_event__process_mmap2,
3365 .comm = perf_event__process_comm,
f3b3614a 3366 .namespaces = perf_event__process_namespaces,
160d4af9 3367 .cgroup = perf_event__process_cgroup,
6f3e5eda
AH		 3368 .exit = perf_event__process_exit,
3369 .fork = perf_event__process_fork,
7ea95727 3370 .attr = process_attr,
91daee30 3371 .event_update = perf_event__process_event_update,
6f3e5eda 3372 .tracing_data = perf_event__process_tracing_data,
92ead7ee 3373 .feature = process_feature_event,
6f3e5eda 3374 .build_id = perf_event__process_build_id,
7a680eb9 3375 .id_index = perf_event__process_id_index,
fa48c892 3376 .auxtrace_info = perf_script__process_auxtrace_info,
7a680eb9
AH		 3377 .auxtrace = perf_event__process_auxtrace,
3378 .auxtrace_error = perf_event__process_auxtrace_error,
e099eba8
JO		 3379 .stat = perf_event__process_stat_event,
3380 .stat_round = process_stat_round_event,
91a2c3d5 3381 .stat_config = process_stat_config_event,
cfc8874a
JO		 3382 .thread_map = process_thread_map_event,
3383 .cpu_map = process_cpu_map_event,
0a8cb85c 3384 .ordered_events = true,
6f3e5eda
AH		 3385 .ordering_requires_timestamps = true,
3386 },
3387 };
8ceb41d7 3388 struct perf_data data = {
06af0f2c
YS		 3389 .mode = PERF_DATA_MODE_READ,
3390 };
69b6470e 3391 const struct option options[] = {
5f9c39dc
FW		 3392 OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
3393 "dump raw trace in ASCII"),
c0555642 3394 OPT_INCR('v', "verbose", &verbose,
69b6470e 3395 "be more verbose (show symbol address, etc)"),
4b9c0c59 3396 OPT_BOOLEAN('L', "Latency", &latency_format,
cda48461 3397 "show latency attributes (irqs/preemption disabled, etc)"),
4b9c0c59
TZ		 3398 OPT_CALLBACK_NOOPT('l', "list", NULL, NULL, "list available scripts",
3399 list_available_scripts),
956ffd02
TZ		 3400 OPT_CALLBACK('s', "script", NULL, "name",
3401 "script file name (lang:script name, script name, or *)",
3402 parse_scriptname),
3403 OPT_STRING('g', "gen-script", &generate_script_lang, "lang",
133dc4c3 3404 "generate perf-script.xx script in specified language"),
69b6470e 3405 OPT_STRING('i', "input", &input_name, "file", "input file name"),
ffabd99e
FW		 3406 OPT_BOOLEAN('d', "debug-mode", &debug_mode,
3407 "do various checks like samples ordering and lost events"),
e90debdd
JO		 3408 OPT_BOOLEAN(0, "header", &header, "Show data header."),
3409 OPT_BOOLEAN(0, "header-only", &header_only, "Show only data header."),
c0230b2b
DA		 3410 OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
3411 "file", "vmlinux pathname"),
3412 OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name,
3413 "file", "kallsyms pathname"),
3414 OPT_BOOLEAN('G', "hide-call-graph", &no_callchain,
3415 "When printing symbols do not display call chain"),
a7066709
HK		 3416 OPT_CALLBACK(0, "symfs", NULL, "directory",
3417 "Look for files with symbols relative to this directory",
3418 symbol__config_symfs),
06af0f2c 3419 OPT_CALLBACK('F', "fields", NULL, "str",
a978f2ab 3420 "comma separated output fields prepend with 'type:'. "
36ce5651 3421 "+field to add and -field to remove."
1405720d 3422 "Valid types: hw,sw,trace,raw,synth. "
a978f2ab 3423 "Fields: comm,tid,pid,time,cpu,event,trace,ip,sym,dso,"
10e9cec9
RB		 3424 "addr,symoff,srcline,period,iregs,uregs,brstack,"
3425 "brstacksym,flags,bpf-output,brstackinsn,brstackoff,"
68fb45bf 3426 "callindent,insn,insnlen,synth,phys_addr,metric,misc,ipc",
48d02a1d 3427 parse_output_fields),
317df650 3428 OPT_BOOLEAN('a', "all-cpus", &system_wide,
69b6470e 3429 "system-wide collection from all CPUs"),
36385be5
FT		 3430 OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
3431 "only consider these symbols"),
b585ebdb
AK		 3432 OPT_CALLBACK_OPTARG(0, "insn-trace", &itrace_synth_opts, NULL, NULL,
3433 "Decode instructions from itrace", parse_insn_trace),
3434 OPT_CALLBACK_OPTARG(0, "xed", NULL, NULL, NULL,
3435 "Run xed disassembler on output", parse_xed),
d1b1552e
AK		 3436 OPT_CALLBACK_OPTARG(0, "call-trace", &itrace_synth_opts, NULL, NULL,
3437 "Decode calls from from itrace", parse_call_trace),
3438 OPT_CALLBACK_OPTARG(0, "call-ret-trace", &itrace_synth_opts, NULL, NULL,
3439 "Decode calls and returns from itrace", parse_callret_trace),
99f753f0
AK		 3440 OPT_STRING(0, "graph-function", &symbol_conf.graph_function, "symbol[,symbol...]",
3441 "Only print symbols and callees with --call-trace/--call-ret-trace"),
64eff7d9
DA		 3442 OPT_STRING(0, "stop-bt", &symbol_conf.bt_stop_list_str, "symbol[,symbol...]",
3443 "Stop display of callgraph at these symbols"),
c8e66720 3444 OPT_STRING('C', "cpu", &cpu_list, "cpu", "list of cpus to profile"),
e7984b7b
DA		 3445 OPT_STRING('c', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
3446 "only display events for these comms"),
e03eaa40
DA		 3447 OPT_STRING(0, "pid", &symbol_conf.pid_list_str, "pid[,pid...]",
3448 "only consider symbols in these pids"),
3449 OPT_STRING(0, "tid", &symbol_conf.tid_list_str, "tid[,tid...]",
3450 "only consider symbols in these tids"),
6125cc8d
ACM		 3451 OPT_UINTEGER(0, "max-stack", &scripting_max_stack,
3452 "Set the maximum stack depth when parsing the callchain, "
3453 "anything beyond the specified depth will be ignored. "
4cb93446 3454 "Default: kernel.perf_event_max_stack or " __stringify(PERF_MAX_STACK_DEPTH)),
90b10f47 3455 OPT_BOOLEAN(0, "reltime", &reltime, "Show time stamps relative to start"),
26567ed7 3456 OPT_BOOLEAN(0, "deltatime", &deltatime, "Show time stamps relative to previous event"),
fbe96f29
SE		 3457 OPT_BOOLEAN('I', "show-info", &show_full_info,
3458 "display extended information from perf.data file"),
0bc8d205
AN		 3459 OPT_BOOLEAN('\0', "show-kernel-path", &symbol_conf.show_kernel_path,
3460 "Show the path of [kernel.kallsyms]"),
ad7ebb9a
NK		 3461 OPT_BOOLEAN('\0', "show-task-events", &script.show_task_events,
3462 "Show the fork/comm/exit events"),
ba1ddf42
NK		 3463 OPT_BOOLEAN('\0', "show-mmap-events", &script.show_mmap_events,
3464 "Show the mmap events"),
7c14898b
AH		 3465 OPT_BOOLEAN('\0', "show-switch-events", &script.show_switch_events,
3466 "Show context switch events (if recorded)"),
96a44bbc
HB		 3467 OPT_BOOLEAN('\0', "show-namespace-events", &script.show_namespace_events,
3468 "Show namespace events (if recorded)"),
160d4af9
NK		 3469 OPT_BOOLEAN('\0', "show-cgroup-events", &script.show_cgroup_events,
3470 "Show cgroup events (if recorded)"),
3d7c27b6
JO		 3471 OPT_BOOLEAN('\0', "show-lost-events", &script.show_lost_events,
3472 "Show lost events (if recorded)"),
3233b37a
JO		 3473 OPT_BOOLEAN('\0', "show-round-events", &script.show_round_events,
3474 "Show round events (if recorded)"),
490c8cc9
JO		 3475 OPT_BOOLEAN('\0', "show-bpf-events", &script.show_bpf_events,
3476 "Show bpf related events (if recorded)"),
a14390fd
ACM		 3477 OPT_BOOLEAN('\0', "per-event-dump", &script.per_event_dump,
3478 "Dump trace output to files named by the monitored events"),
be3d466c 3479 OPT_BOOLEAN('f', "force", &symbol_conf.force, "don't complain, do it"),
48d02a1d
AK		 3480 OPT_INTEGER(0, "max-blocks", &max_blocks,
3481 "Maximum number of code blocks to dump with brstackinsn"),
52bab886 3482 OPT_BOOLEAN(0, "ns", &symbol_conf.nanosecs,
83e19860 3483 "Use 9 decimal places when displaying time"),
7a680eb9 3484 OPT_CALLBACK_OPTARG(0, "itrace", &itrace_synth_opts, NULL, "opts",
c12e039d 3485 "Instruction Tracing options\n" ITRACE_HELP,
7a680eb9 3486 itrace_parse_synth_opts),
a9710ba0
AK		 3487 OPT_BOOLEAN(0, "full-source-path", &srcline_full_filename,
3488 "Show full source file name path for source lines"),
77e0070d
MD		 3489 OPT_BOOLEAN(0, "demangle", &symbol_conf.demangle,
3490 "Enable symbol demangling"),
3491 OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf.demangle_kernel,
3492 "Enable kernel symbol demangling"),
a91f4c47
DA		 3493 OPT_STRING(0, "time", &script.time_str, "str",
3494 "Time span of interest (start,stop)"),
325fbff5
NK		 3495 OPT_BOOLEAN(0, "inline", &symbol_conf.inline_name,
3496 "Show inline function"),
15a108af
ACM		 3497 OPT_STRING(0, "guestmount", &symbol_conf.guestmount, "directory",
3498 "guest mount directory under which every guest os"
3499 " instance has a subdir"),
3500 OPT_STRING(0, "guestvmlinux", &symbol_conf.default_guest_vmlinux_name,
3501 "file", "file saving guest os vmlinux"),
3502 OPT_STRING(0, "guestkallsyms", &symbol_conf.default_guest_kallsyms,
3503 "file", "file saving guest os /proc/kallsyms"),
3504 OPT_STRING(0, "guestmodules", &symbol_conf.default_guest_modules,
3505 "file", "file saving guest os /proc/modules"),
680d125c
KL		 3506 OPT_BOOLEAN('\0', "stitch-lbr", &script.stitch_lbr,
3507 "Enable LBR callgraph stitching approach"),
add3a719 3508 OPTS_EVSWITCH(&script.evswitch),
1909629f 3509 OPT_END()
69b6470e 3510 };
40cae2b7
YS		 3511 const char * const script_subcommands[] = { "record", "report", NULL };
3512 const char *script_usage[] = {
69b6470e
ACM		 3513 "perf script [<options>]",
3514 "perf script [<options>] record <script> [<record-options>] <command>",
3515 "perf script [<options>] report <script> [script-args]",
3516 "perf script [<options>] <script> [<record-options>] <command>",
3517 "perf script [<options>] <top-script> [script-args]",
3518 NULL
3519 };
3875294f 3520
0a7c74ea
ACM		 3521 perf_set_singlethreaded();
3522
b5b87312
TZ		 3523 setup_scripting();
3524
40cae2b7 3525 argc = parse_options_subcommand(argc, argv, options, script_subcommands, script_usage,
b5b87312
TZ		 3526 PARSE_OPT_STOP_AT_NON_OPTION);
3527
15a108af
ACM		 3528 if (symbol_conf.guestmount ||
3529 symbol_conf.default_guest_vmlinux_name ||
3530 symbol_conf.default_guest_kallsyms ||
3531 symbol_conf.default_guest_modules) {
3532 /*
3533 * Enable guest sample processing.
3534 */
3535 perf_guest = true;
3536 }
3537
2d4f2799
JO		 3538 data.path = input_name;
3539 data.force = symbol_conf.force;
f5fc1412 3540
b5b87312
TZ		 3541 if (argc > 1 && !strncmp(argv[0], "rec", strlen("rec"))) {
3542 rec_script_path = get_script_path(argv[1], RECORD_SUFFIX);
3543 if (!rec_script_path)
b0ad8ea6 3544 return cmd_record(argc, argv);
3875294f
TZ		 3545 }
3546
b5b87312
TZ		 3547 if (argc > 1 && !strncmp(argv[0], "rep", strlen("rep"))) {
3548 rep_script_path = get_script_path(argv[1], REPORT_SUFFIX);
3549 if (!rep_script_path) {
3875294f 3550 fprintf(stderr,
b5b87312 3551 "Please specify a valid report script"
133dc4c3 3552 "(see 'perf script -l' for listing)\n");
3875294f
TZ		 3553 return -1;
3554 }
3875294f
TZ		 3555 }
3556
26567ed7
HPP		 3557 if (reltime && deltatime) {
3558 fprintf(stderr,
3559 "reltime and deltatime - the two don't get along well. "
3560 "Please limit to --reltime or --deltatime.\n");
3561 return -1;
3562 }
3563
1c5c25b3 3564 if ((itrace_synth_opts.callchain || itrace_synth_opts.add_callchain) &&
3c5b645f
AH		 3565 itrace_synth_opts.callchain_sz > scripting_max_stack)
3566 scripting_max_stack = itrace_synth_opts.callchain_sz;
3567
44e668c6 3568 /* make sure PERF_EXEC_PATH is set for scripts */
46113a54 3569 set_argv_exec_path(get_argv_exec_path());
44e668c6 3570
b5b87312 3571 if (argc && !script_name && !rec_script_path && !rep_script_path) {
a0cccc2e 3572 int live_pipe[2];
b5b87312 3573 int rep_args;
a0cccc2e
TZ		 3574 pid_t pid;
3575
b5b87312
TZ		 3576 rec_script_path = get_script_path(argv[0], RECORD_SUFFIX);
3577 rep_script_path = get_script_path(argv[0], REPORT_SUFFIX);
3578
3579 if (!rec_script_path && !rep_script_path) {
c7118369
NK		 3580 usage_with_options_msg(script_usage, options,
3581 "Couldn't find script `%s'\n\n See perf"
133dc4c3 3582 " script -l for available scripts.\n", argv[0]);
a0cccc2e
TZ		 3583 }
3584
b5b87312
TZ		 3585 if (is_top_script(argv[0])) {
3586 rep_args = argc - 1;
3587 } else {
3588 int rec_args;
3589
3590 rep_args = has_required_arg(rep_script_path);
3591 rec_args = (argc - 1) - rep_args;
3592 if (rec_args < 0) {
c7118369
NK		 3593 usage_with_options_msg(script_usage, options,
3594 "`%s' script requires options."
133dc4c3 3595 "\n\n See perf script -l for available "
b5b87312 3596 "scripts and options.\n", argv[0]);
b5b87312 3597 }
a0cccc2e
TZ		 3598 }
3599
3600 if (pipe(live_pipe) < 0) {
3601 perror("failed to create pipe");
d54b1a9e 3602 return -1;
a0cccc2e
TZ		 3603 }
3604
3605 pid = fork();
3606 if (pid < 0) {
3607 perror("failed to fork");
d54b1a9e 3608 return -1;
a0cccc2e
TZ		 3609 }
3610
3611 if (!pid) {
b5b87312
TZ		 3612 j = 0;
3613
a0cccc2e
TZ		 3614 dup2(live_pipe[1], 1);
3615 close(live_pipe[0]);
3616
317df650
RR		 3617 if (is_top_script(argv[0])) {
3618 system_wide = true;
3619 } else if (!system_wide) {
d54b1a9e
DA		 3620 if (have_cmd(argc - rep_args, &argv[rep_args]) != 0) {
3621 err = -1;
3622 goto out;
3623 }
317df650 3624 }
b5b87312
TZ		 3625
3626 __argv = malloc((argc + 6) * sizeof(const char *));
d54b1a9e
DA		 3627 if (!__argv) {
3628 pr_err("malloc failed\n");
3629 err = -ENOMEM;
3630 goto out;
3631 }
e8719adf 3632
b5b87312
TZ		 3633 __argv[j++] = "/bin/sh";
3634 __argv[j++] = rec_script_path;
3635 if (system_wide)
3636 __argv[j++] = "-a";
3637 __argv[j++] = "-q";
3638 __argv[j++] = "-o";
3639 __argv[j++] = "-";
3640 for (i = rep_args + 1; i < argc; i++)
3641 __argv[j++] = argv[i];
3642 __argv[j++] = NULL;
a0cccc2e
TZ		 3643
3644 execvp("/bin/sh", (char **)__argv);
e8719adf 3645 free(__argv);
a0cccc2e
TZ		 3646 exit(-1);
3647 }
3648
3649 dup2(live_pipe[0], 0);
3650 close(live_pipe[1]);
3651
b5b87312 3652 __argv = malloc((argc + 4) * sizeof(const char *));
d54b1a9e
DA		 3653 if (!__argv) {
3654 pr_err("malloc failed\n");
3655 err = -ENOMEM;
3656 goto out;
3657 }
3658
b5b87312
TZ		 3659 j = 0;
3660 __argv[j++] = "/bin/sh";
3661 __argv[j++] = rep_script_path;
3662 for (i = 1; i < rep_args + 1; i++)
3663 __argv[j++] = argv[i];
3664 __argv[j++] = "-i";
3665 __argv[j++] = "-";
3666 __argv[j++] = NULL;
a0cccc2e
TZ		 3667
3668 execvp("/bin/sh", (char **)__argv);
e8719adf 3669 free(__argv);
a0cccc2e
TZ		 3670 exit(-1);
3671 }
3672
b5b87312
TZ		 3673 if (rec_script_path)
3674 script_path = rec_script_path;
3675 if (rep_script_path)
3676 script_path = rep_script_path;
34c86ea9 3677
b5b87312 3678 if (script_path) {
b5b87312 3679 j = 0;
3875294f 3680
317df650
RR		 3681 if (!rec_script_path)
3682 system_wide = false;
d54b1a9e
DA		 3683 else if (!system_wide) {
3684 if (have_cmd(argc - 1, &argv[1]) != 0) {
3685 err = -1;
3686 goto out;
3687 }
3688 }
34c86ea9 3689
b5b87312 3690 __argv = malloc((argc + 2) * sizeof(const char *));
d54b1a9e
DA		 3691 if (!__argv) {
3692 pr_err("malloc failed\n");
3693 err = -ENOMEM;
3694 goto out;
3695 }
3696
34c86ea9
TZ		 3697 __argv[j++] = "/bin/sh";
3698 __argv[j++] = script_path;
3699 if (system_wide)
3700 __argv[j++] = "-a";
b5b87312 3701 for (i = 2; i < argc; i++)
34c86ea9
TZ		 3702 __argv[j++] = argv[i];
3703 __argv[j++] = NULL;
3875294f
TZ		 3704
3705 execvp("/bin/sh", (char **)__argv);
e8719adf 3706 free(__argv);
3875294f
TZ		 3707 exit(-1);
3708 }
956ffd02 3709
c1c9b969 3710 if (!script_name) {
cf4fee50 3711 setup_pager();
c1c9b969
MW		 3712 use_browser = 0;
3713 }
5f9c39dc 3714
8ceb41d7 3715 session = perf_session__new(&data, false, &script.tool);
6ef81c55
MI		 3716 if (IS_ERR(session))
3717 return PTR_ERR(session);
d8f66248 3718
e90debdd 3719 if (header || header_only) {
114f709e 3720 script.tool.show_feat_hdr = SHOW_FEAT_HEADER;
e90debdd
JO		 3721 perf_session__fprintf_info(session, stdout, show_full_info);
3722 if (header_only)
6cc870f0 3723 goto out_delete;
e90debdd 3724 }
114f709e
DCC		 3725 if (show_full_info)
3726 script.tool.show_feat_hdr = SHOW_FEAT_HEADER_FULL_INFO;
e90debdd 3727
0a7e6d1b 3728 if (symbol__init(&session->header.env) < 0)
38520dc3
NK		 3729 goto out_delete;
3730
3ab481a1 3731 uname(&uts);
9d49169c
SL		 3732 if (data.is_pipe || /* assume pipe_mode indicates native_arch */
3733 !strcmp(uts.machine, session->header.env.arch) ||
3ab481a1
AK		 3734 (!strcmp(uts.machine, "x86_64") &&
3735 !strcmp(session->header.env.arch, "i386")))
3736 native_arch = true;
3737
6f3e5eda 3738 script.session = session;
7322d6c9 3739 script__setup_sample_type(&script);
6f3e5eda 3740
99f753f0
AK		 3741 if ((output[PERF_TYPE_HARDWARE].fields & PERF_OUTPUT_CALLINDENT) ||
3742 symbol_conf.graph_function)
e216708d
AH		 3743 itrace_synth_opts.thread_stack = true;
3744
7a680eb9
AH		 3745 session->itrace_synth_opts = &itrace_synth_opts;
3746
5d67be97 3747 if (cpu_list) {
6cc870f0
NK		 3748 err = perf_session__cpu_bitmap(session, cpu_list, cpu_bitmap);
3749 if (err < 0)
3750 goto out_delete;
644e0840 3751 itrace_synth_opts.cpu_bitmap = cpu_bitmap;
5d67be97
AB		 3752 }
3753
1424dc96 3754 if (!no_callchain)
c0230b2b
DA		 3755 symbol_conf.use_callchain = true;
3756 else
3757 symbol_conf.use_callchain = false;
3758
9ee67421 3759 if (session->tevent.pevent &&
ece2a4f4
TSV		 3760 tep_set_function_resolver(session->tevent.pevent,
3761 machine__resolve_kernel_addr,
3762 &session->machines.host) < 0) {
ccb3a829 3763 pr_err("%s: failed to set libtraceevent function resolver\n", __func__);
db49bc15
CJ		 3764 err = -1;
3765 goto out_delete;
ccb3a829
ACM		 3766 }
3767
956ffd02
TZ		 3768 if (generate_script_lang) {
3769 struct stat perf_stat;
745f43e3
DA		 3770 int input;
3771
2c9e45f7 3772 if (output_set_by_user()) {
745f43e3
DA		 3773 fprintf(stderr,
3774 "custom fields not supported for generated scripts");
6cc870f0
NK		 3775 err = -EINVAL;
3776 goto out_delete;
745f43e3 3777 }
956ffd02 3778
2d4f2799 3779 input = open(data.path, O_RDONLY); /* input_name */
956ffd02 3780 if (input < 0) {
6cc870f0 3781 err = -errno;
956ffd02 3782 perror("failed to open file");
6cc870f0 3783 goto out_delete;
956ffd02
TZ		 3784 }
3785
3786 err = fstat(input, &perf_stat);
3787 if (err < 0) {
3788 perror("failed to stat file");
6cc870f0 3789 goto out_delete;
956ffd02
TZ		 3790 }
3791
3792 if (!perf_stat.st_size) {
3793 fprintf(stderr, "zero-sized file, nothing to do!\n");
6cc870f0 3794 goto out_delete;
956ffd02
TZ		 3795 }
3796
3797 scripting_ops = script_spec__lookup(generate_script_lang);
3798 if (!scripting_ops) {
3799 fprintf(stderr, "invalid language specifier");
6cc870f0
NK		 3800 err = -ENOENT;
3801 goto out_delete;
956ffd02
TZ		 3802 }
3803
29f5ffd3 3804 err = scripting_ops->generate_script(session->tevent.pevent,
da378962 3805 "perf-script");
6cc870f0 3806 goto out_delete;
956ffd02
TZ		 3807 }
3808
3809 if (script_name) {
586bc5cc 3810 err = scripting_ops->start_script(script_name, argc, argv);
956ffd02 3811 if (err)
6cc870f0 3812 goto out_delete;
133dc4c3 3813 pr_debug("perf script started with script %s\n\n", script_name);
6cc870f0 3814 script_started = true;
956ffd02
TZ		 3815 }
3816
9cbdb702
DA		 3817
3818 err = perf_session__check_output_opt(session);
3819 if (err < 0)
6cc870f0 3820 goto out_delete;
9cbdb702 3821
284c4e18 3822 if (script.time_str) {
b3509b6e 3823 err = perf_time__parse_for_ranges_reltime(script.time_str, session,
284c4e18
JY		 3824 &script.ptime_range,
3825 &script.range_size,
b3509b6e
AK		 3826 &script.range_num,
3827 reltime);
284c4e18 3828 if (err < 0)
2ab046cd 3829 goto out_delete;
400ae981
AH		 3830
3831 itrace_synth_opts__set_time_range(&itrace_synth_opts,
3832 script.ptime_range,
3833 script.range_num);
a91f4c47
DA		 3834 }
3835
124e02be
ACM		 3836 err = evswitch__init(&script.evswitch, session->evlist, stderr);
3837 if (err)
3838 goto out_delete;
dd41f660 3839
b13b04d9
MW		 3840 if (zstd_init(&(session->zstd_data), 0) < 0)
3841 pr_warning("Decompression initialization failed. Reported data may be incomplete.\n");
3842
6f3e5eda 3843 err = __cmd_script(&script);
956ffd02 3844
d445dd2a
AH		 3845 flush_scripting();
3846
6cc870f0 3847out_delete:
400ae981
AH		 3848 if (script.ptime_range) {
3849 itrace_synth_opts__clear_time_range(&itrace_synth_opts);
284c4e18 3850 zfree(&script.ptime_range);
400ae981 3851 }
cc2ef584 3852
cfc8874a 3853 perf_evlist__free_stats(session->evlist);
d8f66248 3854 perf_session__delete(session);
6cc870f0
NK		 3855
3856 if (script_started)
3857 cleanup_scripting();
956ffd02
TZ		 3858out:
3859 return err;
5f9c39dc 3860}
Linux 6.x block layer and io_uring tree(s)