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