projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/shli/md
[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;
cfc8874a 1492 bool allocated;
a14390fd 1493 bool per_event_dump;
cfc8874a
JO		 1494 struct cpu_map *cpus;
1495 struct thread_map *threads;
9cdbc409 1496 int name_width;
a91f4c47 1497 const char *time_str;
cc2ef584
JY		 1498 struct perf_time_interval *ptime_range;
1499 int range_size;
2ab046cd 1500 int range_num;
809e9423
JO		 1501};
1502
9cdbc409
JO		 1503static int perf_evlist__max_name_len(struct perf_evlist *evlist)
1504{
1505 struct perf_evsel *evsel;
1506 int max = 0;
1507
e5cadb93 1508 evlist__for_each_entry(evlist, evsel) {
9cdbc409
JO		 1509 int len = strlen(perf_evsel__name(evsel));
1510
1511 max = MAX(len, max);
1512 }
1513
1514 return max;
1515}
1516
a1a58707 1517static int data_src__fprintf(u64 data_src, FILE *fp)
c19ac912
JO		 1518{
1519 struct mem_info mi = { .data_src.val = data_src };
1520 char decode[100];
1521 char out[100];
1522 static int maxlen;
1523 int len;
1524
1525 perf_script__meminfo_scnprintf(decode, 100, &mi);
1526
1527 len = scnprintf(out, 100, "%16" PRIx64 " %s", data_src, decode);
1528 if (maxlen < len)
1529 maxlen = len;
1530
a1a58707 1531 return fprintf(fp, "%-*s", maxlen, out);
c19ac912
JO		 1532}
1533
4bd1bef8
AK		 1534struct metric_ctx {
1535 struct perf_sample *sample;
1536 struct thread *thread;
1537 struct perf_evsel *evsel;
1538 FILE *fp;
1539};
1540
1541static void script_print_metric(void *ctx, const char *color,
1542 const char *fmt,
1543 const char *unit, double val)
1544{
1545 struct metric_ctx *mctx = ctx;
1546
1547 if (!fmt)
1548 return;
1549 perf_sample__fprintf_start(mctx->sample, mctx->thread, mctx->evsel,
28a0b398 1550 PERF_RECORD_SAMPLE, mctx->fp);
4bd1bef8
AK		 1551 fputs("\tmetric: ", mctx->fp);
1552 if (color)
1553 color_fprintf(mctx->fp, color, fmt, val);
1554 else
1555 printf(fmt, val);
1556 fprintf(mctx->fp, " %s\n", unit);
1557}
1558
1559static void script_new_line(void *ctx)
1560{
1561 struct metric_ctx *mctx = ctx;
1562
1563 perf_sample__fprintf_start(mctx->sample, mctx->thread, mctx->evsel,
28a0b398 1564 PERF_RECORD_SAMPLE, mctx->fp);
4bd1bef8
AK		 1565 fputs("\tmetric: ", mctx->fp);
1566}
1567
1568static void perf_sample__fprint_metric(struct perf_script *script,
1569 struct thread *thread,
1570 struct perf_evsel *evsel,
1571 struct perf_sample *sample,
1572 FILE *fp)
1573{
1574 struct perf_stat_output_ctx ctx = {
1575 .print_metric = script_print_metric,
1576 .new_line = script_new_line,
1577 .ctx = &(struct metric_ctx) {
1578 .sample = sample,
1579 .thread = thread,
1580 .evsel = evsel,
1581 .fp = fp,
1582 },
1583 .force_header = false,
1584 };
1585 struct perf_evsel *ev2;
1586 static bool init;
1587 u64 val;
1588
1589 if (!init) {
1590 perf_stat__init_shadow_stats();
1591 init = true;
1592 }
1593 if (!evsel->stats)
1594 perf_evlist__alloc_stats(script->session->evlist, false);
1595 if (evsel_script(evsel->leader)->gnum++ == 0)
1596 perf_stat__reset_shadow_stats();
1597 val = sample->period * evsel->scale;
1598 perf_stat__update_shadow_stats(evsel,
1599 val,
1fcd0394
JY		 1600 sample->cpu,
1601 &rt_stat);
4bd1bef8
AK		 1602 evsel_script(evsel)->val = val;
1603 if (evsel_script(evsel->leader)->gnum == evsel->leader->nr_members) {
1604 for_each_group_member (ev2, evsel->leader) {
1605 perf_stat__print_shadow_stats(ev2,
1606 evsel_script(ev2)->val,
1607 sample->cpu,
1608 &ctx,
e0128b30
JY		 1609 NULL,
1610 &rt_stat);
4bd1bef8
AK		 1611 }
1612 evsel_script(evsel->leader)->gnum = 0;
1613 }
1614}
1615
a3dff304 1616static void process_event(struct perf_script *script,
809e9423 1617 struct perf_sample *sample, struct perf_evsel *evsel,
48d02a1d
AK		 1618 struct addr_location *al,
1619 struct machine *machine)
be6d842a 1620{
f9d5d549 1621 struct thread *thread = al->thread;
9e69c210 1622 struct perf_event_attr *attr = &evsel->attr;
1405720d 1623 unsigned int type = output_type(attr->type);
642ee1c6
ACM		 1624 struct perf_evsel_script *es = evsel->priv;
1625 FILE *fp = es->fp;
1424dc96 1626
1405720d 1627 if (output[type].fields == 0)
1424dc96
DA		 1628 return;
1629
642ee1c6
ACM		 1630 ++es->samples;
1631
28a0b398
JO		 1632 perf_sample__fprintf_start(sample, thread, evsel,
1633 PERF_RECORD_SAMPLE, fp);
745f43e3 1634
535aeaae 1635 if (PRINT_FIELD(PERIOD))
69c71252 1636 fprintf(fp, "%10" PRIu64 " ", sample->period);
535aeaae 1637
e944d3d7
NK		 1638 if (PRINT_FIELD(EVNAME)) {
1639 const char *evname = perf_evsel__name(evsel);
9cdbc409
JO		 1640
1641 if (!script->name_width)
1642 script->name_width = perf_evlist__max_name_len(script->session->evlist);
1643
69c71252 1644 fprintf(fp, "%*s: ", script->name_width, evname ?: "[unknown]");
e944d3d7
NK		 1645 }
1646
400ea6d3 1647 if (print_flags)
a1a58707 1648 perf_sample__fprintf_flags(sample->flags, fp);
400ea6d3 1649
95582596 1650 if (is_bts_event(attr)) {
a1a58707 1651 perf_sample__fprintf_bts(sample, evsel, thread, al, machine, fp);
95582596
AN		 1652 return;
1653 }
1654
894f3f17
ACM		 1655 if (PRINT_FIELD(TRACE)) {
1656 event_format__fprintf(evsel->tp_format, sample->cpu,
1657 sample->raw_data, sample->raw_size, fp);
1658 }
47e78084
AH		 1659
1660 if (attr->type == PERF_TYPE_SYNTH && PRINT_FIELD(SYNTH))
a1a58707 1661 perf_sample__fprintf_synth(sample, evsel, fp);
47e78084 1662
7cec0922 1663 if (PRINT_FIELD(ADDR))
a1a58707 1664 perf_sample__fprintf_addr(sample, thread, attr, fp);
7cec0922 1665
94ddddfa 1666 if (PRINT_FIELD(DATA_SRC))
a1a58707 1667 data_src__fprintf(sample->data_src, fp);
94ddddfa
JO		 1668
1669 if (PRINT_FIELD(WEIGHT))
a1a58707 1670 fprintf(fp, "%16" PRIu64, sample->weight);
94ddddfa 1671
787bef17 1672 if (PRINT_FIELD(IP)) {
e557b674 1673 struct callchain_cursor *cursor = NULL;
6f736735 1674
92231521 1675 if (symbol_conf.use_callchain && sample->callchain &&
e557b674 1676 thread__resolve_callchain(al->thread, &callchain_cursor, evsel,
6f736735 1677 sample, NULL, NULL, scripting_max_stack) == 0)
e557b674 1678 cursor = &callchain_cursor;
a6ffaf91 1679
a1a58707
ACM		 1680 fputc(cursor ? '\n' : ' ', fp);
1681 sample__fprintf_sym(sample, al, 0, output[type].print_ip_opts, cursor, fp);
c0230b2b
DA		 1682 }
1683
fc36f948 1684 if (PRINT_FIELD(IREGS))
a1a58707 1685 perf_sample__fprintf_iregs(sample, attr, fp);
fc36f948 1686
b1491ace 1687 if (PRINT_FIELD(UREGS))
a1a58707 1688 perf_sample__fprintf_uregs(sample, attr, fp);
b1491ace 1689
dc323ce8 1690 if (PRINT_FIELD(BRSTACK))
a1a58707 1691 perf_sample__fprintf_brstack(sample, thread, attr, fp);
dc323ce8 1692 else if (PRINT_FIELD(BRSTACKSYM))
a1a58707 1693 perf_sample__fprintf_brstacksym(sample, thread, attr, fp);
106dacd8 1694 else if (PRINT_FIELD(BRSTACKOFF))
a1a58707 1695 perf_sample__fprintf_brstackoff(sample, thread, attr, fp);
dc323ce8 1696
30372f04 1697 if (perf_evsel__is_bpf_output(evsel) && PRINT_FIELD(BPF_OUTPUT))
a1a58707
ACM		 1698 perf_sample__fprintf_bpf_output(sample, fp);
1699 perf_sample__fprintf_insn(sample, attr, thread, machine, fp);
49d58f04
KL		 1700
1701 if (PRINT_FIELD(PHYS_ADDR))
69c71252
ACM		 1702 fprintf(fp, "%16" PRIx64, sample->phys_addr);
1703 fprintf(fp, "\n");
4bd1bef8
AK		 1704
1705 if (PRINT_FIELD(METRIC))
1706 perf_sample__fprint_metric(script, thread, evsel, sample, fp);
be6d842a
DA		 1707}
1708
956ffd02
TZ		 1709static struct scripting_ops *scripting_ops;
1710
36e33c53
JO		 1711static void __process_stat(struct perf_evsel *counter, u64 tstamp)
1712{
1713 int nthreads = thread_map__nr(counter->threads);
1714 int ncpus = perf_evsel__nr_cpus(counter);
1715 int cpu, thread;
1716 static int header_printed;
1717
1718 if (counter->system_wide)
1719 nthreads = 1;
1720
1721 if (!header_printed) {
1722 printf("%3s %8s %15s %15s %15s %15s %s\n",
1723 "CPU", "THREAD", "VAL", "ENA", "RUN", "TIME", "EVENT");
1724 header_printed = 1;
1725 }
1726
1727 for (thread = 0; thread < nthreads; thread++) {
1728 for (cpu = 0; cpu < ncpus; cpu++) {
1729 struct perf_counts_values *counts;
1730
1731 counts = perf_counts(counter->counts, cpu, thread);
1732
1733 printf("%3d %8d %15" PRIu64 " %15" PRIu64 " %15" PRIu64 " %15" PRIu64 " %s\n",
1734 counter->cpus->map[cpu],
1735 thread_map__pid(counter->threads, thread),
1736 counts->val,
1737 counts->ena,
1738 counts->run,
1739 tstamp,
1740 perf_evsel__name(counter));
1741 }
1742 }
1743}
1744
e099eba8
JO		 1745static void process_stat(struct perf_evsel *counter, u64 tstamp)
1746{
1747 if (scripting_ops && scripting_ops->process_stat)
1748 scripting_ops->process_stat(&stat_config, counter, tstamp);
36e33c53
JO		 1749 else
1750 __process_stat(counter, tstamp);
e099eba8
JO		 1751}
1752
1753static void process_stat_interval(u64 tstamp)
1754{
1755 if (scripting_ops && scripting_ops->process_stat_interval)
1756 scripting_ops->process_stat_interval(tstamp);
1757}
1758
956ffd02
TZ		 1759static void setup_scripting(void)
1760{
16c632de 1761 setup_perl_scripting();
7e4b21b8 1762 setup_python_scripting();
956ffd02
TZ		 1763}
1764
d445dd2a
AH		 1765static int flush_scripting(void)
1766{
2aaecfc5 1767 return scripting_ops ? scripting_ops->flush_script() : 0;
d445dd2a
AH		 1768}
1769
956ffd02
TZ		 1770static int cleanup_scripting(void)
1771{
133dc4c3 1772 pr_debug("\nperf script stopped\n");
3824a4e8 1773
2aaecfc5 1774 return scripting_ops ? scripting_ops->stop_script() : 0;
956ffd02
TZ		 1775}
1776
809e9423 1777static int process_sample_event(struct perf_tool *tool,
d20deb64 1778 union perf_event *event,
8115d60c 1779 struct perf_sample *sample,
9e69c210 1780 struct perf_evsel *evsel,
743eb868 1781 struct machine *machine)
5f9c39dc 1782{
809e9423 1783 struct perf_script *scr = container_of(tool, struct perf_script, tool);
e7984b7b 1784 struct addr_location al;
5f9c39dc 1785
2ab046cd
JY		 1786 if (perf_time__ranges_skip_sample(scr->ptime_range, scr->range_num,
1787 sample->time)) {
a91f4c47 1788 return 0;
2ab046cd 1789 }
a91f4c47 1790
1424dc96
DA		 1791 if (debug_mode) {
1792 if (sample->time < last_timestamp) {
1793 pr_err("Samples misordered, previous: %" PRIu64
1794 " this: %" PRIu64 "\n", last_timestamp,
1795 sample->time);
1796 nr_unordered++;
e1889d75 1797 }
1424dc96
DA		 1798 last_timestamp = sample->time;
1799 return 0;
5f9c39dc 1800 }
5d67be97 1801
bb3eb566 1802 if (machine__resolve(machine, &al, sample) < 0) {
e7984b7b
DA		 1803 pr_err("problem processing %d event, skipping it.\n",
1804 event->header.type);
1805 return -1;
1806 }
1807
1808 if (al.filtered)
b91fc39f 1809 goto out_put;
e7984b7b 1810
5d67be97 1811 if (cpu_list && !test_bit(sample->cpu, cpu_bitmap))
b91fc39f 1812 goto out_put;
5d67be97 1813
2aaecfc5
JO		 1814 if (scripting_ops)
1815 scripting_ops->process_event(event, sample, evsel, &al);
1816 else
48d02a1d 1817 process_event(scr, sample, evsel, &al, machine);
2aaecfc5 1818
b91fc39f
ACM		 1819out_put:
1820 addr_location__put(&al);
5f9c39dc
FW		 1821 return 0;
1822}
1823
7ea95727
AH		 1824static int process_attr(struct perf_tool *tool, union perf_event *event,
1825 struct perf_evlist **pevlist)
1826{
1827 struct perf_script *scr = container_of(tool, struct perf_script, tool);
1828 struct perf_evlist *evlist;
1829 struct perf_evsel *evsel, *pos;
1830 int err;
1831
1832 err = perf_event__process_attr(tool, event, pevlist);
1833 if (err)
1834 return err;
1835
1836 evlist = *pevlist;
1837 evsel = perf_evlist__last(*pevlist);
1838
1405720d
AH		 1839 if (evsel->attr.type >= PERF_TYPE_MAX &&
1840 evsel->attr.type != PERF_TYPE_SYNTH)
7ea95727
AH		 1841 return 0;
1842
e5cadb93 1843 evlist__for_each_entry(evlist, pos) {
7ea95727
AH		 1844 if (pos->attr.type == evsel->attr.type && pos != evsel)
1845 return 0;
1846 }
1847
1848 set_print_ip_opts(&evsel->attr);
1849
d2b5a315
JO		 1850 if (evsel->attr.sample_type)
1851 err = perf_evsel__check_attr(evsel, scr->session);
1852
1853 return err;
7ea95727
AH		 1854}
1855
ad7ebb9a
NK		 1856static int process_comm_event(struct perf_tool *tool,
1857 union perf_event *event,
1858 struct perf_sample *sample,
1859 struct machine *machine)
1860{
1861 struct thread *thread;
1862 struct perf_script *script = container_of(tool, struct perf_script, tool);
1863 struct perf_session *session = script->session;
06b234ec 1864 struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
ad7ebb9a
NK		 1865 int ret = -1;
1866
1867 thread = machine__findnew_thread(machine, event->comm.pid, event->comm.tid);
1868 if (thread == NULL) {
1869 pr_debug("problem processing COMM event, skipping it.\n");
1870 return -1;
1871 }
1872
1873 if (perf_event__process_comm(tool, event, sample, machine) < 0)
1874 goto out;
1875
1876 if (!evsel->attr.sample_id_all) {
1877 sample->cpu = 0;
1878 sample->time = 0;
1879 sample->tid = event->comm.tid;
1880 sample->pid = event->comm.pid;
1881 }
28a0b398
JO		 1882 perf_sample__fprintf_start(sample, thread, evsel,
1883 PERF_RECORD_COMM, stdout);
ad7ebb9a
NK		 1884 perf_event__fprintf(event, stdout);
1885 ret = 0;
ad7ebb9a 1886out:
b91fc39f 1887 thread__put(thread);
ad7ebb9a
NK		 1888 return ret;
1889}
1890
96a44bbc
HB		 1891static int process_namespaces_event(struct perf_tool *tool,
1892 union perf_event *event,
1893 struct perf_sample *sample,
1894 struct machine *machine)
1895{
1896 struct thread *thread;
1897 struct perf_script *script = container_of(tool, struct perf_script, tool);
1898 struct perf_session *session = script->session;
1899 struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
1900 int ret = -1;
1901
1902 thread = machine__findnew_thread(machine, event->namespaces.pid,
1903 event->namespaces.tid);
1904 if (thread == NULL) {
1905 pr_debug("problem processing NAMESPACES event, skipping it.\n");
1906 return -1;
1907 }
1908
1909 if (perf_event__process_namespaces(tool, event, sample, machine) < 0)
1910 goto out;
1911
1912 if (!evsel->attr.sample_id_all) {
1913 sample->cpu = 0;
1914 sample->time = 0;
1915 sample->tid = event->namespaces.tid;
1916 sample->pid = event->namespaces.pid;
1917 }
28a0b398
JO		 1918 perf_sample__fprintf_start(sample, thread, evsel,
1919 PERF_RECORD_NAMESPACES, stdout);
96a44bbc
HB		 1920 perf_event__fprintf(event, stdout);
1921 ret = 0;
1922out:
1923 thread__put(thread);
1924 return ret;
1925}
1926
ad7ebb9a
NK		 1927static int process_fork_event(struct perf_tool *tool,
1928 union perf_event *event,
1929 struct perf_sample *sample,
1930 struct machine *machine)
1931{
1932 struct thread *thread;
1933 struct perf_script *script = container_of(tool, struct perf_script, tool);
1934 struct perf_session *session = script->session;
06b234ec 1935 struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
ad7ebb9a
NK		 1936
1937 if (perf_event__process_fork(tool, event, sample, machine) < 0)
1938 return -1;
1939
1940 thread = machine__findnew_thread(machine, event->fork.pid, event->fork.tid);
1941 if (thread == NULL) {
1942 pr_debug("problem processing FORK event, skipping it.\n");
1943 return -1;
1944 }
1945
1946 if (!evsel->attr.sample_id_all) {
1947 sample->cpu = 0;
1948 sample->time = event->fork.time;
1949 sample->tid = event->fork.tid;
1950 sample->pid = event->fork.pid;
1951 }
28a0b398
JO		 1952 perf_sample__fprintf_start(sample, thread, evsel,
1953 PERF_RECORD_FORK, stdout);
ad7ebb9a 1954 perf_event__fprintf(event, stdout);
b91fc39f 1955 thread__put(thread);
ad7ebb9a
NK		 1956
1957 return 0;
1958}
1959static int process_exit_event(struct perf_tool *tool,
1960 union perf_event *event,
1961 struct perf_sample *sample,
1962 struct machine *machine)
1963{
b91fc39f 1964 int err = 0;
ad7ebb9a
NK		 1965 struct thread *thread;
1966 struct perf_script *script = container_of(tool, struct perf_script, tool);
1967 struct perf_session *session = script->session;
06b234ec 1968 struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
ad7ebb9a
NK		 1969
1970 thread = machine__findnew_thread(machine, event->fork.pid, event->fork.tid);
1971 if (thread == NULL) {
1972 pr_debug("problem processing EXIT event, skipping it.\n");
1973 return -1;
1974 }
1975
1976 if (!evsel->attr.sample_id_all) {
1977 sample->cpu = 0;
1978 sample->time = 0;
53ff6bc3
AH		 1979 sample->tid = event->fork.tid;
1980 sample->pid = event->fork.pid;
ad7ebb9a 1981 }
28a0b398
JO		 1982 perf_sample__fprintf_start(sample, thread, evsel,
1983 PERF_RECORD_EXIT, stdout);
ad7ebb9a
NK		 1984 perf_event__fprintf(event, stdout);
1985
1986 if (perf_event__process_exit(tool, event, sample, machine) < 0)
b91fc39f 1987 err = -1;
ad7ebb9a 1988
b91fc39f
ACM		 1989 thread__put(thread);
1990 return err;
ad7ebb9a
NK		 1991}
1992
ba1ddf42
NK		 1993static int process_mmap_event(struct perf_tool *tool,
1994 union perf_event *event,
1995 struct perf_sample *sample,
1996 struct machine *machine)
1997{
1998 struct thread *thread;
1999 struct perf_script *script = container_of(tool, struct perf_script, tool);
2000 struct perf_session *session = script->session;
06b234ec 2001 struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
ba1ddf42
NK		 2002
2003 if (perf_event__process_mmap(tool, event, sample, machine) < 0)
2004 return -1;
2005
2006 thread = machine__findnew_thread(machine, event->mmap.pid, event->mmap.tid);
2007 if (thread == NULL) {
2008 pr_debug("problem processing MMAP event, skipping it.\n");
2009 return -1;
2010 }
2011
2012 if (!evsel->attr.sample_id_all) {
2013 sample->cpu = 0;
2014 sample->time = 0;
2015 sample->tid = event->mmap.tid;
2016 sample->pid = event->mmap.pid;
2017 }
28a0b398
JO		 2018 perf_sample__fprintf_start(sample, thread, evsel,
2019 PERF_RECORD_MMAP, stdout);
ba1ddf42 2020 perf_event__fprintf(event, stdout);
b91fc39f 2021 thread__put(thread);
ba1ddf42
NK		 2022 return 0;
2023}
2024
2025static int process_mmap2_event(struct perf_tool *tool,
2026 union perf_event *event,
2027 struct perf_sample *sample,
2028 struct machine *machine)
2029{
2030 struct thread *thread;
2031 struct perf_script *script = container_of(tool, struct perf_script, tool);
2032 struct perf_session *session = script->session;
06b234ec 2033 struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
ba1ddf42
NK		 2034
2035 if (perf_event__process_mmap2(tool, event, sample, machine) < 0)
2036 return -1;
2037
2038 thread = machine__findnew_thread(machine, event->mmap2.pid, event->mmap2.tid);
2039 if (thread == NULL) {
2040 pr_debug("problem processing MMAP2 event, skipping it.\n");
2041 return -1;
2042 }
2043
2044 if (!evsel->attr.sample_id_all) {
2045 sample->cpu = 0;
2046 sample->time = 0;
2047 sample->tid = event->mmap2.tid;
2048 sample->pid = event->mmap2.pid;
2049 }
28a0b398
JO		 2050 perf_sample__fprintf_start(sample, thread, evsel,
2051 PERF_RECORD_MMAP2, stdout);
ba1ddf42 2052 perf_event__fprintf(event, stdout);
b91fc39f 2053 thread__put(thread);
ba1ddf42
NK		 2054 return 0;
2055}
2056
7c14898b
AH		 2057static int process_switch_event(struct perf_tool *tool,
2058 union perf_event *event,
2059 struct perf_sample *sample,
2060 struct machine *machine)
2061{
2062 struct thread *thread;
2063 struct perf_script *script = container_of(tool, struct perf_script, tool);
2064 struct perf_session *session = script->session;
2065 struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
2066
2067 if (perf_event__process_switch(tool, event, sample, machine) < 0)
2068 return -1;
2069
2070 thread = machine__findnew_thread(machine, sample->pid,
2071 sample->tid);
2072 if (thread == NULL) {
2073 pr_debug("problem processing SWITCH event, skipping it.\n");
2074 return -1;
2075 }
2076
28a0b398
JO		 2077 perf_sample__fprintf_start(sample, thread, evsel,
2078 PERF_RECORD_SWITCH, stdout);
7c14898b
AH		 2079 perf_event__fprintf(event, stdout);
2080 thread__put(thread);
2081 return 0;
2082}
2083
3d7c27b6
JO		 2084static int
2085process_lost_event(struct perf_tool *tool,
2086 union perf_event *event,
2087 struct perf_sample *sample,
2088 struct machine *machine)
2089{
2090 struct perf_script *script = container_of(tool, struct perf_script, tool);
2091 struct perf_session *session = script->session;
2092 struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
2093 struct thread *thread;
2094
2095 thread = machine__findnew_thread(machine, sample->pid,
2096 sample->tid);
2097 if (thread == NULL)
2098 return -1;
2099
2100 perf_sample__fprintf_start(sample, thread, evsel,
2101 PERF_RECORD_LOST, stdout);
2102 perf_event__fprintf(event, stdout);
2103 thread__put(thread);
2104 return 0;
2105}
2106
1d037ca1 2107static void sig_handler(int sig __maybe_unused)
c239da3b
TZ		 2108{
2109 session_done = 1;
2110}
2111
a14390fd
ACM		 2112static void perf_script__fclose_per_event_dump(struct perf_script *script)
2113{
2114 struct perf_evlist *evlist = script->session->evlist;
2115 struct perf_evsel *evsel;
2116
2117 evlist__for_each_entry(evlist, evsel) {
2118 if (!evsel->priv)
2119 break;
642ee1c6 2120 perf_evsel_script__delete(evsel->priv);
a14390fd
ACM		 2121 evsel->priv = NULL;
2122 }
2123}
2124
2125static int perf_script__fopen_per_event_dump(struct perf_script *script)
2126{
2127 struct perf_evsel *evsel;
2128
2129 evlist__for_each_entry(script->session->evlist, evsel) {
fa48c892
ACM		 2130 /*
2131 * Already setup? I.e. we may be called twice in cases like
2132 * Intel PT, one for the intel_pt// and dummy events, then
2133 * for the evsels syntheized from the auxtrace info.
2134 *
2135 * Ses perf_script__process_auxtrace_info.
2136 */
2137 if (evsel->priv != NULL)
2138 continue;
2139
8ceb41d7 2140 evsel->priv = perf_evsel_script__new(evsel, script->session->data);
a14390fd
ACM		 2141 if (evsel->priv == NULL)
2142 goto out_err_fclose;
2143 }
2144
2145 return 0;
2146
2147out_err_fclose:
2148 perf_script__fclose_per_event_dump(script);
2149 return -1;
2150}
2151
2152static int perf_script__setup_per_event_dump(struct perf_script *script)
2153{
2154 struct perf_evsel *evsel;
642ee1c6 2155 static struct perf_evsel_script es_stdout;
a14390fd
ACM		 2156
2157 if (script->per_event_dump)
2158 return perf_script__fopen_per_event_dump(script);
2159
642ee1c6
ACM		 2160 es_stdout.fp = stdout;
2161
a14390fd 2162 evlist__for_each_entry(script->session->evlist, evsel)
642ee1c6 2163 evsel->priv = &es_stdout;
a14390fd
ACM		 2164
2165 return 0;
2166}
2167
642ee1c6
ACM		 2168static void perf_script__exit_per_event_dump_stats(struct perf_script *script)
2169{
2170 struct perf_evsel *evsel;
2171
2172 evlist__for_each_entry(script->session->evlist, evsel) {
2173 struct perf_evsel_script *es = evsel->priv;
2174
2175 perf_evsel_script__fprintf(es, stdout);
2176 perf_evsel_script__delete(es);
2177 evsel->priv = NULL;
2178 }
2179}
2180
6f3e5eda 2181static int __cmd_script(struct perf_script *script)
5f9c39dc 2182{
6fcf7ddb
FW		 2183 int ret;
2184
c239da3b
TZ		 2185 signal(SIGINT, sig_handler);
2186
ad7ebb9a
NK		 2187 /* override event processing functions */
2188 if (script->show_task_events) {
2189 script->tool.comm = process_comm_event;
2190 script->tool.fork = process_fork_event;
2191 script->tool.exit = process_exit_event;
2192 }
ba1ddf42
NK		 2193 if (script->show_mmap_events) {
2194 script->tool.mmap = process_mmap_event;
2195 script->tool.mmap2 = process_mmap2_event;
2196 }
7c14898b
AH		 2197 if (script->show_switch_events)
2198 script->tool.context_switch = process_switch_event;
96a44bbc
HB		 2199 if (script->show_namespace_events)
2200 script->tool.namespaces = process_namespaces_event;
3d7c27b6
JO		 2201 if (script->show_lost_events)
2202 script->tool.lost = process_lost_event;
ad7ebb9a 2203
a14390fd
ACM		 2204 if (perf_script__setup_per_event_dump(script)) {
2205 pr_err("Couldn't create the per event dump files\n");
2206 return -1;
2207 }
2208
b7b61cbe 2209 ret = perf_session__process_events(script->session);
6fcf7ddb 2210
a14390fd 2211 if (script->per_event_dump)
642ee1c6 2212 perf_script__exit_per_event_dump_stats(script);
a14390fd 2213
6d8afb56 2214 if (debug_mode)
9486aa38 2215 pr_err("Misordered timestamps: %" PRIu64 "\n", nr_unordered);
6fcf7ddb
FW		 2216
2217 return ret;
5f9c39dc
FW		 2218}
2219
956ffd02
TZ		 2220struct script_spec {
2221 struct list_head node;
2222 struct scripting_ops *ops;
2223 char spec[0];
2224};
2225
eccdfe2d 2226static LIST_HEAD(script_specs);
956ffd02
TZ		 2227
2228static struct script_spec *script_spec__new(const char *spec,
2229 struct scripting_ops *ops)
2230{
2231 struct script_spec *s = malloc(sizeof(*s) + strlen(spec) + 1);
2232
2233 if (s != NULL) {
2234 strcpy(s->spec, spec);
2235 s->ops = ops;
2236 }
2237
2238 return s;
2239}
2240
956ffd02
TZ		 2241static void script_spec__add(struct script_spec *s)
2242{
2243 list_add_tail(&s->node, &script_specs);
2244}
2245
2246static struct script_spec *script_spec__find(const char *spec)
2247{
2248 struct script_spec *s;
2249
2250 list_for_each_entry(s, &script_specs, node)
2251 if (strcasecmp(s->spec, spec) == 0)
2252 return s;
2253 return NULL;
2254}
2255
956ffd02
TZ		 2256int script_spec_register(const char *spec, struct scripting_ops *ops)
2257{
2258 struct script_spec *s;
2259
2260 s = script_spec__find(spec);
2261 if (s)
2262 return -1;
2263
8560bae0 2264 s = script_spec__new(spec, ops);
956ffd02
TZ		 2265 if (!s)
2266 return -1;
8560bae0
TS		 2267 else
2268 script_spec__add(s);
956ffd02
TZ		 2269
2270 return 0;
2271}
2272
2273static struct scripting_ops *script_spec__lookup(const char *spec)
2274{
2275 struct script_spec *s = script_spec__find(spec);
2276 if (!s)
2277 return NULL;
2278
2279 return s->ops;
2280}
2281
2282static void list_available_languages(void)
2283{
2284 struct script_spec *s;
2285
2286 fprintf(stderr, "\n");
2287 fprintf(stderr, "Scripting language extensions (used in "
133dc4c3 2288 "perf script -s [spec:]script.[spec]):\n\n");
956ffd02
TZ		 2289
2290 list_for_each_entry(s, &script_specs, node)
2291 fprintf(stderr, " %-42s [%s]\n", s->spec, s->ops->name);
2292
2293 fprintf(stderr, "\n");
2294}
2295
1d037ca1
IT		 2296static int parse_scriptname(const struct option *opt __maybe_unused,
2297 const char *str, int unset __maybe_unused)
956ffd02
TZ		 2298{
2299 char spec[PATH_MAX];
2300 const char *script, *ext;
2301 int len;
2302
f526d68b 2303 if (strcmp(str, "lang") == 0) {
956ffd02 2304 list_available_languages();
f526d68b 2305 exit(0);
956ffd02
TZ		 2306 }
2307
2308 script = strchr(str, ':');
2309 if (script) {
2310 len = script - str;
2311 if (len >= PATH_MAX) {
2312 fprintf(stderr, "invalid language specifier");
2313 return -1;
2314 }
2315 strncpy(spec, str, len);
2316 spec[len] = '\0';
2317 scripting_ops = script_spec__lookup(spec);
2318 if (!scripting_ops) {
2319 fprintf(stderr, "invalid language specifier");
2320 return -1;
2321 }
2322 script++;
2323 } else {
2324 script = str;
d1e95bb5 2325 ext = strrchr(script, '.');
956ffd02
TZ		 2326 if (!ext) {
2327 fprintf(stderr, "invalid script extension");
2328 return -1;
2329 }
2330 scripting_ops = script_spec__lookup(++ext);
2331 if (!scripting_ops) {
2332 fprintf(stderr, "invalid script extension");
2333 return -1;
2334 }
2335 }
2336
2337 script_name = strdup(script);
2338
2339 return 0;
2340}
2341
1d037ca1
IT		 2342static int parse_output_fields(const struct option *opt __maybe_unused,
2343 const char *arg, int unset __maybe_unused)
745f43e3 2344{
49346e85 2345 char *tok, *strtok_saveptr = NULL;
50ca19ae 2346 int i, imax = ARRAY_SIZE(all_output_options);
2c9e45f7 2347 int j;
745f43e3
DA		 2348 int rc = 0;
2349 char *str = strdup(arg);
1424dc96 2350 int type = -1;
36ce5651 2351 enum { DEFAULT, SET, ADD, REMOVE } change = DEFAULT;
745f43e3
DA		 2352
2353 if (!str)
2354 return -ENOMEM;
2355
2c9e45f7
DA		 2356 /* first word can state for which event type the user is specifying
2357 * the fields. If no type exists, the specified fields apply to all
2358 * event types found in the file minus the invalid fields for a type.
1424dc96 2359 */
2c9e45f7
DA		 2360 tok = strchr(str, ':');
2361 if (tok) {
2362 *tok = '\0';
2363 tok++;
2364 if (!strcmp(str, "hw"))
2365 type = PERF_TYPE_HARDWARE;
2366 else if (!strcmp(str, "sw"))
2367 type = PERF_TYPE_SOFTWARE;
2368 else if (!strcmp(str, "trace"))
2369 type = PERF_TYPE_TRACEPOINT;
0817a6a3
AS		 2370 else if (!strcmp(str, "raw"))
2371 type = PERF_TYPE_RAW;
27cfef00
WN		 2372 else if (!strcmp(str, "break"))
2373 type = PERF_TYPE_BREAKPOINT;
1405720d
AH		 2374 else if (!strcmp(str, "synth"))
2375 type = OUTPUT_TYPE_SYNTH;
2c9e45f7
DA		 2376 else {
2377 fprintf(stderr, "Invalid event type in field string.\n");
38efb539
RR		 2378 rc = -EINVAL;
2379 goto out;
2c9e45f7
DA		 2380 }
2381
2382 if (output[type].user_set)
2383 pr_warning("Overriding previous field request for %s events.\n",
2384 event_type(type));
2385
2386 output[type].fields = 0;
2387 output[type].user_set = true;
9cbdb702 2388 output[type].wildcard_set = false;
2c9e45f7
DA		 2389
2390 } else {
2391 tok = str;
2392 if (strlen(str) == 0) {
2393 fprintf(stderr,
2394 "Cannot set fields to 'none' for all event types.\n");
2395 rc = -EINVAL;
2396 goto out;
2397 }
2398
36ce5651
AK		 2399 /* Don't override defaults for +- */
2400 if (strchr(str, '+') || strchr(str, '-'))
2401 goto parse;
2402
2c9e45f7
DA		 2403 if (output_set_by_user())
2404 pr_warning("Overriding previous field request for all events.\n");
2405
1405720d 2406 for (j = 0; j < OUTPUT_TYPE_MAX; ++j) {
2c9e45f7
DA		 2407 output[j].fields = 0;
2408 output[j].user_set = true;
9cbdb702 2409 output[j].wildcard_set = true;
2c9e45f7 2410 }
745f43e3
DA		 2411 }
2412
36ce5651 2413parse:
49346e85 2414 for (tok = strtok_r(tok, ",", &strtok_saveptr); tok; tok = strtok_r(NULL, ",", &strtok_saveptr)) {
36ce5651
AK		 2415 if (*tok == '+') {
2416 if (change == SET)
2417 goto out_badmix;
2418 change = ADD;
2419 tok++;
2420 } else if (*tok == '-') {
2421 if (change == SET)
2422 goto out_badmix;
2423 change = REMOVE;
2424 tok++;
2425 } else {
2426 if (change != SET && change != DEFAULT)
2427 goto out_badmix;
2428 change = SET;
2429 }
2430
745f43e3 2431 for (i = 0; i < imax; ++i) {
2c9e45f7 2432 if (strcmp(tok, all_output_options[i].str) == 0)
745f43e3 2433 break;
745f43e3 2434 }
400ea6d3 2435 if (i == imax && strcmp(tok, "flags") == 0) {
36ce5651 2436 print_flags = change == REMOVE ? false : true;
400ea6d3
AH		 2437 continue;
2438 }
745f43e3 2439 if (i == imax) {
2c9e45f7 2440 fprintf(stderr, "Invalid field requested.\n");
745f43e3 2441 rc = -EINVAL;
2c9e45f7 2442 goto out;
745f43e3
DA		 2443 }
2444
2c9e45f7
DA		 2445 if (type == -1) {
2446 /* add user option to all events types for
2447 * which it is valid
2448 */
1405720d 2449 for (j = 0; j < OUTPUT_TYPE_MAX; ++j) {
2c9e45f7
DA		 2450 if (output[j].invalid_fields & all_output_options[i].field) {
2451 pr_warning("\'%s\' not valid for %s events. Ignoring.\n",
2452 all_output_options[i].str, event_type(j));
36ce5651
AK		 2453 } else {
2454 if (change == REMOVE)
2455 output[j].fields &= ~all_output_options[i].field;
2456 else
2457 output[j].fields |= all_output_options[i].field;
2458 }
2c9e45f7
DA		 2459 }
2460 } else {
2461 if (output[type].invalid_fields & all_output_options[i].field) {
2462 fprintf(stderr, "\'%s\' not valid for %s events.\n",
2463 all_output_options[i].str, event_type(type));
2464
2465 rc = -EINVAL;
2466 goto out;
2467 }
2468 output[type].fields |= all_output_options[i].field;
2469 }
745f43e3
DA		 2470 }
2471
2c9e45f7
DA		 2472 if (type >= 0) {
2473 if (output[type].fields == 0) {
2474 pr_debug("No fields requested for %s type. "
2475 "Events will not be displayed.\n", event_type(type));
2476 }
2477 }
36ce5651 2478 goto out;
745f43e3 2479
36ce5651
AK		 2480out_badmix:
2481 fprintf(stderr, "Cannot mix +-field with overridden fields\n");
2482 rc = -EINVAL;
2c9e45f7 2483out:
745f43e3
DA		 2484 free(str);
2485 return rc;
2486}
2487
a5e8e825
ACM		 2488#define for_each_lang(scripts_path, scripts_dir, lang_dirent) \
2489 while ((lang_dirent = readdir(scripts_dir)) != NULL) \
2490 if ((lang_dirent->d_type == DT_DIR || \
2491 (lang_dirent->d_type == DT_UNKNOWN && \
2492 is_directory(scripts_path, lang_dirent))) && \
2493 (strcmp(lang_dirent->d_name, ".")) && \
2494 (strcmp(lang_dirent->d_name, "..")))
2495
2496#define for_each_script(lang_path, lang_dir, script_dirent) \
2497 while ((script_dirent = readdir(lang_dir)) != NULL) \
2498 if (script_dirent->d_type != DT_DIR && \
2499 (script_dirent->d_type != DT_UNKNOWN || \
2500 !is_directory(lang_path, script_dirent)))
4b9c0c59
TZ		 2501
2502
2503#define RECORD_SUFFIX "-record"
2504#define REPORT_SUFFIX "-report"
2505
2506struct script_desc {
2507 struct list_head node;
2508 char *name;
2509 char *half_liner;
2510 char *args;
2511};
2512
eccdfe2d 2513static LIST_HEAD(script_descs);
4b9c0c59
TZ		 2514
2515static struct script_desc *script_desc__new(const char *name)
2516{
2517 struct script_desc *s = zalloc(sizeof(*s));
2518
b5b87312 2519 if (s != NULL && name)
4b9c0c59
TZ		 2520 s->name = strdup(name);
2521
2522 return s;
2523}
2524
2525static void script_desc__delete(struct script_desc *s)
2526{
74cf249d
ACM		 2527 zfree(&s->name);
2528 zfree(&s->half_liner);
2529 zfree(&s->args);
4b9c0c59
TZ		 2530 free(s);
2531}
2532
2533static void script_desc__add(struct script_desc *s)
2534{
2535 list_add_tail(&s->node, &script_descs);
2536}
2537
2538static struct script_desc *script_desc__find(const char *name)
2539{
2540 struct script_desc *s;
2541
2542 list_for_each_entry(s, &script_descs, node)
2543 if (strcasecmp(s->name, name) == 0)
2544 return s;
2545 return NULL;
2546}
2547
2548static struct script_desc *script_desc__findnew(const char *name)
2549{
2550 struct script_desc *s = script_desc__find(name);
2551
2552 if (s)
2553 return s;
2554
2555 s = script_desc__new(name);
2556 if (!s)
2ec5cab6 2557 return NULL;
4b9c0c59
TZ		 2558
2559 script_desc__add(s);
2560
2561 return s;
4b9c0c59
TZ		 2562}
2563
965bb6be 2564static const char *ends_with(const char *str, const char *suffix)
4b9c0c59
TZ		 2565{
2566 size_t suffix_len = strlen(suffix);
965bb6be 2567 const char *p = str;
4b9c0c59
TZ		 2568
2569 if (strlen(str) > suffix_len) {
2570 p = str + strlen(str) - suffix_len;
2571 if (!strncmp(p, suffix, suffix_len))
2572 return p;
2573 }
2574
2575 return NULL;
2576}
2577
4b9c0c59
TZ		 2578static int read_script_info(struct script_desc *desc, const char *filename)
2579{
2580 char line[BUFSIZ], *p;
2581 FILE *fp;
2582
2583 fp = fopen(filename, "r");
2584 if (!fp)
2585 return -1;
2586
2587 while (fgets(line, sizeof(line), fp)) {
2588 p = ltrim(line);
2589 if (strlen(p) == 0)
2590 continue;
2591 if (*p != '#')
2592 continue;
2593 p++;
2594 if (strlen(p) && *p == '!')
2595 continue;
2596
2597 p = ltrim(p);
2598 if (strlen(p) && p[strlen(p) - 1] == '\n')
2599 p[strlen(p) - 1] = '\0';
2600
2601 if (!strncmp(p, "description:", strlen("description:"))) {
2602 p += strlen("description:");
2603 desc->half_liner = strdup(ltrim(p));
2604 continue;
2605 }
2606
2607 if (!strncmp(p, "args:", strlen("args:"))) {
2608 p += strlen("args:");
2609 desc->args = strdup(ltrim(p));
2610 continue;
2611 }
2612 }
2613
2614 fclose(fp);
2615
2616 return 0;
2617}
2618
38efb539
RR		 2619static char *get_script_root(struct dirent *script_dirent, const char *suffix)
2620{
2621 char *script_root, *str;
2622
2623 script_root = strdup(script_dirent->d_name);
2624 if (!script_root)
2625 return NULL;
2626
2627 str = (char *)ends_with(script_root, suffix);
2628 if (!str) {
2629 free(script_root);
2630 return NULL;
2631 }
2632
2633 *str = '\0';
2634 return script_root;
2635}
2636
1d037ca1
IT		 2637static int list_available_scripts(const struct option *opt __maybe_unused,
2638 const char *s __maybe_unused,
2639 int unset __maybe_unused)
4b9c0c59 2640{
a5e8e825 2641 struct dirent *script_dirent, *lang_dirent;
4b9c0c59
TZ		 2642 char scripts_path[MAXPATHLEN];
2643 DIR *scripts_dir, *lang_dir;
2644 char script_path[MAXPATHLEN];
2645 char lang_path[MAXPATHLEN];
2646 struct script_desc *desc;
2647 char first_half[BUFSIZ];
2648 char *script_root;
4b9c0c59 2649
46113a54 2650 snprintf(scripts_path, MAXPATHLEN, "%s/scripts", get_argv_exec_path());
4b9c0c59
TZ		 2651
2652 scripts_dir = opendir(scripts_path);
88ded4d8
HK		 2653 if (!scripts_dir) {
2654 fprintf(stdout,
2655 "open(%s) failed.\n"
2656 "Check \"PERF_EXEC_PATH\" env to set scripts dir.\n",
2657 scripts_path);
2658 exit(-1);
2659 }
4b9c0c59 2660
a5e8e825 2661 for_each_lang(scripts_path, scripts_dir, lang_dirent) {
4b9c0c59 2662 snprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path,
a5e8e825 2663 lang_dirent->d_name);
4b9c0c59
TZ		 2664 lang_dir = opendir(lang_path);
2665 if (!lang_dir)
2666 continue;
2667
a5e8e825
ACM		 2668 for_each_script(lang_path, lang_dir, script_dirent) {
2669 script_root = get_script_root(script_dirent, REPORT_SUFFIX);
38efb539 2670 if (script_root) {
4b9c0c59
TZ		 2671 desc = script_desc__findnew(script_root);
2672 snprintf(script_path, MAXPATHLEN, "%s/%s",
a5e8e825 2673 lang_path, script_dirent->d_name);
4b9c0c59 2674 read_script_info(desc, script_path);
38efb539 2675 free(script_root);
4b9c0c59 2676 }
4b9c0c59
TZ		 2677 }
2678 }
2679
2680 fprintf(stdout, "List of available trace scripts:\n");
2681 list_for_each_entry(desc, &script_descs, node) {
2682 sprintf(first_half, "%s %s", desc->name,
2683 desc->args ? desc->args : "");
2684 fprintf(stdout, " %-36s %s\n", first_half,
2685 desc->half_liner ? desc->half_liner : "");
2686 }
2687
2688 exit(0);
2689}
2690
49e639e2
FT		 2691/*
2692 * Some scripts specify the required events in their "xxx-record" file,
2693 * this function will check if the events in perf.data match those
2694 * mentioned in the "xxx-record".
2695 *
2696 * Fixme: All existing "xxx-record" are all in good formats "-e event ",
2697 * which is covered well now. And new parsing code should be added to
2698 * cover the future complexing formats like event groups etc.
2699 */
2700static int check_ev_match(char *dir_name, char *scriptname,
2701 struct perf_session *session)
2702{
2703 char filename[MAXPATHLEN], evname[128];
2704 char line[BUFSIZ], *p;
2705 struct perf_evsel *pos;
2706 int match, len;
2707 FILE *fp;
2708
2709 sprintf(filename, "%s/bin/%s-record", dir_name, scriptname);
2710
2711 fp = fopen(filename, "r");
2712 if (!fp)
2713 return -1;
2714
2715 while (fgets(line, sizeof(line), fp)) {
2716 p = ltrim(line);
2717 if (*p == '#')
2718 continue;
2719
2720 while (strlen(p)) {
2721 p = strstr(p, "-e");
2722 if (!p)
2723 break;
2724
2725 p += 2;
2726 p = ltrim(p);
2727 len = strcspn(p, " \t");
2728 if (!len)
2729 break;
2730
2731 snprintf(evname, len + 1, "%s", p);
2732
2733 match = 0;
e5cadb93 2734 evlist__for_each_entry(session->evlist, pos) {
49e639e2
FT		 2735 if (!strcmp(perf_evsel__name(pos), evname)) {
2736 match = 1;
2737 break;
2738 }
2739 }
2740
2741 if (!match) {
2742 fclose(fp);
2743 return -1;
2744 }
2745 }
2746 }
2747
2748 fclose(fp);
2749 return 0;
2750}
2751
e5f3705e
FT		 2752/*
2753 * Return -1 if none is found, otherwise the actual scripts number.
2754 *
2755 * Currently the only user of this function is the script browser, which
2756 * will list all statically runnable scripts, select one, execute it and
2757 * show the output in a perf browser.
2758 */
2759int find_scripts(char **scripts_array, char **scripts_path_array)
2760{
a5e8e825 2761 struct dirent *script_dirent, *lang_dirent;
49e639e2 2762 char scripts_path[MAXPATHLEN], lang_path[MAXPATHLEN];
e5f3705e 2763 DIR *scripts_dir, *lang_dir;
49e639e2 2764 struct perf_session *session;
8ceb41d7 2765 struct perf_data data = {
eae8ad80
JO		 2766 .file = {
2767 .path = input_name,
2768 },
2769 .mode = PERF_DATA_MODE_READ,
f5fc1412 2770 };
e5f3705e
FT		 2771 char *temp;
2772 int i = 0;
2773
8ceb41d7 2774 session = perf_session__new(&data, false, NULL);
49e639e2
FT		 2775 if (!session)
2776 return -1;
2777
46113a54 2778 snprintf(scripts_path, MAXPATHLEN, "%s/scripts", get_argv_exec_path());
e5f3705e
FT		 2779
2780 scripts_dir = opendir(scripts_path);
49e639e2
FT		 2781 if (!scripts_dir) {
2782 perf_session__delete(session);
e5f3705e 2783 return -1;
49e639e2 2784 }
e5f3705e 2785
a5e8e825 2786 for_each_lang(scripts_path, scripts_dir, lang_dirent) {
e5f3705e 2787 snprintf(lang_path, MAXPATHLEN, "%s/%s", scripts_path,
a5e8e825 2788 lang_dirent->d_name);
e5f3705e
FT		 2789#ifdef NO_LIBPERL
2790 if (strstr(lang_path, "perl"))
2791 continue;
2792#endif
2793#ifdef NO_LIBPYTHON
2794 if (strstr(lang_path, "python"))
2795 continue;
2796#endif
2797
2798 lang_dir = opendir(lang_path);
2799 if (!lang_dir)
2800 continue;
2801
a5e8e825 2802 for_each_script(lang_path, lang_dir, script_dirent) {
e5f3705e 2803 /* Skip those real time scripts: xxxtop.p[yl] */
a5e8e825 2804 if (strstr(script_dirent->d_name, "top."))
e5f3705e
FT		 2805 continue;
2806 sprintf(scripts_path_array[i], "%s/%s", lang_path,
a5e8e825
ACM		 2807 script_dirent->d_name);
2808 temp = strchr(script_dirent->d_name, '.');
e5f3705e 2809 snprintf(scripts_array[i],
a5e8e825
ACM		 2810 (temp - script_dirent->d_name) + 1,
2811 "%s", script_dirent->d_name);
49e639e2
FT		 2812
2813 if (check_ev_match(lang_path,
2814 scripts_array[i], session))
2815 continue;
2816
e5f3705e
FT		 2817 i++;
2818 }
49e639e2 2819 closedir(lang_dir);
e5f3705e
FT		 2820 }
2821
49e639e2
FT		 2822 closedir(scripts_dir);
2823 perf_session__delete(session);
e5f3705e
FT		 2824 return i;
2825}
2826
3875294f
TZ		 2827static char *get_script_path(const char *script_root, const char *suffix)
2828{
a5e8e825 2829 struct dirent *script_dirent, *lang_dirent;
3875294f
TZ		 2830 char scripts_path[MAXPATHLEN];
2831 char script_path[MAXPATHLEN];
2832 DIR *scripts_dir, *lang_dir;
2833 char lang_path[MAXPATHLEN];
38efb539 2834 char *__script_root;
3875294f 2835
46113a54 2836 snprintf(scripts_path, MAXPATHLEN, "%s/scripts", get_argv_exec_path());
3875294f
TZ		 2837
2838 scripts_dir = opendir(scripts_path);
2839 if (!scripts_dir)
2840 return NULL;
2841
a5e8e825 2842 for_each_lang(scripts_path, scripts_dir, lang_dirent) {
3875294f 2843 snprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path,
a5e8e825 2844 lang_dirent->d_name);
3875294f
TZ		 2845 lang_dir = opendir(lang_path);
2846 if (!lang_dir)
2847 continue;
2848
a5e8e825
ACM		 2849 for_each_script(lang_path, lang_dir, script_dirent) {
2850 __script_root = get_script_root(script_dirent, suffix);
38efb539
RR		 2851 if (__script_root && !strcmp(script_root, __script_root)) {
2852 free(__script_root);
946ef2a2
NK		 2853 closedir(lang_dir);
2854 closedir(scripts_dir);
3875294f 2855 snprintf(script_path, MAXPATHLEN, "%s/%s",
a5e8e825 2856 lang_path, script_dirent->d_name);
38efb539 2857 return strdup(script_path);
3875294f
TZ		 2858 }
2859 free(__script_root);
2860 }
946ef2a2 2861 closedir(lang_dir);
3875294f 2862 }
946ef2a2 2863 closedir(scripts_dir);
3875294f 2864
38efb539 2865 return NULL;
3875294f
TZ		 2866}
2867
b5b87312
TZ		 2868static bool is_top_script(const char *script_path)
2869{
965bb6be 2870 return ends_with(script_path, "top") == NULL ? false : true;
b5b87312
TZ		 2871}
2872
2873static int has_required_arg(char *script_path)
2874{
2875 struct script_desc *desc;
2876 int n_args = 0;
2877 char *p;
2878
2879 desc = script_desc__new(NULL);
2880
2881 if (read_script_info(desc, script_path))
2882 goto out;
2883
2884 if (!desc->args)
2885 goto out;
2886
2887 for (p = desc->args; *p; p++)
2888 if (*p == '<')
2889 n_args++;
2890out:
2891 script_desc__delete(desc);
2892
2893 return n_args;
2894}
2895
69b6470e
ACM		 2896static int have_cmd(int argc, const char **argv)
2897{
2898 char **__argv = malloc(sizeof(const char *) * argc);
2899
2900 if (!__argv) {
2901 pr_err("malloc failed\n");
2902 return -1;
2903 }
2904
2905 memcpy(__argv, argv, sizeof(const char *) * argc);
2906 argc = parse_options(argc, (const char **)__argv, record_options,
2907 NULL, PARSE_OPT_STOP_AT_NON_OPTION);
2908 free(__argv);
5f9c39dc 2909
69b6470e
ACM		 2910 system_wide = (argc == 0);
2911
2912 return 0;
2913}
2914
7322d6c9
JO		 2915static void script__setup_sample_type(struct perf_script *script)
2916{
2917 struct perf_session *session = script->session;
2918 u64 sample_type = perf_evlist__combined_sample_type(session->evlist);
2919
2920 if (symbol_conf.use_callchain || symbol_conf.cumulate_callchain) {
2921 if ((sample_type & PERF_SAMPLE_REGS_USER) &&
eabad8c6 2922 (sample_type & PERF_SAMPLE_STACK_USER)) {
7322d6c9 2923 callchain_param.record_mode = CALLCHAIN_DWARF;
eabad8c6
ACM		 2924 dwarf_callchain_users = true;
2925 } else if (sample_type & PERF_SAMPLE_BRANCH_STACK)
7322d6c9
JO		 2926 callchain_param.record_mode = CALLCHAIN_LBR;
2927 else
2928 callchain_param.record_mode = CALLCHAIN_FP;
2929 }
2930}
2931
e099eba8
JO		 2932static int process_stat_round_event(struct perf_tool *tool __maybe_unused,
2933 union perf_event *event,
2934 struct perf_session *session)
2935{
2936 struct stat_round_event *round = &event->stat_round;
2937 struct perf_evsel *counter;
2938
e5cadb93 2939 evlist__for_each_entry(session->evlist, counter) {
e099eba8
JO		 2940 perf_stat_process_counter(&stat_config, counter);
2941 process_stat(counter, round->time);
2942 }
2943
2944 process_stat_interval(round->time);
2945 return 0;
2946}
2947
91a2c3d5
JO		 2948static int process_stat_config_event(struct perf_tool *tool __maybe_unused,
2949 union perf_event *event,
2950 struct perf_session *session __maybe_unused)
2951{
2952 perf_event__read_stat_config(&stat_config, &event->stat_config);
2953 return 0;
2954}
2955
cfc8874a
JO		 2956static int set_maps(struct perf_script *script)
2957{
2958 struct perf_evlist *evlist = script->session->evlist;
2959
2960 if (!script->cpus || !script->threads)
2961 return 0;
2962
2963 if (WARN_ONCE(script->allocated, "stats double allocation\n"))
2964 return -EINVAL;
2965
2966 perf_evlist__set_maps(evlist, script->cpus, script->threads);
2967
2968 if (perf_evlist__alloc_stats(evlist, true))
2969 return -ENOMEM;
2970
2971 script->allocated = true;
2972 return 0;
2973}
2974
2975static
2976int process_thread_map_event(struct perf_tool *tool,
2977 union perf_event *event,
2978 struct perf_session *session __maybe_unused)
2979{
2980 struct perf_script *script = container_of(tool, struct perf_script, tool);
2981
2982 if (script->threads) {
2983 pr_warning("Extra thread map event, ignoring.\n");
2984 return 0;
2985 }
2986
2987 script->threads = thread_map__new_event(&event->thread_map);
2988 if (!script->threads)
2989 return -ENOMEM;
2990
2991 return set_maps(script);
2992}
2993
2994static
2995int process_cpu_map_event(struct perf_tool *tool __maybe_unused,
2996 union perf_event *event,
2997 struct perf_session *session __maybe_unused)
2998{
2999 struct perf_script *script = container_of(tool, struct perf_script, tool);
3000
3001 if (script->cpus) {
3002 pr_warning("Extra cpu map event, ignoring.\n");
3003 return 0;
3004 }
3005
3006 script->cpus = cpu_map__new_data(&event->cpu_map.data);
3007 if (!script->cpus)
3008 return -ENOMEM;
3009
3010 return set_maps(script);
3011}
3012
fa48c892
ACM		 3013#ifdef HAVE_AUXTRACE_SUPPORT
3014static int perf_script__process_auxtrace_info(struct perf_tool *tool,
3015 union perf_event *event,
3016 struct perf_session *session)
3017{
3018 int ret = perf_event__process_auxtrace_info(tool, event, session);
3019
3020 if (ret == 0) {
3021 struct perf_script *script = container_of(tool, struct perf_script, tool);
3022
3023 ret = perf_script__setup_per_event_dump(script);
3024 }
3025
3026 return ret;
3027}
3028#else
3029#define perf_script__process_auxtrace_info 0
3030#endif
3031
b0ad8ea6 3032int cmd_script(int argc, const char **argv)
69b6470e
ACM		 3033{
3034 bool show_full_info = false;
e90debdd
JO		 3035 bool header = false;
3036 bool header_only = false;
6cc870f0 3037 bool script_started = false;
69b6470e
ACM		 3038 char *rec_script_path = NULL;
3039 char *rep_script_path = NULL;
3040 struct perf_session *session;
7a680eb9 3041 struct itrace_synth_opts itrace_synth_opts = { .set = false, };
69b6470e
ACM		 3042 char *script_path = NULL;
3043 const char **__argv;
6cc870f0 3044 int i, j, err = 0;
6f3e5eda
AH		 3045 struct perf_script script = {
3046 .tool = {
3047 .sample = process_sample_event,
3048 .mmap = perf_event__process_mmap,
3049 .mmap2 = perf_event__process_mmap2,
3050 .comm = perf_event__process_comm,
f3b3614a 3051 .namespaces = perf_event__process_namespaces,
6f3e5eda
AH		 3052 .exit = perf_event__process_exit,
3053 .fork = perf_event__process_fork,
7ea95727 3054 .attr = process_attr,
91daee30 3055 .event_update = perf_event__process_event_update,
6f3e5eda 3056 .tracing_data = perf_event__process_tracing_data,
e9def1b2 3057 .feature = perf_event__process_feature,
6f3e5eda 3058 .build_id = perf_event__process_build_id,
7a680eb9 3059 .id_index = perf_event__process_id_index,
fa48c892 3060 .auxtrace_info = perf_script__process_auxtrace_info,
7a680eb9
AH		 3061 .auxtrace = perf_event__process_auxtrace,
3062 .auxtrace_error = perf_event__process_auxtrace_error,
e099eba8
JO		 3063 .stat = perf_event__process_stat_event,
3064 .stat_round = process_stat_round_event,
91a2c3d5 3065 .stat_config = process_stat_config_event,
cfc8874a
JO		 3066 .thread_map = process_thread_map_event,
3067 .cpu_map = process_cpu_map_event,
0a8cb85c 3068 .ordered_events = true,
6f3e5eda
AH		 3069 .ordering_requires_timestamps = true,
3070 },
3071 };
8ceb41d7 3072 struct perf_data data = {
06af0f2c
YS		 3073 .mode = PERF_DATA_MODE_READ,
3074 };
69b6470e 3075 const struct option options[] = {
5f9c39dc
FW		 3076 OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
3077 "dump raw trace in ASCII"),
c0555642 3078 OPT_INCR('v', "verbose", &verbose,
69b6470e 3079 "be more verbose (show symbol address, etc)"),
4b9c0c59 3080 OPT_BOOLEAN('L', "Latency", &latency_format,
cda48461 3081 "show latency attributes (irqs/preemption disabled, etc)"),
4b9c0c59
TZ		 3082 OPT_CALLBACK_NOOPT('l', "list", NULL, NULL, "list available scripts",
3083 list_available_scripts),
956ffd02
TZ		 3084 OPT_CALLBACK('s', "script", NULL, "name",
3085 "script file name (lang:script name, script name, or *)",
3086 parse_scriptname),
3087 OPT_STRING('g', "gen-script", &generate_script_lang, "lang",
133dc4c3 3088 "generate perf-script.xx script in specified language"),
69b6470e 3089 OPT_STRING('i', "input", &input_name, "file", "input file name"),
ffabd99e
FW		 3090 OPT_BOOLEAN('d', "debug-mode", &debug_mode,
3091 "do various checks like samples ordering and lost events"),
e90debdd
JO		 3092 OPT_BOOLEAN(0, "header", &header, "Show data header."),
3093 OPT_BOOLEAN(0, "header-only", &header_only, "Show only data header."),
c0230b2b
DA		 3094 OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
3095 "file", "vmlinux pathname"),
3096 OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name,
3097 "file", "kallsyms pathname"),
3098 OPT_BOOLEAN('G', "hide-call-graph", &no_callchain,
3099 "When printing symbols do not display call chain"),
a7066709
HK		 3100 OPT_CALLBACK(0, "symfs", NULL, "directory",
3101 "Look for files with symbols relative to this directory",
3102 symbol__config_symfs),
06af0f2c 3103 OPT_CALLBACK('F', "fields", NULL, "str",
a978f2ab 3104 "comma separated output fields prepend with 'type:'. "
36ce5651 3105 "+field to add and -field to remove."
1405720d 3106 "Valid types: hw,sw,trace,raw,synth. "
a978f2ab 3107 "Fields: comm,tid,pid,time,cpu,event,trace,ip,sym,dso,"
b1491ace 3108 "addr,symoff,period,iregs,uregs,brstack,brstacksym,flags,"
49d58f04 3109 "bpf-output,callindent,insn,insnlen,brstackinsn,synth,phys_addr",
48d02a1d 3110 parse_output_fields),
317df650 3111 OPT_BOOLEAN('a', "all-cpus", &system_wide,
69b6470e 3112 "system-wide collection from all CPUs"),
36385be5
FT		 3113 OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
3114 "only consider these symbols"),
64eff7d9
DA		 3115 OPT_STRING(0, "stop-bt", &symbol_conf.bt_stop_list_str, "symbol[,symbol...]",
3116 "Stop display of callgraph at these symbols"),
c8e66720 3117 OPT_STRING('C', "cpu", &cpu_list, "cpu", "list of cpus to profile"),
e7984b7b
DA		 3118 OPT_STRING('c', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
3119 "only display events for these comms"),
e03eaa40
DA		 3120 OPT_STRING(0, "pid", &symbol_conf.pid_list_str, "pid[,pid...]",
3121 "only consider symbols in these pids"),
3122 OPT_STRING(0, "tid", &symbol_conf.tid_list_str, "tid[,tid...]",
3123 "only consider symbols in these tids"),
6125cc8d
ACM		 3124 OPT_UINTEGER(0, "max-stack", &scripting_max_stack,
3125 "Set the maximum stack depth when parsing the callchain, "
3126 "anything beyond the specified depth will be ignored. "
4cb93446 3127 "Default: kernel.perf_event_max_stack or " __stringify(PERF_MAX_STACK_DEPTH)),
fbe96f29
SE		 3128 OPT_BOOLEAN('I', "show-info", &show_full_info,
3129 "display extended information from perf.data file"),
0bc8d205
AN		 3130 OPT_BOOLEAN('\0', "show-kernel-path", &symbol_conf.show_kernel_path,
3131 "Show the path of [kernel.kallsyms]"),
ad7ebb9a
NK		 3132 OPT_BOOLEAN('\0', "show-task-events", &script.show_task_events,
3133 "Show the fork/comm/exit events"),
ba1ddf42
NK		 3134 OPT_BOOLEAN('\0', "show-mmap-events", &script.show_mmap_events,
3135 "Show the mmap events"),
7c14898b
AH		 3136 OPT_BOOLEAN('\0', "show-switch-events", &script.show_switch_events,
3137 "Show context switch events (if recorded)"),
96a44bbc
HB		 3138 OPT_BOOLEAN('\0', "show-namespace-events", &script.show_namespace_events,
3139 "Show namespace events (if recorded)"),
3d7c27b6
JO		 3140 OPT_BOOLEAN('\0', "show-lost-events", &script.show_lost_events,
3141 "Show lost events (if recorded)"),
a14390fd
ACM		 3142 OPT_BOOLEAN('\0', "per-event-dump", &script.per_event_dump,
3143 "Dump trace output to files named by the monitored events"),
be3d466c 3144 OPT_BOOLEAN('f', "force", &symbol_conf.force, "don't complain, do it"),
48d02a1d
AK		 3145 OPT_INTEGER(0, "max-blocks", &max_blocks,
3146 "Maximum number of code blocks to dump with brstackinsn"),
83e19860
AH		 3147 OPT_BOOLEAN(0, "ns", &nanosecs,
3148 "Use 9 decimal places when displaying time"),
7a680eb9
AH		 3149 OPT_CALLBACK_OPTARG(0, "itrace", &itrace_synth_opts, NULL, "opts",
3150 "Instruction Tracing options",
3151 itrace_parse_synth_opts),
a9710ba0
AK		 3152 OPT_BOOLEAN(0, "full-source-path", &srcline_full_filename,
3153 "Show full source file name path for source lines"),
77e0070d
MD		 3154 OPT_BOOLEAN(0, "demangle", &symbol_conf.demangle,
3155 "Enable symbol demangling"),
3156 OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf.demangle_kernel,
3157 "Enable kernel symbol demangling"),
a91f4c47
DA		 3158 OPT_STRING(0, "time", &script.time_str, "str",
3159 "Time span of interest (start,stop)"),
325fbff5
NK		 3160 OPT_BOOLEAN(0, "inline", &symbol_conf.inline_name,
3161 "Show inline function"),
1909629f 3162 OPT_END()
69b6470e 3163 };
40cae2b7
YS		 3164 const char * const script_subcommands[] = { "record", "report", NULL };
3165 const char *script_usage[] = {
69b6470e
ACM		 3166 "perf script [<options>]",
3167 "perf script [<options>] record <script> [<record-options>] <command>",
3168 "perf script [<options>] report <script> [script-args]",
3169 "perf script [<options>] <script> [<record-options>] <command>",
3170 "perf script [<options>] <top-script> [script-args]",
3171 NULL
3172 };
3875294f 3173
0a7c74ea
ACM		 3174 perf_set_singlethreaded();
3175
b5b87312
TZ		 3176 setup_scripting();
3177
40cae2b7 3178 argc = parse_options_subcommand(argc, argv, options, script_subcommands, script_usage,
b5b87312
TZ		 3179 PARSE_OPT_STOP_AT_NON_OPTION);
3180
eae8ad80
JO		 3181 data.file.path = input_name;
3182 data.force = symbol_conf.force;
f5fc1412 3183
b5b87312
TZ		 3184 if (argc > 1 && !strncmp(argv[0], "rec", strlen("rec"))) {
3185 rec_script_path = get_script_path(argv[1], RECORD_SUFFIX);
3186 if (!rec_script_path)
b0ad8ea6 3187 return cmd_record(argc, argv);
3875294f
TZ		 3188 }
3189
b5b87312
TZ		 3190 if (argc > 1 && !strncmp(argv[0], "rep", strlen("rep"))) {
3191 rep_script_path = get_script_path(argv[1], REPORT_SUFFIX);
3192 if (!rep_script_path) {
3875294f 3193 fprintf(stderr,
b5b87312 3194 "Please specify a valid report script"
133dc4c3 3195 "(see 'perf script -l' for listing)\n");
3875294f
TZ		 3196 return -1;
3197 }
3875294f
TZ		 3198 }
3199
3c5b645f
AH		 3200 if (itrace_synth_opts.callchain &&
3201 itrace_synth_opts.callchain_sz > scripting_max_stack)
3202 scripting_max_stack = itrace_synth_opts.callchain_sz;
3203
44e668c6 3204 /* make sure PERF_EXEC_PATH is set for scripts */
46113a54 3205 set_argv_exec_path(get_argv_exec_path());
44e668c6 3206
b5b87312 3207 if (argc && !script_name && !rec_script_path && !rep_script_path) {
a0cccc2e 3208 int live_pipe[2];
b5b87312 3209 int rep_args;
a0cccc2e
TZ		 3210 pid_t pid;
3211
b5b87312
TZ		 3212 rec_script_path = get_script_path(argv[0], RECORD_SUFFIX);
3213 rep_script_path = get_script_path(argv[0], REPORT_SUFFIX);
3214
3215 if (!rec_script_path && !rep_script_path) {
c7118369
NK		 3216 usage_with_options_msg(script_usage, options,
3217 "Couldn't find script `%s'\n\n See perf"
133dc4c3 3218 " script -l for available scripts.\n", argv[0]);
a0cccc2e
TZ		 3219 }
3220
b5b87312
TZ		 3221 if (is_top_script(argv[0])) {
3222 rep_args = argc - 1;
3223 } else {
3224 int rec_args;
3225
3226 rep_args = has_required_arg(rep_script_path);
3227 rec_args = (argc - 1) - rep_args;
3228 if (rec_args < 0) {
c7118369
NK		 3229 usage_with_options_msg(script_usage, options,
3230 "`%s' script requires options."
133dc4c3 3231 "\n\n See perf script -l for available "
b5b87312 3232 "scripts and options.\n", argv[0]);
b5b87312 3233 }
a0cccc2e
TZ		 3234 }
3235
3236 if (pipe(live_pipe) < 0) {
3237 perror("failed to create pipe");
d54b1a9e 3238 return -1;
a0cccc2e
TZ		 3239 }
3240
3241 pid = fork();
3242 if (pid < 0) {
3243 perror("failed to fork");
d54b1a9e 3244 return -1;
a0cccc2e
TZ		 3245 }
3246
3247 if (!pid) {
b5b87312
TZ		 3248 j = 0;
3249
a0cccc2e
TZ		 3250 dup2(live_pipe[1], 1);
3251 close(live_pipe[0]);
3252
317df650
RR		 3253 if (is_top_script(argv[0])) {
3254 system_wide = true;
3255 } else if (!system_wide) {
d54b1a9e
DA		 3256 if (have_cmd(argc - rep_args, &argv[rep_args]) != 0) {
3257 err = -1;
3258 goto out;
3259 }
317df650 3260 }
b5b87312
TZ		 3261
3262 __argv = malloc((argc + 6) * sizeof(const char *));
d54b1a9e
DA		 3263 if (!__argv) {
3264 pr_err("malloc failed\n");
3265 err = -ENOMEM;
3266 goto out;
3267 }
e8719adf 3268
b5b87312
TZ		 3269 __argv[j++] = "/bin/sh";
3270 __argv[j++] = rec_script_path;
3271 if (system_wide)
3272 __argv[j++] = "-a";
3273 __argv[j++] = "-q";
3274 __argv[j++] = "-o";
3275 __argv[j++] = "-";
3276 for (i = rep_args + 1; i < argc; i++)
3277 __argv[j++] = argv[i];
3278 __argv[j++] = NULL;
a0cccc2e
TZ		 3279
3280 execvp("/bin/sh", (char **)__argv);
e8719adf 3281 free(__argv);
a0cccc2e
TZ		 3282 exit(-1);
3283 }
3284
3285 dup2(live_pipe[0], 0);
3286 close(live_pipe[1]);
3287
b5b87312 3288 __argv = malloc((argc + 4) * sizeof(const char *));
d54b1a9e
DA		 3289 if (!__argv) {
3290 pr_err("malloc failed\n");
3291 err = -ENOMEM;
3292 goto out;
3293 }
3294
b5b87312
TZ		 3295 j = 0;
3296 __argv[j++] = "/bin/sh";
3297 __argv[j++] = rep_script_path;
3298 for (i = 1; i < rep_args + 1; i++)
3299 __argv[j++] = argv[i];
3300 __argv[j++] = "-i";
3301 __argv[j++] = "-";
3302 __argv[j++] = NULL;
a0cccc2e
TZ		 3303
3304 execvp("/bin/sh", (char **)__argv);
e8719adf 3305 free(__argv);
a0cccc2e
TZ		 3306 exit(-1);
3307 }
3308
b5b87312
TZ		 3309 if (rec_script_path)
3310 script_path = rec_script_path;
3311 if (rep_script_path)
3312 script_path = rep_script_path;
34c86ea9 3313
b5b87312 3314 if (script_path) {
b5b87312 3315 j = 0;
3875294f 3316
317df650
RR		 3317 if (!rec_script_path)
3318 system_wide = false;
d54b1a9e
DA		 3319 else if (!system_wide) {
3320 if (have_cmd(argc - 1, &argv[1]) != 0) {
3321 err = -1;
3322 goto out;
3323 }
3324 }
34c86ea9 3325
b5b87312 3326 __argv = malloc((argc + 2) * sizeof(const char *));
d54b1a9e
DA		 3327 if (!__argv) {
3328 pr_err("malloc failed\n");
3329 err = -ENOMEM;
3330 goto out;
3331 }
3332
34c86ea9
TZ		 3333 __argv[j++] = "/bin/sh";
3334 __argv[j++] = script_path;
3335 if (system_wide)
3336 __argv[j++] = "-a";
b5b87312 3337 for (i = 2; i < argc; i++)
34c86ea9
TZ		 3338 __argv[j++] = argv[i];
3339 __argv[j++] = NULL;
3875294f
TZ		 3340
3341 execvp("/bin/sh", (char **)__argv);
e8719adf 3342 free(__argv);
3875294f
TZ		 3343 exit(-1);
3344 }
956ffd02 3345
cf4fee50
TZ		 3346 if (!script_name)
3347 setup_pager();
5f9c39dc 3348
8ceb41d7 3349 session = perf_session__new(&data, false, &script.tool);
d8f66248 3350 if (session == NULL)
52e02834 3351 return -1;
d8f66248 3352
e90debdd 3353 if (header || header_only) {
114f709e 3354 script.tool.show_feat_hdr = SHOW_FEAT_HEADER;
e90debdd
JO		 3355 perf_session__fprintf_info(session, stdout, show_full_info);
3356 if (header_only)
6cc870f0 3357 goto out_delete;
e90debdd 3358 }
114f709e
DCC		 3359 if (show_full_info)
3360 script.tool.show_feat_hdr = SHOW_FEAT_HEADER_FULL_INFO;
e90debdd 3361
0a7e6d1b 3362 if (symbol__init(&session->header.env) < 0)
38520dc3
NK		 3363 goto out_delete;
3364
6f3e5eda 3365 script.session = session;
7322d6c9 3366 script__setup_sample_type(&script);
6f3e5eda 3367
e216708d
AH		 3368 if (output[PERF_TYPE_HARDWARE].fields & PERF_OUTPUT_CALLINDENT)
3369 itrace_synth_opts.thread_stack = true;
3370
7a680eb9
AH		 3371 session->itrace_synth_opts = &itrace_synth_opts;
3372
5d67be97 3373 if (cpu_list) {
6cc870f0
NK		 3374 err = perf_session__cpu_bitmap(session, cpu_list, cpu_bitmap);
3375 if (err < 0)
3376 goto out_delete;
644e0840 3377 itrace_synth_opts.cpu_bitmap = cpu_bitmap;
5d67be97
AB		 3378 }
3379
1424dc96 3380 if (!no_callchain)
c0230b2b
DA		 3381 symbol_conf.use_callchain = true;
3382 else
3383 symbol_conf.use_callchain = false;
3384
9ee67421
ACM		 3385 if (session->tevent.pevent &&
3386 pevent_set_function_resolver(session->tevent.pevent,
ccb3a829
ACM		 3387 machine__resolve_kernel_addr,
3388 &session->machines.host) < 0) {
3389 pr_err("%s: failed to set libtraceevent function resolver\n", __func__);
db49bc15
CJ		 3390 err = -1;
3391 goto out_delete;
ccb3a829
ACM		 3392 }
3393
956ffd02
TZ		 3394 if (generate_script_lang) {
3395 struct stat perf_stat;
745f43e3
DA		 3396 int input;
3397
2c9e45f7 3398 if (output_set_by_user()) {
745f43e3
DA		 3399 fprintf(stderr,
3400 "custom fields not supported for generated scripts");
6cc870f0
NK		 3401 err = -EINVAL;
3402 goto out_delete;
745f43e3 3403 }
956ffd02 3404
eae8ad80 3405 input = open(data.file.path, O_RDONLY); /* input_name */
956ffd02 3406 if (input < 0) {
6cc870f0 3407 err = -errno;
956ffd02 3408 perror("failed to open file");
6cc870f0 3409 goto out_delete;
956ffd02
TZ		 3410 }
3411
3412 err = fstat(input, &perf_stat);
3413 if (err < 0) {
3414 perror("failed to stat file");
6cc870f0 3415 goto out_delete;
956ffd02
TZ		 3416 }
3417
3418 if (!perf_stat.st_size) {
3419 fprintf(stderr, "zero-sized file, nothing to do!\n");
6cc870f0 3420 goto out_delete;
956ffd02
TZ		 3421 }
3422
3423 scripting_ops = script_spec__lookup(generate_script_lang);
3424 if (!scripting_ops) {
3425 fprintf(stderr, "invalid language specifier");
6cc870f0
NK		 3426 err = -ENOENT;
3427 goto out_delete;
956ffd02
TZ		 3428 }
3429
29f5ffd3 3430 err = scripting_ops->generate_script(session->tevent.pevent,
da378962 3431 "perf-script");
6cc870f0 3432 goto out_delete;
956ffd02
TZ		 3433 }
3434
3435 if (script_name) {
586bc5cc 3436 err = scripting_ops->start_script(script_name, argc, argv);
956ffd02 3437 if (err)
6cc870f0 3438 goto out_delete;
133dc4c3 3439 pr_debug("perf script started with script %s\n\n", script_name);
6cc870f0 3440 script_started = true;
956ffd02
TZ		 3441 }
3442
9cbdb702
DA		 3443
3444 err = perf_session__check_output_opt(session);
3445 if (err < 0)
6cc870f0 3446 goto out_delete;
9cbdb702 3447
cc2ef584
JY		 3448 script.ptime_range = perf_time__range_alloc(script.time_str,
3449 &script.range_size);
3450 if (!script.ptime_range) {
3451 err = -ENOMEM;
3452 goto out_delete;
3453 }
3454
a91f4c47 3455 /* needs to be parsed after looking up reference time */
2ab046cd
JY		 3456 if (perf_time__parse_str(script.ptime_range, script.time_str) != 0) {
3457 if (session->evlist->first_sample_time == 0 &&
3458 session->evlist->last_sample_time == 0) {
1e2778e9
JY		 3459 pr_err("HINT: no first/last sample time found in perf data.\n"
3460 "Please use latest perf binary to execute 'perf record'\n"
3461 "(if '--buildid-all' is enabled, please set '--timestamp-boundary').\n");
2ab046cd
JY		 3462 err = -EINVAL;
3463 goto out_delete;
3464 }
3465
3466 script.range_num = perf_time__percent_parse_str(
cc2ef584 3467 script.ptime_range, script.range_size,
2ab046cd
JY		 3468 script.time_str,
3469 session->evlist->first_sample_time,
3470 session->evlist->last_sample_time);
3471
3472 if (script.range_num < 0) {
3473 pr_err("Invalid time string\n");
3474 err = -EINVAL;
3475 goto out_delete;
3476 }
3477 } else {
3478 script.range_num = 1;
a91f4c47
DA		 3479 }
3480
6f3e5eda 3481 err = __cmd_script(&script);
956ffd02 3482
d445dd2a
AH		 3483 flush_scripting();
3484
6cc870f0 3485out_delete:
cc2ef584
JY		 3486 zfree(&script.ptime_range);
3487
cfc8874a 3488 perf_evlist__free_stats(session->evlist);
d8f66248 3489 perf_session__delete(session);
6cc870f0
NK		 3490
3491 if (script_started)
3492 cleanup_scripting();
956ffd02
TZ		 3493out:
3494 return err;
5f9c39dc 3495}
Linux 6.x block layer and io_uring tree(s)