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