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