1 // SPDX-License-Identifier: GPL-2.0
4 #include "util/counts.h"
5 #include "util/debug.h"
7 #include <subcmd/exec-cmd.h>
8 #include "util/header.h"
9 #include <subcmd/parse-options.h>
10 #include "util/perf_regs.h"
11 #include "util/session.h"
12 #include "util/tool.h"
14 #include "util/srcline.h"
15 #include "util/symbol.h"
16 #include "util/thread.h"
17 #include "util/trace-event.h"
18 #include "util/evlist.h"
19 #include "util/evsel.h"
20 #include "util/evsel_fprintf.h"
21 #include "util/evswitch.h"
22 #include "util/sort.h"
23 #include "util/data.h"
24 #include "util/auxtrace.h"
25 #include "util/cpumap.h"
26 #include "util/thread_map.h"
27 #include "util/stat.h"
28 #include "util/color.h"
29 #include "util/string2.h"
30 #include "util/thread-stack.h"
31 #include "util/time-utils.h"
32 #include "util/path.h"
33 #include "util/event.h"
35 #include "print_binary.h"
37 #include <linux/bitmap.h>
38 #include <linux/kernel.h>
39 #include <linux/stringify.h>
40 #include <linux/time64.h>
41 #include <linux/zalloc.h>
42 #include <sys/utsname.h>
44 #include "util/mem-events.h"
45 #include "util/dump-insn.h"
50 #include <sys/param.h>
51 #include <sys/types.h>
55 #include <subcmd/pager.h>
56 #include <perf/evlist.h>
57 #include <linux/err.h>
58 #include "util/dlfilter.h"
59 #include "util/record.h"
60 #include "util/util.h"
63 #include <linux/ctype.h>
65 static char const *script_name
;
66 static char const *generate_script_lang
;
68 static bool deltatime
;
69 static u64 initial_time
;
70 static u64 previous_time
;
71 static bool debug_mode
;
72 static u64 last_timestamp
;
73 static u64 nr_unordered
;
74 static bool no_callchain
;
75 static bool latency_format
;
76 static bool system_wide
;
77 static bool print_flags
;
78 static const char *cpu_list
;
79 static DECLARE_BITMAP(cpu_bitmap
, MAX_NR_CPUS
);
80 static struct perf_stat_config stat_config
;
81 static int max_blocks
;
82 static bool native_arch
;
83 static struct dlfilter
*dlfilter
;
87 unsigned int scripting_max_stack
= PERF_MAX_STACK_DEPTH
;
89 enum perf_output_field
{
90 PERF_OUTPUT_COMM
= 1ULL << 0,
91 PERF_OUTPUT_TID
= 1ULL << 1,
92 PERF_OUTPUT_PID
= 1ULL << 2,
93 PERF_OUTPUT_TIME
= 1ULL << 3,
94 PERF_OUTPUT_CPU
= 1ULL << 4,
95 PERF_OUTPUT_EVNAME
= 1ULL << 5,
96 PERF_OUTPUT_TRACE
= 1ULL << 6,
97 PERF_OUTPUT_IP
= 1ULL << 7,
98 PERF_OUTPUT_SYM
= 1ULL << 8,
99 PERF_OUTPUT_DSO
= 1ULL << 9,
100 PERF_OUTPUT_ADDR
= 1ULL << 10,
101 PERF_OUTPUT_SYMOFFSET
= 1ULL << 11,
102 PERF_OUTPUT_SRCLINE
= 1ULL << 12,
103 PERF_OUTPUT_PERIOD
= 1ULL << 13,
104 PERF_OUTPUT_IREGS
= 1ULL << 14,
105 PERF_OUTPUT_BRSTACK
= 1ULL << 15,
106 PERF_OUTPUT_BRSTACKSYM
= 1ULL << 16,
107 PERF_OUTPUT_DATA_SRC
= 1ULL << 17,
108 PERF_OUTPUT_WEIGHT
= 1ULL << 18,
109 PERF_OUTPUT_BPF_OUTPUT
= 1ULL << 19,
110 PERF_OUTPUT_CALLINDENT
= 1ULL << 20,
111 PERF_OUTPUT_INSN
= 1ULL << 21,
112 PERF_OUTPUT_INSNLEN
= 1ULL << 22,
113 PERF_OUTPUT_BRSTACKINSN
= 1ULL << 23,
114 PERF_OUTPUT_BRSTACKOFF
= 1ULL << 24,
115 PERF_OUTPUT_SYNTH
= 1ULL << 25,
116 PERF_OUTPUT_PHYS_ADDR
= 1ULL << 26,
117 PERF_OUTPUT_UREGS
= 1ULL << 27,
118 PERF_OUTPUT_METRIC
= 1ULL << 28,
119 PERF_OUTPUT_MISC
= 1ULL << 29,
120 PERF_OUTPUT_SRCCODE
= 1ULL << 30,
121 PERF_OUTPUT_IPC
= 1ULL << 31,
122 PERF_OUTPUT_TOD
= 1ULL << 32,
123 PERF_OUTPUT_DATA_PAGE_SIZE
= 1ULL << 33,
124 PERF_OUTPUT_CODE_PAGE_SIZE
= 1ULL << 34,
128 struct perf_tool tool
;
129 struct perf_session
*session
;
130 bool show_task_events
;
131 bool show_mmap_events
;
132 bool show_switch_events
;
133 bool show_namespace_events
;
134 bool show_lost_events
;
135 bool show_round_events
;
136 bool show_bpf_events
;
137 bool show_cgroup_events
;
138 bool show_text_poke_events
;
142 struct evswitch evswitch
;
143 struct perf_cpu_map
*cpus
;
144 struct perf_thread_map
*threads
;
146 const char *time_str
;
147 struct perf_time_interval
*ptime_range
;
152 struct output_option
{
154 enum perf_output_field field
;
155 } all_output_options
[] = {
156 {.str
= "comm", .field
= PERF_OUTPUT_COMM
},
157 {.str
= "tid", .field
= PERF_OUTPUT_TID
},
158 {.str
= "pid", .field
= PERF_OUTPUT_PID
},
159 {.str
= "time", .field
= PERF_OUTPUT_TIME
},
160 {.str
= "cpu", .field
= PERF_OUTPUT_CPU
},
161 {.str
= "event", .field
= PERF_OUTPUT_EVNAME
},
162 {.str
= "trace", .field
= PERF_OUTPUT_TRACE
},
163 {.str
= "ip", .field
= PERF_OUTPUT_IP
},
164 {.str
= "sym", .field
= PERF_OUTPUT_SYM
},
165 {.str
= "dso", .field
= PERF_OUTPUT_DSO
},
166 {.str
= "addr", .field
= PERF_OUTPUT_ADDR
},
167 {.str
= "symoff", .field
= PERF_OUTPUT_SYMOFFSET
},
168 {.str
= "srcline", .field
= PERF_OUTPUT_SRCLINE
},
169 {.str
= "period", .field
= PERF_OUTPUT_PERIOD
},
170 {.str
= "iregs", .field
= PERF_OUTPUT_IREGS
},
171 {.str
= "uregs", .field
= PERF_OUTPUT_UREGS
},
172 {.str
= "brstack", .field
= PERF_OUTPUT_BRSTACK
},
173 {.str
= "brstacksym", .field
= PERF_OUTPUT_BRSTACKSYM
},
174 {.str
= "data_src", .field
= PERF_OUTPUT_DATA_SRC
},
175 {.str
= "weight", .field
= PERF_OUTPUT_WEIGHT
},
176 {.str
= "bpf-output", .field
= PERF_OUTPUT_BPF_OUTPUT
},
177 {.str
= "callindent", .field
= PERF_OUTPUT_CALLINDENT
},
178 {.str
= "insn", .field
= PERF_OUTPUT_INSN
},
179 {.str
= "insnlen", .field
= PERF_OUTPUT_INSNLEN
},
180 {.str
= "brstackinsn", .field
= PERF_OUTPUT_BRSTACKINSN
},
181 {.str
= "brstackoff", .field
= PERF_OUTPUT_BRSTACKOFF
},
182 {.str
= "synth", .field
= PERF_OUTPUT_SYNTH
},
183 {.str
= "phys_addr", .field
= PERF_OUTPUT_PHYS_ADDR
},
184 {.str
= "metric", .field
= PERF_OUTPUT_METRIC
},
185 {.str
= "misc", .field
= PERF_OUTPUT_MISC
},
186 {.str
= "srccode", .field
= PERF_OUTPUT_SRCCODE
},
187 {.str
= "ipc", .field
= PERF_OUTPUT_IPC
},
188 {.str
= "tod", .field
= PERF_OUTPUT_TOD
},
189 {.str
= "data_page_size", .field
= PERF_OUTPUT_DATA_PAGE_SIZE
},
190 {.str
= "code_page_size", .field
= PERF_OUTPUT_CODE_PAGE_SIZE
},
194 OUTPUT_TYPE_SYNTH
= PERF_TYPE_MAX
,
199 /* default set to maintain compatibility with current format */
203 unsigned int print_ip_opts
;
207 u64 user_unset_fields
;
208 } output
[OUTPUT_TYPE_MAX
] = {
210 [PERF_TYPE_HARDWARE
] = {
213 .fields
= PERF_OUTPUT_COMM
| PERF_OUTPUT_TID
|
214 PERF_OUTPUT_CPU
| PERF_OUTPUT_TIME
|
215 PERF_OUTPUT_EVNAME
| PERF_OUTPUT_IP
|
216 PERF_OUTPUT_SYM
| PERF_OUTPUT_SYMOFFSET
|
217 PERF_OUTPUT_DSO
| PERF_OUTPUT_PERIOD
,
219 .invalid_fields
= PERF_OUTPUT_TRACE
| PERF_OUTPUT_BPF_OUTPUT
,
222 [PERF_TYPE_SOFTWARE
] = {
225 .fields
= PERF_OUTPUT_COMM
| PERF_OUTPUT_TID
|
226 PERF_OUTPUT_CPU
| PERF_OUTPUT_TIME
|
227 PERF_OUTPUT_EVNAME
| PERF_OUTPUT_IP
|
228 PERF_OUTPUT_SYM
| PERF_OUTPUT_SYMOFFSET
|
229 PERF_OUTPUT_DSO
| PERF_OUTPUT_PERIOD
|
230 PERF_OUTPUT_BPF_OUTPUT
,
232 .invalid_fields
= PERF_OUTPUT_TRACE
,
235 [PERF_TYPE_TRACEPOINT
] = {
238 .fields
= PERF_OUTPUT_COMM
| PERF_OUTPUT_TID
|
239 PERF_OUTPUT_CPU
| PERF_OUTPUT_TIME
|
240 PERF_OUTPUT_EVNAME
| PERF_OUTPUT_TRACE
243 [PERF_TYPE_HW_CACHE
] = {
246 .fields
= PERF_OUTPUT_COMM
| PERF_OUTPUT_TID
|
247 PERF_OUTPUT_CPU
| PERF_OUTPUT_TIME
|
248 PERF_OUTPUT_EVNAME
| PERF_OUTPUT_IP
|
249 PERF_OUTPUT_SYM
| PERF_OUTPUT_SYMOFFSET
|
250 PERF_OUTPUT_DSO
| PERF_OUTPUT_PERIOD
,
252 .invalid_fields
= PERF_OUTPUT_TRACE
| PERF_OUTPUT_BPF_OUTPUT
,
258 .fields
= PERF_OUTPUT_COMM
| PERF_OUTPUT_TID
|
259 PERF_OUTPUT_CPU
| PERF_OUTPUT_TIME
|
260 PERF_OUTPUT_EVNAME
| PERF_OUTPUT_IP
|
261 PERF_OUTPUT_SYM
| PERF_OUTPUT_SYMOFFSET
|
262 PERF_OUTPUT_DSO
| PERF_OUTPUT_PERIOD
|
263 PERF_OUTPUT_ADDR
| PERF_OUTPUT_DATA_SRC
|
264 PERF_OUTPUT_WEIGHT
| PERF_OUTPUT_PHYS_ADDR
|
265 PERF_OUTPUT_DATA_PAGE_SIZE
| PERF_OUTPUT_CODE_PAGE_SIZE
,
267 .invalid_fields
= PERF_OUTPUT_TRACE
| PERF_OUTPUT_BPF_OUTPUT
,
270 [PERF_TYPE_BREAKPOINT
] = {
273 .fields
= PERF_OUTPUT_COMM
| PERF_OUTPUT_TID
|
274 PERF_OUTPUT_CPU
| PERF_OUTPUT_TIME
|
275 PERF_OUTPUT_EVNAME
| PERF_OUTPUT_IP
|
276 PERF_OUTPUT_SYM
| PERF_OUTPUT_SYMOFFSET
|
277 PERF_OUTPUT_DSO
| PERF_OUTPUT_PERIOD
,
279 .invalid_fields
= PERF_OUTPUT_TRACE
| PERF_OUTPUT_BPF_OUTPUT
,
282 [OUTPUT_TYPE_SYNTH
] = {
285 .fields
= PERF_OUTPUT_COMM
| PERF_OUTPUT_TID
|
286 PERF_OUTPUT_CPU
| PERF_OUTPUT_TIME
|
287 PERF_OUTPUT_EVNAME
| PERF_OUTPUT_IP
|
288 PERF_OUTPUT_SYM
| PERF_OUTPUT_SYMOFFSET
|
289 PERF_OUTPUT_DSO
| PERF_OUTPUT_SYNTH
,
291 .invalid_fields
= PERF_OUTPUT_TRACE
| PERF_OUTPUT_BPF_OUTPUT
,
294 [OUTPUT_TYPE_OTHER
] = {
297 .fields
= PERF_OUTPUT_COMM
| PERF_OUTPUT_TID
|
298 PERF_OUTPUT_CPU
| PERF_OUTPUT_TIME
|
299 PERF_OUTPUT_EVNAME
| PERF_OUTPUT_IP
|
300 PERF_OUTPUT_SYM
| PERF_OUTPUT_SYMOFFSET
|
301 PERF_OUTPUT_DSO
| PERF_OUTPUT_PERIOD
,
303 .invalid_fields
= PERF_OUTPUT_TRACE
| PERF_OUTPUT_BPF_OUTPUT
,
307 struct evsel_script
{
311 /* For metric output */
316 static inline struct evsel_script
*evsel_script(struct evsel
*evsel
)
318 return (struct evsel_script
*)evsel
->priv
;
321 static struct evsel_script
*evsel_script__new(struct evsel
*evsel
, struct perf_data
*data
)
323 struct evsel_script
*es
= zalloc(sizeof(*es
));
326 if (asprintf(&es
->filename
, "%s.%s.dump", data
->file
.path
, evsel__name(evsel
)) < 0)
328 es
->fp
= fopen(es
->filename
, "w");
330 goto out_free_filename
;
335 zfree(&es
->filename
);
341 static void evsel_script__delete(struct evsel_script
*es
)
343 zfree(&es
->filename
);
349 static int evsel_script__fprintf(struct evsel_script
*es
, FILE *fp
)
353 fstat(fileno(es
->fp
), &st
);
354 return fprintf(fp
, "[ perf script: Wrote %.3f MB %s (%" PRIu64
" samples) ]\n",
355 st
.st_size
/ 1024.0 / 1024.0, es
->filename
, es
->samples
);
358 static inline int output_type(unsigned int type
)
361 case PERF_TYPE_SYNTH
:
362 return OUTPUT_TYPE_SYNTH
;
364 if (type
< PERF_TYPE_MAX
)
368 return OUTPUT_TYPE_OTHER
;
371 static bool output_set_by_user(void)
374 for (j
= 0; j
< OUTPUT_TYPE_MAX
; ++j
) {
375 if (output
[j
].user_set
)
381 static const char *output_field2str(enum perf_output_field field
)
383 int i
, imax
= ARRAY_SIZE(all_output_options
);
384 const char *str
= "";
386 for (i
= 0; i
< imax
; ++i
) {
387 if (all_output_options
[i
].field
== field
) {
388 str
= all_output_options
[i
].str
;
395 #define PRINT_FIELD(x) (output[output_type(attr->type)].fields & PERF_OUTPUT_##x)
397 static int evsel__do_check_stype(struct evsel
*evsel
, u64 sample_type
, const char *sample_msg
,
398 enum perf_output_field field
, bool allow_user_set
)
400 struct perf_event_attr
*attr
= &evsel
->core
.attr
;
401 int type
= output_type(attr
->type
);
404 if (attr
->sample_type
& sample_type
)
407 if (output
[type
].user_set_fields
& field
) {
410 evname
= evsel__name(evsel
);
411 pr_err("Samples for '%s' event do not have %s attribute set. "
412 "Cannot print '%s' field.\n",
413 evname
, sample_msg
, output_field2str(field
));
417 /* user did not ask for it explicitly so remove from the default list */
418 output
[type
].fields
&= ~field
;
419 evname
= evsel__name(evsel
);
420 pr_debug("Samples for '%s' event do not have %s attribute set. "
421 "Skipping '%s' field.\n",
422 evname
, sample_msg
, output_field2str(field
));
427 static int evsel__check_stype(struct evsel
*evsel
, u64 sample_type
, const char *sample_msg
,
428 enum perf_output_field field
)
430 return evsel__do_check_stype(evsel
, sample_type
, sample_msg
, field
, false);
433 static int evsel__check_attr(struct evsel
*evsel
, struct perf_session
*session
)
435 struct perf_event_attr
*attr
= &evsel
->core
.attr
;
438 if (perf_header__has_feat(&session
->header
, HEADER_STAT
))
441 allow_user_set
= perf_header__has_feat(&session
->header
,
444 if (PRINT_FIELD(TRACE
) &&
445 !perf_session__has_traces(session
, "record -R"))
448 if (PRINT_FIELD(IP
)) {
449 if (evsel__check_stype(evsel
, PERF_SAMPLE_IP
, "IP", PERF_OUTPUT_IP
))
453 if (PRINT_FIELD(ADDR
) &&
454 evsel__do_check_stype(evsel
, PERF_SAMPLE_ADDR
, "ADDR", PERF_OUTPUT_ADDR
, allow_user_set
))
457 if (PRINT_FIELD(DATA_SRC
) &&
458 evsel__check_stype(evsel
, PERF_SAMPLE_DATA_SRC
, "DATA_SRC", PERF_OUTPUT_DATA_SRC
))
461 if (PRINT_FIELD(WEIGHT
) &&
462 evsel__check_stype(evsel
, PERF_SAMPLE_WEIGHT_TYPE
, "WEIGHT", PERF_OUTPUT_WEIGHT
))
465 if (PRINT_FIELD(SYM
) &&
466 !(evsel
->core
.attr
.sample_type
& (PERF_SAMPLE_IP
|PERF_SAMPLE_ADDR
))) {
467 pr_err("Display of symbols requested but neither sample IP nor "
468 "sample address\navailable. Hence, no addresses to convert "
472 if (PRINT_FIELD(SYMOFFSET
) && !PRINT_FIELD(SYM
)) {
473 pr_err("Display of offsets requested but symbol is not"
477 if (PRINT_FIELD(DSO
) &&
478 !(evsel
->core
.attr
.sample_type
& (PERF_SAMPLE_IP
|PERF_SAMPLE_ADDR
))) {
479 pr_err("Display of DSO requested but no address to convert.\n");
482 if ((PRINT_FIELD(SRCLINE
) || PRINT_FIELD(SRCCODE
)) && !PRINT_FIELD(IP
)) {
483 pr_err("Display of source line number requested but sample IP is not\n"
484 "selected. Hence, no address to lookup the source line number.\n");
487 if (PRINT_FIELD(BRSTACKINSN
) && !allow_user_set
&&
488 !(evlist__combined_branch_type(session
->evlist
) & PERF_SAMPLE_BRANCH_ANY
)) {
489 pr_err("Display of branch stack assembler requested, but non all-branch filter set\n"
490 "Hint: run 'perf record -b ...'\n");
493 if ((PRINT_FIELD(PID
) || PRINT_FIELD(TID
)) &&
494 evsel__check_stype(evsel
, PERF_SAMPLE_TID
, "TID", PERF_OUTPUT_TID
|PERF_OUTPUT_PID
))
497 if (PRINT_FIELD(TIME
) &&
498 evsel__check_stype(evsel
, PERF_SAMPLE_TIME
, "TIME", PERF_OUTPUT_TIME
))
501 if (PRINT_FIELD(CPU
) &&
502 evsel__do_check_stype(evsel
, PERF_SAMPLE_CPU
, "CPU", PERF_OUTPUT_CPU
, allow_user_set
))
505 if (PRINT_FIELD(IREGS
) &&
506 evsel__do_check_stype(evsel
, PERF_SAMPLE_REGS_INTR
, "IREGS", PERF_OUTPUT_IREGS
, allow_user_set
))
509 if (PRINT_FIELD(UREGS
) &&
510 evsel__check_stype(evsel
, PERF_SAMPLE_REGS_USER
, "UREGS", PERF_OUTPUT_UREGS
))
513 if (PRINT_FIELD(PHYS_ADDR
) &&
514 evsel__check_stype(evsel
, PERF_SAMPLE_PHYS_ADDR
, "PHYS_ADDR", PERF_OUTPUT_PHYS_ADDR
))
517 if (PRINT_FIELD(DATA_PAGE_SIZE
) &&
518 evsel__check_stype(evsel
, PERF_SAMPLE_DATA_PAGE_SIZE
, "DATA_PAGE_SIZE", PERF_OUTPUT_DATA_PAGE_SIZE
))
521 if (PRINT_FIELD(CODE_PAGE_SIZE
) &&
522 evsel__check_stype(evsel
, PERF_SAMPLE_CODE_PAGE_SIZE
, "CODE_PAGE_SIZE", PERF_OUTPUT_CODE_PAGE_SIZE
))
528 static void set_print_ip_opts(struct perf_event_attr
*attr
)
530 unsigned int type
= output_type(attr
->type
);
532 output
[type
].print_ip_opts
= 0;
534 output
[type
].print_ip_opts
|= EVSEL__PRINT_IP
;
536 if (PRINT_FIELD(SYM
))
537 output
[type
].print_ip_opts
|= EVSEL__PRINT_SYM
;
539 if (PRINT_FIELD(DSO
))
540 output
[type
].print_ip_opts
|= EVSEL__PRINT_DSO
;
542 if (PRINT_FIELD(SYMOFFSET
))
543 output
[type
].print_ip_opts
|= EVSEL__PRINT_SYMOFFSET
;
545 if (PRINT_FIELD(SRCLINE
))
546 output
[type
].print_ip_opts
|= EVSEL__PRINT_SRCLINE
;
549 static struct evsel
*find_first_output_type(struct evlist
*evlist
,
554 evlist__for_each_entry(evlist
, evsel
) {
555 if (output_type(evsel
->core
.attr
.type
) == (int)type
)
562 * verify all user requested events exist and the samples
563 * have the expected data
565 static int perf_session__check_output_opt(struct perf_session
*session
)
571 for (j
= 0; j
< OUTPUT_TYPE_MAX
; ++j
) {
572 evsel
= find_first_output_type(session
->evlist
, j
);
575 * even if fields is set to 0 (ie., show nothing) event must
576 * exist if user explicitly includes it on the command line
578 if (!evsel
&& output
[j
].user_set
&& !output
[j
].wildcard_set
&&
579 j
!= OUTPUT_TYPE_SYNTH
) {
580 pr_err("%s events do not exist. "
581 "Remove corresponding -F option to proceed.\n",
586 if (evsel
&& output
[j
].fields
&&
587 evsel__check_attr(evsel
, session
))
593 set_print_ip_opts(&evsel
->core
.attr
);
594 tod
|= output
[j
].fields
& PERF_OUTPUT_TOD
;
598 bool use_callchain
= false;
599 bool not_pipe
= false;
601 evlist__for_each_entry(session
->evlist
, evsel
) {
603 if (evsel__has_callchain(evsel
)) {
604 use_callchain
= true;
608 if (not_pipe
&& !use_callchain
)
609 symbol_conf
.use_callchain
= false;
613 * set default for tracepoints to print symbols only
614 * if callchains are present
616 if (symbol_conf
.use_callchain
&&
617 !output
[PERF_TYPE_TRACEPOINT
].user_set
) {
618 j
= PERF_TYPE_TRACEPOINT
;
620 evlist__for_each_entry(session
->evlist
, evsel
) {
621 if (evsel
->core
.attr
.type
!= j
)
624 if (evsel__has_callchain(evsel
)) {
625 output
[j
].fields
|= PERF_OUTPUT_IP
;
626 output
[j
].fields
|= PERF_OUTPUT_SYM
;
627 output
[j
].fields
|= PERF_OUTPUT_SYMOFFSET
;
628 output
[j
].fields
|= PERF_OUTPUT_DSO
;
629 set_print_ip_opts(&evsel
->core
.attr
);
635 if (tod
&& !session
->header
.env
.clock
.enabled
) {
636 pr_err("Can't provide 'tod' time, missing clock data. "
637 "Please record with -k/--clockid option.\n");
644 static int perf_sample__fprintf_regs(struct regs_dump
*regs
, uint64_t mask
,
650 if (!regs
|| !regs
->regs
)
653 printed
+= fprintf(fp
, " ABI:%" PRIu64
" ", regs
->abi
);
655 for_each_set_bit(r
, (unsigned long *) &mask
, sizeof(mask
) * 8) {
656 u64 val
= regs
->regs
[i
++];
657 printed
+= fprintf(fp
, "%5s:0x%"PRIx64
" ", perf_reg_name(r
), val
);
663 #define DEFAULT_TOD_FMT "%F %H:%M:%S"
666 tod_scnprintf(struct perf_script
*script
, char *buf
, int buflen
,
669 u64 tod_ns
, clockid_ns
;
670 struct perf_env
*env
;
677 if (buflen
< 64 || !script
)
680 env
= &script
->session
->header
.env
;
681 if (!env
->clock
.enabled
) {
682 scnprintf(buf
, buflen
, "disabled");
686 clockid_ns
= env
->clock
.clockid_ns
;
687 tod_ns
= env
->clock
.tod_ns
;
689 if (timestamp
> clockid_ns
)
690 tod_ns
+= timestamp
- clockid_ns
;
692 tod_ns
-= clockid_ns
- timestamp
;
694 sec
= (time_t) (tod_ns
/ NSEC_PER_SEC
);
695 nsec
= tod_ns
- sec
* NSEC_PER_SEC
;
697 if (localtime_r(&sec
, <ime
) == NULL
) {
698 scnprintf(buf
, buflen
, "failed");
700 strftime(date
, sizeof(date
), DEFAULT_TOD_FMT
, <ime
);
702 if (symbol_conf
.nanosecs
) {
703 snprintf(buf
, buflen
, "%s.%09lu", date
, nsec
);
705 snprintf(buf
, buflen
, "%s.%06lu",
706 date
, nsec
/ NSEC_PER_USEC
);
713 static int perf_sample__fprintf_iregs(struct perf_sample
*sample
,
714 struct perf_event_attr
*attr
, FILE *fp
)
716 return perf_sample__fprintf_regs(&sample
->intr_regs
,
717 attr
->sample_regs_intr
, fp
);
720 static int perf_sample__fprintf_uregs(struct perf_sample
*sample
,
721 struct perf_event_attr
*attr
, FILE *fp
)
723 return perf_sample__fprintf_regs(&sample
->user_regs
,
724 attr
->sample_regs_user
, fp
);
727 static int perf_sample__fprintf_start(struct perf_script
*script
,
728 struct perf_sample
*sample
,
729 struct thread
*thread
,
733 struct perf_event_attr
*attr
= &evsel
->core
.attr
;
735 unsigned long long nsecs
;
739 if (PRINT_FIELD(COMM
)) {
740 const char *comm
= thread
? thread__comm_str(thread
) : ":-1";
743 printed
+= fprintf(fp
, "%8.8s ", comm
);
744 else if (PRINT_FIELD(IP
) && evsel__has_callchain(evsel
) && symbol_conf
.use_callchain
)
745 printed
+= fprintf(fp
, "%s ", comm
);
747 printed
+= fprintf(fp
, "%16s ", comm
);
750 if (PRINT_FIELD(PID
) && PRINT_FIELD(TID
))
751 printed
+= fprintf(fp
, "%5d/%-5d ", sample
->pid
, sample
->tid
);
752 else if (PRINT_FIELD(PID
))
753 printed
+= fprintf(fp
, "%5d ", sample
->pid
);
754 else if (PRINT_FIELD(TID
))
755 printed
+= fprintf(fp
, "%5d ", sample
->tid
);
757 if (PRINT_FIELD(CPU
)) {
759 printed
+= fprintf(fp
, "%3d ", sample
->cpu
);
761 printed
+= fprintf(fp
, "[%03d] ", sample
->cpu
);
764 if (PRINT_FIELD(MISC
)) {
768 (sample->misc & PERF_RECORD_MISC_##m) == PERF_RECORD_MISC_##m
771 ret
+= fprintf(fp
, "K");
773 ret
+= fprintf(fp
, "U");
775 ret
+= fprintf(fp
, "H");
776 if (has(GUEST_KERNEL
))
777 ret
+= fprintf(fp
, "G");
779 ret
+= fprintf(fp
, "g");
782 case PERF_RECORD_MMAP
:
783 case PERF_RECORD_MMAP2
:
785 ret
+= fprintf(fp
, "M");
787 case PERF_RECORD_COMM
:
789 ret
+= fprintf(fp
, "E");
791 case PERF_RECORD_SWITCH
:
792 case PERF_RECORD_SWITCH_CPU_WIDE
:
793 if (has(SWITCH_OUT
)) {
794 ret
+= fprintf(fp
, "S");
795 if (sample
->misc
& PERF_RECORD_MISC_SWITCH_OUT_PREEMPT
)
796 ret
+= fprintf(fp
, "p");
804 ret
+= fprintf(fp
, "%*s", 6 - ret
, " ");
808 if (PRINT_FIELD(TOD
)) {
809 tod_scnprintf(script
, tstr
, sizeof(tstr
), sample
->time
);
810 printed
+= fprintf(fp
, "%s ", tstr
);
813 if (PRINT_FIELD(TIME
)) {
814 u64 t
= sample
->time
;
817 initial_time
= sample
->time
;
818 t
= sample
->time
- initial_time
;
819 } else if (deltatime
) {
821 t
= sample
->time
- previous_time
;
825 previous_time
= sample
->time
;
828 secs
= nsecs
/ NSEC_PER_SEC
;
829 nsecs
-= secs
* NSEC_PER_SEC
;
831 if (symbol_conf
.nanosecs
)
832 printed
+= fprintf(fp
, "%5lu.%09llu: ", secs
, nsecs
);
834 char sample_time
[32];
835 timestamp__scnprintf_usec(t
, sample_time
, sizeof(sample_time
));
836 printed
+= fprintf(fp
, "%12s: ", sample_time
);
844 mispred_str(struct branch_entry
*br
)
846 if (!(br
->flags
.mispred
|| br
->flags
.predicted
))
849 return br
->flags
.predicted
? 'P' : 'M';
852 static int perf_sample__fprintf_brstack(struct perf_sample
*sample
,
853 struct thread
*thread
,
854 struct perf_event_attr
*attr
, FILE *fp
)
856 struct branch_stack
*br
= sample
->branch_stack
;
857 struct branch_entry
*entries
= perf_sample__branch_entries(sample
);
858 struct addr_location alf
, alt
;
865 for (i
= 0; i
< br
->nr
; i
++) {
866 from
= entries
[i
].from
;
869 if (PRINT_FIELD(DSO
)) {
870 memset(&alf
, 0, sizeof(alf
));
871 memset(&alt
, 0, sizeof(alt
));
872 thread__find_map_fb(thread
, sample
->cpumode
, from
, &alf
);
873 thread__find_map_fb(thread
, sample
->cpumode
, to
, &alt
);
876 printed
+= fprintf(fp
, " 0x%"PRIx64
, from
);
877 if (PRINT_FIELD(DSO
)) {
878 printed
+= fprintf(fp
, "(");
879 printed
+= map__fprintf_dsoname(alf
.map
, fp
);
880 printed
+= fprintf(fp
, ")");
883 printed
+= fprintf(fp
, "/0x%"PRIx64
, to
);
884 if (PRINT_FIELD(DSO
)) {
885 printed
+= fprintf(fp
, "(");
886 printed
+= map__fprintf_dsoname(alt
.map
, fp
);
887 printed
+= fprintf(fp
, ")");
890 printed
+= fprintf(fp
, "/%c/%c/%c/%d ",
891 mispred_str(entries
+ i
),
892 entries
[i
].flags
.in_tx
? 'X' : '-',
893 entries
[i
].flags
.abort
? 'A' : '-',
894 entries
[i
].flags
.cycles
);
900 static int perf_sample__fprintf_brstacksym(struct perf_sample
*sample
,
901 struct thread
*thread
,
902 struct perf_event_attr
*attr
, FILE *fp
)
904 struct branch_stack
*br
= sample
->branch_stack
;
905 struct branch_entry
*entries
= perf_sample__branch_entries(sample
);
906 struct addr_location alf
, alt
;
913 for (i
= 0; i
< br
->nr
; i
++) {
915 memset(&alf
, 0, sizeof(alf
));
916 memset(&alt
, 0, sizeof(alt
));
917 from
= entries
[i
].from
;
920 thread__find_symbol_fb(thread
, sample
->cpumode
, from
, &alf
);
921 thread__find_symbol_fb(thread
, sample
->cpumode
, to
, &alt
);
923 printed
+= symbol__fprintf_symname_offs(alf
.sym
, &alf
, fp
);
924 if (PRINT_FIELD(DSO
)) {
925 printed
+= fprintf(fp
, "(");
926 printed
+= map__fprintf_dsoname(alf
.map
, fp
);
927 printed
+= fprintf(fp
, ")");
929 printed
+= fprintf(fp
, "%c", '/');
930 printed
+= symbol__fprintf_symname_offs(alt
.sym
, &alt
, fp
);
931 if (PRINT_FIELD(DSO
)) {
932 printed
+= fprintf(fp
, "(");
933 printed
+= map__fprintf_dsoname(alt
.map
, fp
);
934 printed
+= fprintf(fp
, ")");
936 printed
+= fprintf(fp
, "/%c/%c/%c/%d ",
937 mispred_str(entries
+ i
),
938 entries
[i
].flags
.in_tx
? 'X' : '-',
939 entries
[i
].flags
.abort
? 'A' : '-',
940 entries
[i
].flags
.cycles
);
946 static int perf_sample__fprintf_brstackoff(struct perf_sample
*sample
,
947 struct thread
*thread
,
948 struct perf_event_attr
*attr
, FILE *fp
)
950 struct branch_stack
*br
= sample
->branch_stack
;
951 struct branch_entry
*entries
= perf_sample__branch_entries(sample
);
952 struct addr_location alf
, alt
;
959 for (i
= 0; i
< br
->nr
; i
++) {
961 memset(&alf
, 0, sizeof(alf
));
962 memset(&alt
, 0, sizeof(alt
));
963 from
= entries
[i
].from
;
966 if (thread__find_map_fb(thread
, sample
->cpumode
, from
, &alf
) &&
967 !alf
.map
->dso
->adjust_symbols
)
968 from
= map__map_ip(alf
.map
, from
);
970 if (thread__find_map_fb(thread
, sample
->cpumode
, to
, &alt
) &&
971 !alt
.map
->dso
->adjust_symbols
)
972 to
= map__map_ip(alt
.map
, to
);
974 printed
+= fprintf(fp
, " 0x%"PRIx64
, from
);
975 if (PRINT_FIELD(DSO
)) {
976 printed
+= fprintf(fp
, "(");
977 printed
+= map__fprintf_dsoname(alf
.map
, fp
);
978 printed
+= fprintf(fp
, ")");
980 printed
+= fprintf(fp
, "/0x%"PRIx64
, to
);
981 if (PRINT_FIELD(DSO
)) {
982 printed
+= fprintf(fp
, "(");
983 printed
+= map__fprintf_dsoname(alt
.map
, fp
);
984 printed
+= fprintf(fp
, ")");
986 printed
+= fprintf(fp
, "/%c/%c/%c/%d ",
987 mispred_str(entries
+ i
),
988 entries
[i
].flags
.in_tx
? 'X' : '-',
989 entries
[i
].flags
.abort
? 'A' : '-',
990 entries
[i
].flags
.cycles
);
995 #define MAXBB 16384UL
997 static int grab_bb(u8
*buffer
, u64 start
, u64 end
,
998 struct machine
*machine
, struct thread
*thread
,
999 bool *is64bit
, u8
*cpumode
, bool last
)
1002 struct addr_location al
;
1008 kernel
= machine__kernel_ip(machine
, start
);
1010 *cpumode
= PERF_RECORD_MISC_KERNEL
;
1012 *cpumode
= PERF_RECORD_MISC_USER
;
1015 * Block overlaps between kernel and user.
1016 * This can happen due to ring filtering
1017 * On Intel CPUs the entry into the kernel is filtered,
1018 * but the exit is not. Let the caller patch it up.
1020 if (kernel
!= machine__kernel_ip(machine
, end
)) {
1021 pr_debug("\tblock %" PRIx64
"-%" PRIx64
" transfers between kernel and user\n", start
, end
);
1025 memset(&al
, 0, sizeof(al
));
1026 if (end
- start
> MAXBB
- MAXINSN
) {
1028 pr_debug("\tbrstack does not reach to final jump (%" PRIx64
"-%" PRIx64
")\n", start
, end
);
1030 pr_debug("\tblock %" PRIx64
"-%" PRIx64
" (%" PRIu64
") too long to dump\n", start
, end
, end
- start
);
1034 if (!thread__find_map(thread
, *cpumode
, start
, &al
) || !al
.map
->dso
) {
1035 pr_debug("\tcannot resolve %" PRIx64
"-%" PRIx64
"\n", start
, end
);
1038 if (al
.map
->dso
->data
.status
== DSO_DATA_STATUS_ERROR
) {
1039 pr_debug("\tcannot resolve %" PRIx64
"-%" PRIx64
"\n", start
, end
);
1043 /* Load maps to ensure dso->is_64_bit has been updated */
1046 offset
= al
.map
->map_ip(al
.map
, start
);
1047 len
= dso__data_read_offset(al
.map
->dso
, machine
, offset
, (u8
*)buffer
,
1048 end
- start
+ MAXINSN
);
1050 *is64bit
= al
.map
->dso
->is_64_bit
;
1052 pr_debug("\tcannot fetch code for block at %" PRIx64
"-%" PRIx64
"\n",
1057 static int map__fprintf_srccode(struct map
*map
, u64 addr
, FILE *fp
, struct srccode_state
*state
)
1065 if (!map
|| !map
->dso
)
1067 srcfile
= get_srcline_split(map
->dso
,
1068 map__rip_2objdump(map
, addr
),
1073 /* Avoid redundant printing */
1076 !strcmp(state
->srcfile
, srcfile
) &&
1077 state
->line
== line
) {
1082 srccode
= find_sourceline(srcfile
, line
, &len
);
1086 ret
= fprintf(fp
, "|%-8d %.*s", line
, len
, srccode
);
1089 state
->srcfile
= srcfile
;
1099 static int print_srccode(struct thread
*thread
, u8 cpumode
, uint64_t addr
)
1101 struct addr_location al
;
1104 memset(&al
, 0, sizeof(al
));
1105 thread__find_map(thread
, cpumode
, addr
, &al
);
1108 ret
= map__fprintf_srccode(al
.map
, al
.addr
, stdout
,
1109 &thread
->srccode_state
);
1111 ret
+= printf("\n");
1115 static int ip__fprintf_jump(uint64_t ip
, struct branch_entry
*en
,
1116 struct perf_insn
*x
, u8
*inbuf
, int len
,
1117 int insn
, FILE *fp
, int *total_cycles
)
1119 int printed
= fprintf(fp
, "\t%016" PRIx64
"\t%-30s\t#%s%s%s%s", ip
,
1120 dump_insn(x
, ip
, inbuf
, len
, NULL
),
1121 en
->flags
.predicted
? " PRED" : "",
1122 en
->flags
.mispred
? " MISPRED" : "",
1123 en
->flags
.in_tx
? " INTX" : "",
1124 en
->flags
.abort
? " ABORT" : "");
1125 if (en
->flags
.cycles
) {
1126 *total_cycles
+= en
->flags
.cycles
;
1127 printed
+= fprintf(fp
, " %d cycles [%d]", en
->flags
.cycles
, *total_cycles
);
1129 printed
+= fprintf(fp
, " %.2f IPC", (float)insn
/ en
->flags
.cycles
);
1131 return printed
+ fprintf(fp
, "\n");
1134 static int ip__fprintf_sym(uint64_t addr
, struct thread
*thread
,
1135 u8 cpumode
, int cpu
, struct symbol
**lastsym
,
1136 struct perf_event_attr
*attr
, FILE *fp
)
1138 struct addr_location al
;
1139 int off
, printed
= 0;
1141 memset(&al
, 0, sizeof(al
));
1143 thread__find_map(thread
, cpumode
, addr
, &al
);
1145 if ((*lastsym
) && al
.addr
>= (*lastsym
)->start
&& al
.addr
< (*lastsym
)->end
)
1151 al
.sym
= map__find_symbol(al
.map
, al
.addr
);
1156 if (al
.addr
< al
.sym
->end
)
1157 off
= al
.addr
- al
.sym
->start
;
1159 off
= al
.addr
- al
.map
->start
- al
.sym
->start
;
1160 printed
+= fprintf(fp
, "\t%s", al
.sym
->name
);
1162 printed
+= fprintf(fp
, "%+d", off
);
1163 printed
+= fprintf(fp
, ":");
1164 if (PRINT_FIELD(SRCLINE
))
1165 printed
+= map__fprintf_srcline(al
.map
, al
.addr
, "\t", fp
);
1166 printed
+= fprintf(fp
, "\n");
1172 static int perf_sample__fprintf_brstackinsn(struct perf_sample
*sample
,
1173 struct thread
*thread
,
1174 struct perf_event_attr
*attr
,
1175 struct machine
*machine
, FILE *fp
)
1177 struct branch_stack
*br
= sample
->branch_stack
;
1178 struct branch_entry
*entries
= perf_sample__branch_entries(sample
);
1180 int i
, insn
, len
, nr
, ilen
, printed
= 0;
1184 struct symbol
*lastsym
= NULL
;
1185 int total_cycles
= 0;
1187 if (!(br
&& br
->nr
))
1190 if (max_blocks
&& nr
> max_blocks
+ 1)
1191 nr
= max_blocks
+ 1;
1194 x
.cpu
= sample
->cpu
;
1196 printed
+= fprintf(fp
, "%c", '\n');
1198 /* Handle first from jump, of which we don't know the entry. */
1199 len
= grab_bb(buffer
, entries
[nr
-1].from
,
1201 machine
, thread
, &x
.is64bit
, &x
.cpumode
, false);
1203 printed
+= ip__fprintf_sym(entries
[nr
- 1].from
, thread
,
1204 x
.cpumode
, x
.cpu
, &lastsym
, attr
, fp
);
1205 printed
+= ip__fprintf_jump(entries
[nr
- 1].from
, &entries
[nr
- 1],
1206 &x
, buffer
, len
, 0, fp
, &total_cycles
);
1207 if (PRINT_FIELD(SRCCODE
))
1208 printed
+= print_srccode(thread
, x
.cpumode
, entries
[nr
- 1].from
);
1211 /* Print all blocks */
1212 for (i
= nr
- 2; i
>= 0; i
--) {
1213 if (entries
[i
].from
|| entries
[i
].to
)
1214 pr_debug("%d: %" PRIx64
"-%" PRIx64
"\n", i
,
1217 start
= entries
[i
+ 1].to
;
1218 end
= entries
[i
].from
;
1220 len
= grab_bb(buffer
, start
, end
, machine
, thread
, &x
.is64bit
, &x
.cpumode
, false);
1221 /* Patch up missing kernel transfers due to ring filters */
1222 if (len
== -ENXIO
&& i
> 0) {
1223 end
= entries
[--i
].from
;
1224 pr_debug("\tpatching up to %" PRIx64
"-%" PRIx64
"\n", start
, end
);
1225 len
= grab_bb(buffer
, start
, end
, machine
, thread
, &x
.is64bit
, &x
.cpumode
, false);
1231 for (off
= 0; off
< (unsigned)len
; off
+= ilen
) {
1232 uint64_t ip
= start
+ off
;
1234 printed
+= ip__fprintf_sym(ip
, thread
, x
.cpumode
, x
.cpu
, &lastsym
, attr
, fp
);
1236 printed
+= ip__fprintf_jump(ip
, &entries
[i
], &x
, buffer
+ off
, len
- off
, ++insn
, fp
,
1238 if (PRINT_FIELD(SRCCODE
))
1239 printed
+= print_srccode(thread
, x
.cpumode
, ip
);
1243 printed
+= fprintf(fp
, "\t%016" PRIx64
"\t%s\n", ip
,
1244 dump_insn(&x
, ip
, buffer
+ off
, len
- off
, &ilen
));
1247 if (PRINT_FIELD(SRCCODE
))
1248 print_srccode(thread
, x
.cpumode
, ip
);
1252 if (off
!= end
- start
)
1253 printed
+= fprintf(fp
, "\tmismatch of LBR data and executable\n");
1257 * Hit the branch? In this case we are already done, and the target
1258 * has not been executed yet.
1260 if (entries
[0].from
== sample
->ip
)
1262 if (entries
[0].flags
.abort
)
1266 * Print final block upto sample
1268 * Due to pipeline delays the LBRs might be missing a branch
1269 * or two, which can result in very large or negative blocks
1270 * between final branch and sample. When this happens just
1271 * continue walking after the last TO until we hit a branch.
1273 start
= entries
[0].to
;
1276 /* Missing jump. Scan 128 bytes for the next branch */
1279 len
= grab_bb(buffer
, start
, end
, machine
, thread
, &x
.is64bit
, &x
.cpumode
, true);
1280 printed
+= ip__fprintf_sym(start
, thread
, x
.cpumode
, x
.cpu
, &lastsym
, attr
, fp
);
1282 /* Print at least last IP if basic block did not work */
1283 len
= grab_bb(buffer
, sample
->ip
, sample
->ip
,
1284 machine
, thread
, &x
.is64bit
, &x
.cpumode
, false);
1287 printed
+= fprintf(fp
, "\t%016" PRIx64
"\t%s\n", sample
->ip
,
1288 dump_insn(&x
, sample
->ip
, buffer
, len
, NULL
));
1289 if (PRINT_FIELD(SRCCODE
))
1290 print_srccode(thread
, x
.cpumode
, sample
->ip
);
1293 for (off
= 0; off
<= end
- start
; off
+= ilen
) {
1295 printed
+= fprintf(fp
, "\t%016" PRIx64
"\t%s\n", start
+ off
,
1296 dump_insn(&x
, start
+ off
, buffer
+ off
, len
- off
, &ilen
));
1299 if (arch_is_branch(buffer
+ off
, len
- off
, x
.is64bit
) && start
+ off
!= sample
->ip
) {
1301 * Hit a missing branch. Just stop.
1303 printed
+= fprintf(fp
, "\t... not reaching sample ...\n");
1306 if (PRINT_FIELD(SRCCODE
))
1307 print_srccode(thread
, x
.cpumode
, start
+ off
);
1313 static int perf_sample__fprintf_addr(struct perf_sample
*sample
,
1314 struct thread
*thread
,
1315 struct perf_event_attr
*attr
, FILE *fp
)
1317 struct addr_location al
;
1318 int printed
= fprintf(fp
, "%16" PRIx64
, sample
->addr
);
1320 if (!sample_addr_correlates_sym(attr
))
1323 thread__resolve(thread
, &al
, sample
);
1325 if (PRINT_FIELD(SYM
)) {
1326 printed
+= fprintf(fp
, " ");
1327 if (PRINT_FIELD(SYMOFFSET
))
1328 printed
+= symbol__fprintf_symname_offs(al
.sym
, &al
, fp
);
1330 printed
+= symbol__fprintf_symname(al
.sym
, fp
);
1333 if (PRINT_FIELD(DSO
)) {
1334 printed
+= fprintf(fp
, " (");
1335 printed
+= map__fprintf_dsoname(al
.map
, fp
);
1336 printed
+= fprintf(fp
, ")");
1342 static const char *resolve_branch_sym(struct perf_sample
*sample
,
1343 struct evsel
*evsel
,
1344 struct thread
*thread
,
1345 struct addr_location
*al
,
1346 struct addr_location
*addr_al
,
1349 struct perf_event_attr
*attr
= &evsel
->core
.attr
;
1350 const char *name
= NULL
;
1352 if (sample
->flags
& (PERF_IP_FLAG_CALL
| PERF_IP_FLAG_TRACE_BEGIN
)) {
1353 if (sample_addr_correlates_sym(attr
)) {
1354 if (!addr_al
->thread
)
1355 thread__resolve(thread
, addr_al
, sample
);
1357 name
= addr_al
->sym
->name
;
1363 } else if (sample
->flags
& (PERF_IP_FLAG_RETURN
| PERF_IP_FLAG_TRACE_END
)) {
1365 name
= al
->sym
->name
;
1372 static int perf_sample__fprintf_callindent(struct perf_sample
*sample
,
1373 struct evsel
*evsel
,
1374 struct thread
*thread
,
1375 struct addr_location
*al
,
1376 struct addr_location
*addr_al
,
1379 struct perf_event_attr
*attr
= &evsel
->core
.attr
;
1380 size_t depth
= thread_stack__depth(thread
, sample
->cpu
);
1381 const char *name
= NULL
;
1388 * The 'return' has already been popped off the stack so the depth has
1389 * to be adjusted to match the 'call'.
1391 if (thread
->ts
&& sample
->flags
& PERF_IP_FLAG_RETURN
)
1394 name
= resolve_branch_sym(sample
, evsel
, thread
, al
, addr_al
, &ip
);
1396 if (PRINT_FIELD(DSO
) && !(PRINT_FIELD(IP
) || PRINT_FIELD(ADDR
))) {
1397 dlen
+= fprintf(fp
, "(");
1398 dlen
+= map__fprintf_dsoname(al
->map
, fp
);
1399 dlen
+= fprintf(fp
, ")\t");
1403 len
= fprintf(fp
, "%*s%s", (int)depth
* 4, "", name
);
1405 len
= fprintf(fp
, "%*s%16" PRIx64
, (int)depth
* 4, "", ip
);
1411 * Try to keep the output length from changing frequently so that the
1412 * output lines up more nicely.
1414 if (len
> spacing
|| (len
&& len
< spacing
- 52))
1415 spacing
= round_up(len
+ 4, 32);
1418 len
+= fprintf(fp
, "%*s", spacing
- len
, "");
1423 __weak
void arch_fetch_insn(struct perf_sample
*sample __maybe_unused
,
1424 struct thread
*thread __maybe_unused
,
1425 struct machine
*machine __maybe_unused
)
1429 void script_fetch_insn(struct perf_sample
*sample
, struct thread
*thread
,
1430 struct machine
*machine
)
1432 if (sample
->insn_len
== 0 && native_arch
)
1433 arch_fetch_insn(sample
, thread
, machine
);
1436 static int perf_sample__fprintf_insn(struct perf_sample
*sample
,
1437 struct perf_event_attr
*attr
,
1438 struct thread
*thread
,
1439 struct machine
*machine
, FILE *fp
)
1443 script_fetch_insn(sample
, thread
, machine
);
1445 if (PRINT_FIELD(INSNLEN
))
1446 printed
+= fprintf(fp
, " ilen: %d", sample
->insn_len
);
1447 if (PRINT_FIELD(INSN
) && sample
->insn_len
) {
1450 printed
+= fprintf(fp
, " insn:");
1451 for (i
= 0; i
< sample
->insn_len
; i
++)
1452 printed
+= fprintf(fp
, " %02x", (unsigned char)sample
->insn
[i
]);
1454 if (PRINT_FIELD(BRSTACKINSN
))
1455 printed
+= perf_sample__fprintf_brstackinsn(sample
, thread
, attr
, machine
, fp
);
1460 static int perf_sample__fprintf_ipc(struct perf_sample
*sample
,
1461 struct perf_event_attr
*attr
, FILE *fp
)
1465 if (!PRINT_FIELD(IPC
) || !sample
->cyc_cnt
|| !sample
->insn_cnt
)
1468 ipc
= (sample
->insn_cnt
* 100) / sample
->cyc_cnt
;
1470 return fprintf(fp
, " \t IPC: %u.%02u (%" PRIu64
"/%" PRIu64
") ",
1471 ipc
/ 100, ipc
% 100, sample
->insn_cnt
, sample
->cyc_cnt
);
1474 static int perf_sample__fprintf_bts(struct perf_sample
*sample
,
1475 struct evsel
*evsel
,
1476 struct thread
*thread
,
1477 struct addr_location
*al
,
1478 struct addr_location
*addr_al
,
1479 struct machine
*machine
, FILE *fp
)
1481 struct perf_event_attr
*attr
= &evsel
->core
.attr
;
1482 unsigned int type
= output_type(attr
->type
);
1483 bool print_srcline_last
= false;
1486 if (PRINT_FIELD(CALLINDENT
))
1487 printed
+= perf_sample__fprintf_callindent(sample
, evsel
, thread
, al
, addr_al
, fp
);
1489 /* print branch_from information */
1490 if (PRINT_FIELD(IP
)) {
1491 unsigned int print_opts
= output
[type
].print_ip_opts
;
1492 struct callchain_cursor
*cursor
= NULL
;
1494 if (symbol_conf
.use_callchain
&& sample
->callchain
&&
1495 thread__resolve_callchain(al
->thread
, &callchain_cursor
, evsel
,
1496 sample
, NULL
, NULL
, scripting_max_stack
) == 0)
1497 cursor
= &callchain_cursor
;
1499 if (cursor
== NULL
) {
1500 printed
+= fprintf(fp
, " ");
1501 if (print_opts
& EVSEL__PRINT_SRCLINE
) {
1502 print_srcline_last
= true;
1503 print_opts
&= ~EVSEL__PRINT_SRCLINE
;
1506 printed
+= fprintf(fp
, "\n");
1508 printed
+= sample__fprintf_sym(sample
, al
, 0, print_opts
, cursor
,
1509 symbol_conf
.bt_stop_list
, fp
);
1512 /* print branch_to information */
1513 if (PRINT_FIELD(ADDR
) ||
1514 ((evsel
->core
.attr
.sample_type
& PERF_SAMPLE_ADDR
) &&
1515 !output
[type
].user_set
)) {
1516 printed
+= fprintf(fp
, " => ");
1517 printed
+= perf_sample__fprintf_addr(sample
, thread
, attr
, fp
);
1520 printed
+= perf_sample__fprintf_ipc(sample
, attr
, fp
);
1522 if (print_srcline_last
)
1523 printed
+= map__fprintf_srcline(al
->map
, al
->addr
, "\n ", fp
);
1525 printed
+= perf_sample__fprintf_insn(sample
, attr
, thread
, machine
, fp
);
1526 printed
+= fprintf(fp
, "\n");
1527 if (PRINT_FIELD(SRCCODE
)) {
1528 int ret
= map__fprintf_srccode(al
->map
, al
->addr
, stdout
,
1529 &thread
->srccode_state
);
1532 printed
+= printf("\n");
1541 } sample_flags
[] = {
1542 {PERF_IP_FLAG_BRANCH
| PERF_IP_FLAG_CALL
, "call"},
1543 {PERF_IP_FLAG_BRANCH
| PERF_IP_FLAG_RETURN
, "return"},
1544 {PERF_IP_FLAG_BRANCH
| PERF_IP_FLAG_CONDITIONAL
, "jcc"},
1545 {PERF_IP_FLAG_BRANCH
, "jmp"},
1546 {PERF_IP_FLAG_BRANCH
| PERF_IP_FLAG_CALL
| PERF_IP_FLAG_INTERRUPT
, "int"},
1547 {PERF_IP_FLAG_BRANCH
| PERF_IP_FLAG_RETURN
| PERF_IP_FLAG_INTERRUPT
, "iret"},
1548 {PERF_IP_FLAG_BRANCH
| PERF_IP_FLAG_CALL
| PERF_IP_FLAG_SYSCALLRET
, "syscall"},
1549 {PERF_IP_FLAG_BRANCH
| PERF_IP_FLAG_RETURN
| PERF_IP_FLAG_SYSCALLRET
, "sysret"},
1550 {PERF_IP_FLAG_BRANCH
| PERF_IP_FLAG_ASYNC
, "async"},
1551 {PERF_IP_FLAG_BRANCH
| PERF_IP_FLAG_CALL
| PERF_IP_FLAG_ASYNC
| PERF_IP_FLAG_INTERRUPT
, "hw int"},
1552 {PERF_IP_FLAG_BRANCH
| PERF_IP_FLAG_TX_ABORT
, "tx abrt"},
1553 {PERF_IP_FLAG_BRANCH
| PERF_IP_FLAG_TRACE_BEGIN
, "tr strt"},
1554 {PERF_IP_FLAG_BRANCH
| PERF_IP_FLAG_TRACE_END
, "tr end"},
1555 {PERF_IP_FLAG_BRANCH
| PERF_IP_FLAG_CALL
| PERF_IP_FLAG_VMENTRY
, "vmentry"},
1556 {PERF_IP_FLAG_BRANCH
| PERF_IP_FLAG_CALL
| PERF_IP_FLAG_VMEXIT
, "vmexit"},
1560 static const char *sample_flags_to_name(u32 flags
)
1564 for (i
= 0; sample_flags
[i
].name
; i
++) {
1565 if (sample_flags
[i
].flags
== flags
)
1566 return sample_flags
[i
].name
;
1572 int perf_sample__sprintf_flags(u32 flags
, char *str
, size_t sz
)
1574 const char *chars
= PERF_IP_FLAG_CHARS
;
1575 const size_t n
= strlen(PERF_IP_FLAG_CHARS
);
1576 bool in_tx
= flags
& PERF_IP_FLAG_IN_TX
;
1577 const char *name
= NULL
;
1580 name
= sample_flags_to_name(flags
& ~PERF_IP_FLAG_IN_TX
);
1582 return snprintf(str
, sz
, "%-15s%4s", name
, in_tx
? "(x)" : "");
1584 if (flags
& PERF_IP_FLAG_TRACE_BEGIN
) {
1585 name
= sample_flags_to_name(flags
& ~(PERF_IP_FLAG_IN_TX
| PERF_IP_FLAG_TRACE_BEGIN
));
1587 return snprintf(str
, sz
, "tr strt %-7s%4s", name
, in_tx
? "(x)" : "");
1590 if (flags
& PERF_IP_FLAG_TRACE_END
) {
1591 name
= sample_flags_to_name(flags
& ~(PERF_IP_FLAG_IN_TX
| PERF_IP_FLAG_TRACE_END
));
1593 return snprintf(str
, sz
, "tr end %-7s%4s", name
, in_tx
? "(x)" : "");
1596 for (i
= 0; i
< n
; i
++, flags
>>= 1) {
1597 if ((flags
& 1) && pos
< sz
)
1598 str
[pos
++] = chars
[i
];
1600 for (; i
< 32; i
++, flags
>>= 1) {
1601 if ((flags
& 1) && pos
< sz
)
1610 static int perf_sample__fprintf_flags(u32 flags
, FILE *fp
)
1612 char str
[SAMPLE_FLAGS_BUF_SIZE
];
1614 perf_sample__sprintf_flags(flags
, str
, sizeof(str
));
1615 return fprintf(fp
, " %-19s ", str
);
1618 struct printer_data
{
1624 static int sample__fprintf_bpf_output(enum binary_printer_ops op
,
1626 void *extra
, FILE *fp
)
1628 unsigned char ch
= (unsigned char)val
;
1629 struct printer_data
*printer_data
= extra
;
1633 case BINARY_PRINT_DATA_BEGIN
:
1634 printed
+= fprintf(fp
, "\n");
1636 case BINARY_PRINT_LINE_BEGIN
:
1637 printed
+= fprintf(fp
, "%17s", !printer_data
->line_no
? "BPF output:" :
1640 case BINARY_PRINT_ADDR
:
1641 printed
+= fprintf(fp
, " %04x:", val
);
1643 case BINARY_PRINT_NUM_DATA
:
1644 printed
+= fprintf(fp
, " %02x", val
);
1646 case BINARY_PRINT_NUM_PAD
:
1647 printed
+= fprintf(fp
, " ");
1649 case BINARY_PRINT_SEP
:
1650 printed
+= fprintf(fp
, " ");
1652 case BINARY_PRINT_CHAR_DATA
:
1653 if (printer_data
->hit_nul
&& ch
)
1654 printer_data
->is_printable
= false;
1657 printed
+= fprintf(fp
, "%c", '.');
1659 if (!printer_data
->is_printable
)
1663 printer_data
->hit_nul
= true;
1665 printer_data
->is_printable
= false;
1667 printed
+= fprintf(fp
, "%c", ch
);
1670 case BINARY_PRINT_CHAR_PAD
:
1671 printed
+= fprintf(fp
, " ");
1673 case BINARY_PRINT_LINE_END
:
1674 printed
+= fprintf(fp
, "\n");
1675 printer_data
->line_no
++;
1677 case BINARY_PRINT_DATA_END
:
1685 static int perf_sample__fprintf_bpf_output(struct perf_sample
*sample
, FILE *fp
)
1687 unsigned int nr_bytes
= sample
->raw_size
;
1688 struct printer_data printer_data
= {0, false, true};
1689 int printed
= binary__fprintf(sample
->raw_data
, nr_bytes
, 8,
1690 sample__fprintf_bpf_output
, &printer_data
, fp
);
1692 if (printer_data
.is_printable
&& printer_data
.hit_nul
)
1693 printed
+= fprintf(fp
, "%17s \"%s\"\n", "BPF string:", (char *)(sample
->raw_data
));
1698 static int perf_sample__fprintf_spacing(int len
, int spacing
, FILE *fp
)
1700 if (len
> 0 && len
< spacing
)
1701 return fprintf(fp
, "%*s", spacing
- len
, "");
1706 static int perf_sample__fprintf_pt_spacing(int len
, FILE *fp
)
1708 return perf_sample__fprintf_spacing(len
, 34, fp
);
1711 static int perf_sample__fprintf_synth_ptwrite(struct perf_sample
*sample
, FILE *fp
)
1713 struct perf_synth_intel_ptwrite
*data
= perf_sample__synth_ptr(sample
);
1716 if (perf_sample__bad_synth_size(sample
, *data
))
1719 len
= fprintf(fp
, " IP: %u payload: %#" PRIx64
" ",
1720 data
->ip
, le64_to_cpu(data
->payload
));
1721 return len
+ perf_sample__fprintf_pt_spacing(len
, fp
);
1724 static int perf_sample__fprintf_synth_mwait(struct perf_sample
*sample
, FILE *fp
)
1726 struct perf_synth_intel_mwait
*data
= perf_sample__synth_ptr(sample
);
1729 if (perf_sample__bad_synth_size(sample
, *data
))
1732 len
= fprintf(fp
, " hints: %#x extensions: %#x ",
1733 data
->hints
, data
->extensions
);
1734 return len
+ perf_sample__fprintf_pt_spacing(len
, fp
);
1737 static int perf_sample__fprintf_synth_pwre(struct perf_sample
*sample
, FILE *fp
)
1739 struct perf_synth_intel_pwre
*data
= perf_sample__synth_ptr(sample
);
1742 if (perf_sample__bad_synth_size(sample
, *data
))
1745 len
= fprintf(fp
, " hw: %u cstate: %u sub-cstate: %u ",
1746 data
->hw
, data
->cstate
, data
->subcstate
);
1747 return len
+ perf_sample__fprintf_pt_spacing(len
, fp
);
1750 static int perf_sample__fprintf_synth_exstop(struct perf_sample
*sample
, FILE *fp
)
1752 struct perf_synth_intel_exstop
*data
= perf_sample__synth_ptr(sample
);
1755 if (perf_sample__bad_synth_size(sample
, *data
))
1758 len
= fprintf(fp
, " IP: %u ", data
->ip
);
1759 return len
+ perf_sample__fprintf_pt_spacing(len
, fp
);
1762 static int perf_sample__fprintf_synth_pwrx(struct perf_sample
*sample
, FILE *fp
)
1764 struct perf_synth_intel_pwrx
*data
= perf_sample__synth_ptr(sample
);
1767 if (perf_sample__bad_synth_size(sample
, *data
))
1770 len
= fprintf(fp
, " deepest cstate: %u last cstate: %u wake reason: %#x ",
1771 data
->deepest_cstate
, data
->last_cstate
,
1773 return len
+ perf_sample__fprintf_pt_spacing(len
, fp
);
1776 static int perf_sample__fprintf_synth_cbr(struct perf_sample
*sample
, FILE *fp
)
1778 struct perf_synth_intel_cbr
*data
= perf_sample__synth_ptr(sample
);
1779 unsigned int percent
, freq
;
1782 if (perf_sample__bad_synth_size(sample
, *data
))
1785 freq
= (le32_to_cpu(data
->freq
) + 500) / 1000;
1786 len
= fprintf(fp
, " cbr: %2u freq: %4u MHz ", data
->cbr
, freq
);
1787 if (data
->max_nonturbo
) {
1788 percent
= (5 + (1000 * data
->cbr
) / data
->max_nonturbo
) / 10;
1789 len
+= fprintf(fp
, "(%3u%%) ", percent
);
1791 return len
+ perf_sample__fprintf_pt_spacing(len
, fp
);
1794 static int perf_sample__fprintf_synth_psb(struct perf_sample
*sample
, FILE *fp
)
1796 struct perf_synth_intel_psb
*data
= perf_sample__synth_ptr(sample
);
1799 if (perf_sample__bad_synth_size(sample
, *data
))
1802 len
= fprintf(fp
, " psb offs: %#" PRIx64
, data
->offset
);
1803 return len
+ perf_sample__fprintf_pt_spacing(len
, fp
);
1806 static int perf_sample__fprintf_synth(struct perf_sample
*sample
,
1807 struct evsel
*evsel
, FILE *fp
)
1809 switch (evsel
->core
.attr
.config
) {
1810 case PERF_SYNTH_INTEL_PTWRITE
:
1811 return perf_sample__fprintf_synth_ptwrite(sample
, fp
);
1812 case PERF_SYNTH_INTEL_MWAIT
:
1813 return perf_sample__fprintf_synth_mwait(sample
, fp
);
1814 case PERF_SYNTH_INTEL_PWRE
:
1815 return perf_sample__fprintf_synth_pwre(sample
, fp
);
1816 case PERF_SYNTH_INTEL_EXSTOP
:
1817 return perf_sample__fprintf_synth_exstop(sample
, fp
);
1818 case PERF_SYNTH_INTEL_PWRX
:
1819 return perf_sample__fprintf_synth_pwrx(sample
, fp
);
1820 case PERF_SYNTH_INTEL_CBR
:
1821 return perf_sample__fprintf_synth_cbr(sample
, fp
);
1822 case PERF_SYNTH_INTEL_PSB
:
1823 return perf_sample__fprintf_synth_psb(sample
, fp
);
1831 static int evlist__max_name_len(struct evlist
*evlist
)
1833 struct evsel
*evsel
;
1836 evlist__for_each_entry(evlist
, evsel
) {
1837 int len
= strlen(evsel__name(evsel
));
1839 max
= MAX(len
, max
);
1845 static int data_src__fprintf(u64 data_src
, FILE *fp
)
1847 struct mem_info mi
= { .data_src
.val
= data_src
};
1853 perf_script__meminfo_scnprintf(decode
, 100, &mi
);
1855 len
= scnprintf(out
, 100, "%16" PRIx64
" %s", data_src
, decode
);
1859 return fprintf(fp
, "%-*s", maxlen
, out
);
1863 struct perf_sample
*sample
;
1864 struct thread
*thread
;
1865 struct evsel
*evsel
;
1869 static void script_print_metric(struct perf_stat_config
*config __maybe_unused
,
1870 void *ctx
, const char *color
,
1872 const char *unit
, double val
)
1874 struct metric_ctx
*mctx
= ctx
;
1878 perf_sample__fprintf_start(NULL
, mctx
->sample
, mctx
->thread
, mctx
->evsel
,
1879 PERF_RECORD_SAMPLE
, mctx
->fp
);
1880 fputs("\tmetric: ", mctx
->fp
);
1882 color_fprintf(mctx
->fp
, color
, fmt
, val
);
1885 fprintf(mctx
->fp
, " %s\n", unit
);
1888 static void script_new_line(struct perf_stat_config
*config __maybe_unused
,
1891 struct metric_ctx
*mctx
= ctx
;
1893 perf_sample__fprintf_start(NULL
, mctx
->sample
, mctx
->thread
, mctx
->evsel
,
1894 PERF_RECORD_SAMPLE
, mctx
->fp
);
1895 fputs("\tmetric: ", mctx
->fp
);
1898 static void perf_sample__fprint_metric(struct perf_script
*script
,
1899 struct thread
*thread
,
1900 struct evsel
*evsel
,
1901 struct perf_sample
*sample
,
1904 struct evsel
*leader
= evsel__leader(evsel
);
1905 struct perf_stat_output_ctx ctx
= {
1906 .print_metric
= script_print_metric
,
1907 .new_line
= script_new_line
,
1908 .ctx
= &(struct metric_ctx
) {
1914 .force_header
= false,
1920 evlist__alloc_stats(script
->session
->evlist
, false);
1921 if (evsel_script(leader
)->gnum
++ == 0)
1922 perf_stat__reset_shadow_stats();
1923 val
= sample
->period
* evsel
->scale
;
1924 perf_stat__update_shadow_stats(evsel
,
1928 evsel_script(evsel
)->val
= val
;
1929 if (evsel_script(leader
)->gnum
== leader
->core
.nr_members
) {
1930 for_each_group_member (ev2
, leader
) {
1931 perf_stat__print_shadow_stats(&stat_config
, ev2
,
1932 evsel_script(ev2
)->val
,
1938 evsel_script(leader
)->gnum
= 0;
1942 static bool show_event(struct perf_sample
*sample
,
1943 struct evsel
*evsel
,
1944 struct thread
*thread
,
1945 struct addr_location
*al
,
1946 struct addr_location
*addr_al
)
1948 int depth
= thread_stack__depth(thread
, sample
->cpu
);
1950 if (!symbol_conf
.graph_function
)
1953 if (thread
->filter
) {
1954 if (depth
<= thread
->filter_entry_depth
) {
1955 thread
->filter
= false;
1960 const char *s
= symbol_conf
.graph_function
;
1962 const char *name
= resolve_branch_sym(sample
, evsel
, thread
, al
, addr_al
,
1968 nlen
= strlen(name
);
1970 unsigned len
= strcspn(s
, ",");
1971 if (nlen
== len
&& !strncmp(name
, s
, len
)) {
1972 thread
->filter
= true;
1973 thread
->filter_entry_depth
= depth
;
1984 static void process_event(struct perf_script
*script
,
1985 struct perf_sample
*sample
, struct evsel
*evsel
,
1986 struct addr_location
*al
,
1987 struct addr_location
*addr_al
,
1988 struct machine
*machine
)
1990 struct thread
*thread
= al
->thread
;
1991 struct perf_event_attr
*attr
= &evsel
->core
.attr
;
1992 unsigned int type
= output_type(attr
->type
);
1993 struct evsel_script
*es
= evsel
->priv
;
1995 char str
[PAGE_SIZE_NAME_LEN
];
1997 if (output
[type
].fields
== 0)
2002 perf_sample__fprintf_start(script
, sample
, thread
, evsel
,
2003 PERF_RECORD_SAMPLE
, fp
);
2005 if (PRINT_FIELD(PERIOD
))
2006 fprintf(fp
, "%10" PRIu64
" ", sample
->period
);
2008 if (PRINT_FIELD(EVNAME
)) {
2009 const char *evname
= evsel__name(evsel
);
2011 if (!script
->name_width
)
2012 script
->name_width
= evlist__max_name_len(script
->session
->evlist
);
2014 fprintf(fp
, "%*s: ", script
->name_width
, evname
?: "[unknown]");
2018 perf_sample__fprintf_flags(sample
->flags
, fp
);
2020 if (is_bts_event(attr
)) {
2021 perf_sample__fprintf_bts(sample
, evsel
, thread
, al
, addr_al
, machine
, fp
);
2025 if (PRINT_FIELD(TRACE
) && sample
->raw_data
) {
2026 event_format__fprintf(evsel
->tp_format
, sample
->cpu
,
2027 sample
->raw_data
, sample
->raw_size
, fp
);
2030 if (attr
->type
== PERF_TYPE_SYNTH
&& PRINT_FIELD(SYNTH
))
2031 perf_sample__fprintf_synth(sample
, evsel
, fp
);
2033 if (PRINT_FIELD(ADDR
))
2034 perf_sample__fprintf_addr(sample
, thread
, attr
, fp
);
2036 if (PRINT_FIELD(DATA_SRC
))
2037 data_src__fprintf(sample
->data_src
, fp
);
2039 if (PRINT_FIELD(WEIGHT
))
2040 fprintf(fp
, "%16" PRIu64
, sample
->weight
);
2042 if (PRINT_FIELD(IP
)) {
2043 struct callchain_cursor
*cursor
= NULL
;
2045 if (script
->stitch_lbr
)
2046 al
->thread
->lbr_stitch_enable
= true;
2048 if (symbol_conf
.use_callchain
&& sample
->callchain
&&
2049 thread__resolve_callchain(al
->thread
, &callchain_cursor
, evsel
,
2050 sample
, NULL
, NULL
, scripting_max_stack
) == 0)
2051 cursor
= &callchain_cursor
;
2053 fputc(cursor
? '\n' : ' ', fp
);
2054 sample__fprintf_sym(sample
, al
, 0, output
[type
].print_ip_opts
, cursor
,
2055 symbol_conf
.bt_stop_list
, fp
);
2058 if (PRINT_FIELD(IREGS
))
2059 perf_sample__fprintf_iregs(sample
, attr
, fp
);
2061 if (PRINT_FIELD(UREGS
))
2062 perf_sample__fprintf_uregs(sample
, attr
, fp
);
2064 if (PRINT_FIELD(BRSTACK
))
2065 perf_sample__fprintf_brstack(sample
, thread
, attr
, fp
);
2066 else if (PRINT_FIELD(BRSTACKSYM
))
2067 perf_sample__fprintf_brstacksym(sample
, thread
, attr
, fp
);
2068 else if (PRINT_FIELD(BRSTACKOFF
))
2069 perf_sample__fprintf_brstackoff(sample
, thread
, attr
, fp
);
2071 if (evsel__is_bpf_output(evsel
) && PRINT_FIELD(BPF_OUTPUT
))
2072 perf_sample__fprintf_bpf_output(sample
, fp
);
2073 perf_sample__fprintf_insn(sample
, attr
, thread
, machine
, fp
);
2075 if (PRINT_FIELD(PHYS_ADDR
))
2076 fprintf(fp
, "%16" PRIx64
, sample
->phys_addr
);
2078 if (PRINT_FIELD(DATA_PAGE_SIZE
))
2079 fprintf(fp
, " %s", get_page_size_name(sample
->data_page_size
, str
));
2081 if (PRINT_FIELD(CODE_PAGE_SIZE
))
2082 fprintf(fp
, " %s", get_page_size_name(sample
->code_page_size
, str
));
2084 perf_sample__fprintf_ipc(sample
, attr
, fp
);
2088 if (PRINT_FIELD(SRCCODE
)) {
2089 if (map__fprintf_srccode(al
->map
, al
->addr
, stdout
,
2090 &thread
->srccode_state
))
2094 if (PRINT_FIELD(METRIC
))
2095 perf_sample__fprint_metric(script
, thread
, evsel
, sample
, fp
);
2101 static struct scripting_ops
*scripting_ops
;
2103 static void __process_stat(struct evsel
*counter
, u64 tstamp
)
2105 int nthreads
= perf_thread_map__nr(counter
->core
.threads
);
2106 int ncpus
= evsel__nr_cpus(counter
);
2108 static int header_printed
;
2110 if (counter
->core
.system_wide
)
2113 if (!header_printed
) {
2114 printf("%3s %8s %15s %15s %15s %15s %s\n",
2115 "CPU", "THREAD", "VAL", "ENA", "RUN", "TIME", "EVENT");
2119 for (thread
= 0; thread
< nthreads
; thread
++) {
2120 for (cpu
= 0; cpu
< ncpus
; cpu
++) {
2121 struct perf_counts_values
*counts
;
2123 counts
= perf_counts(counter
->counts
, cpu
, thread
);
2125 printf("%3d %8d %15" PRIu64
" %15" PRIu64
" %15" PRIu64
" %15" PRIu64
" %s\n",
2126 counter
->core
.cpus
->map
[cpu
],
2127 perf_thread_map__pid(counter
->core
.threads
, thread
),
2132 evsel__name(counter
));
2137 static void process_stat(struct evsel
*counter
, u64 tstamp
)
2139 if (scripting_ops
&& scripting_ops
->process_stat
)
2140 scripting_ops
->process_stat(&stat_config
, counter
, tstamp
);
2142 __process_stat(counter
, tstamp
);
2145 static void process_stat_interval(u64 tstamp
)
2147 if (scripting_ops
&& scripting_ops
->process_stat_interval
)
2148 scripting_ops
->process_stat_interval(tstamp
);
2151 static void setup_scripting(void)
2153 setup_perl_scripting();
2154 setup_python_scripting();
2157 static int flush_scripting(void)
2159 return scripting_ops
? scripting_ops
->flush_script() : 0;
2162 static int cleanup_scripting(void)
2164 pr_debug("\nperf script stopped\n");
2166 return scripting_ops
? scripting_ops
->stop_script() : 0;
2169 static bool filter_cpu(struct perf_sample
*sample
)
2171 if (cpu_list
&& sample
->cpu
!= (u32
)-1)
2172 return !test_bit(sample
->cpu
, cpu_bitmap
);
2176 static int process_sample_event(struct perf_tool
*tool
,
2177 union perf_event
*event
,
2178 struct perf_sample
*sample
,
2179 struct evsel
*evsel
,
2180 struct machine
*machine
)
2182 struct perf_script
*scr
= container_of(tool
, struct perf_script
, tool
);
2183 struct addr_location al
;
2184 struct addr_location addr_al
;
2187 /* Set thread to NULL to indicate addr_al and al are not initialized */
2188 addr_al
.thread
= NULL
;
2191 ret
= dlfilter__filter_event_early(dlfilter
, event
, sample
, evsel
, machine
, &al
, &addr_al
);
2198 if (perf_time__ranges_skip_sample(scr
->ptime_range
, scr
->range_num
,
2204 if (sample
->time
< last_timestamp
) {
2205 pr_err("Samples misordered, previous: %" PRIu64
2206 " this: %" PRIu64
"\n", last_timestamp
,
2210 last_timestamp
= sample
->time
;
2214 if (filter_cpu(sample
))
2217 if (!al
.thread
&& machine__resolve(machine
, &al
, sample
) < 0) {
2218 pr_err("problem processing %d event, skipping it.\n",
2219 event
->header
.type
);
2227 if (!show_event(sample
, evsel
, al
.thread
, &al
, &addr_al
))
2230 if (evswitch__discard(&scr
->evswitch
, evsel
))
2233 ret
= dlfilter__filter_event(dlfilter
, event
, sample
, evsel
, machine
, &al
, &addr_al
);
2240 if (scripting_ops
) {
2241 struct addr_location
*addr_al_ptr
= NULL
;
2243 if ((evsel
->core
.attr
.sample_type
& PERF_SAMPLE_ADDR
) &&
2244 sample_addr_correlates_sym(&evsel
->core
.attr
)) {
2245 if (!addr_al
.thread
)
2246 thread__resolve(al
.thread
, &addr_al
, sample
);
2247 addr_al_ptr
= &addr_al
;
2249 scripting_ops
->process_event(event
, sample
, evsel
, &al
, addr_al_ptr
);
2251 process_event(scr
, sample
, evsel
, &al
, &addr_al
, machine
);
2256 addr_location__put(&al
);
2260 static int process_attr(struct perf_tool
*tool
, union perf_event
*event
,
2261 struct evlist
**pevlist
)
2263 struct perf_script
*scr
= container_of(tool
, struct perf_script
, tool
);
2264 struct evlist
*evlist
;
2265 struct evsel
*evsel
, *pos
;
2268 static struct evsel_script
*es
;
2270 err
= perf_event__process_attr(tool
, event
, pevlist
);
2275 evsel
= evlist__last(*pevlist
);
2278 if (scr
->per_event_dump
) {
2279 evsel
->priv
= evsel_script__new(evsel
, scr
->session
->data
);
2281 es
= zalloc(sizeof(*es
));
2289 if (evsel
->core
.attr
.type
>= PERF_TYPE_MAX
&&
2290 evsel
->core
.attr
.type
!= PERF_TYPE_SYNTH
)
2293 evlist__for_each_entry(evlist
, pos
) {
2294 if (pos
->core
.attr
.type
== evsel
->core
.attr
.type
&& pos
!= evsel
)
2298 if (evsel
->core
.attr
.sample_type
) {
2299 err
= evsel__check_attr(evsel
, scr
->session
);
2305 * Check if we need to enable callchains based
2306 * on events sample_type.
2308 sample_type
= evlist__combined_sample_type(evlist
);
2309 callchain_param_setup(sample_type
);
2311 /* Enable fields for callchain entries */
2312 if (symbol_conf
.use_callchain
&&
2313 (sample_type
& PERF_SAMPLE_CALLCHAIN
||
2314 sample_type
& PERF_SAMPLE_BRANCH_STACK
||
2315 (sample_type
& PERF_SAMPLE_REGS_USER
&&
2316 sample_type
& PERF_SAMPLE_STACK_USER
))) {
2317 int type
= output_type(evsel
->core
.attr
.type
);
2319 if (!(output
[type
].user_unset_fields
& PERF_OUTPUT_IP
))
2320 output
[type
].fields
|= PERF_OUTPUT_IP
;
2321 if (!(output
[type
].user_unset_fields
& PERF_OUTPUT_SYM
))
2322 output
[type
].fields
|= PERF_OUTPUT_SYM
;
2324 set_print_ip_opts(&evsel
->core
.attr
);
2328 static int print_event_with_time(struct perf_tool
*tool
,
2329 union perf_event
*event
,
2330 struct perf_sample
*sample
,
2331 struct machine
*machine
,
2332 pid_t pid
, pid_t tid
, u64 timestamp
)
2334 struct perf_script
*script
= container_of(tool
, struct perf_script
, tool
);
2335 struct perf_session
*session
= script
->session
;
2336 struct evsel
*evsel
= evlist__id2evsel(session
->evlist
, sample
->id
);
2337 struct thread
*thread
= NULL
;
2339 if (evsel
&& !evsel
->core
.attr
.sample_id_all
) {
2341 sample
->time
= timestamp
;
2346 if (filter_cpu(sample
))
2350 thread
= machine__findnew_thread(machine
, pid
, tid
);
2353 perf_sample__fprintf_start(script
, sample
, thread
, evsel
,
2354 event
->header
.type
, stdout
);
2357 perf_event__fprintf(event
, machine
, stdout
);
2359 thread__put(thread
);
2364 static int print_event(struct perf_tool
*tool
, union perf_event
*event
,
2365 struct perf_sample
*sample
, struct machine
*machine
,
2366 pid_t pid
, pid_t tid
)
2368 return print_event_with_time(tool
, event
, sample
, machine
, pid
, tid
, 0);
2371 static int process_comm_event(struct perf_tool
*tool
,
2372 union perf_event
*event
,
2373 struct perf_sample
*sample
,
2374 struct machine
*machine
)
2376 if (perf_event__process_comm(tool
, event
, sample
, machine
) < 0)
2379 return print_event(tool
, event
, sample
, machine
, event
->comm
.pid
,
2383 static int process_namespaces_event(struct perf_tool
*tool
,
2384 union perf_event
*event
,
2385 struct perf_sample
*sample
,
2386 struct machine
*machine
)
2388 if (perf_event__process_namespaces(tool
, event
, sample
, machine
) < 0)
2391 return print_event(tool
, event
, sample
, machine
, event
->namespaces
.pid
,
2392 event
->namespaces
.tid
);
2395 static int process_cgroup_event(struct perf_tool
*tool
,
2396 union perf_event
*event
,
2397 struct perf_sample
*sample
,
2398 struct machine
*machine
)
2400 if (perf_event__process_cgroup(tool
, event
, sample
, machine
) < 0)
2403 return print_event(tool
, event
, sample
, machine
, sample
->pid
,
2407 static int process_fork_event(struct perf_tool
*tool
,
2408 union perf_event
*event
,
2409 struct perf_sample
*sample
,
2410 struct machine
*machine
)
2412 if (perf_event__process_fork(tool
, event
, sample
, machine
) < 0)
2415 return print_event_with_time(tool
, event
, sample
, machine
,
2416 event
->fork
.pid
, event
->fork
.tid
,
2419 static int process_exit_event(struct perf_tool
*tool
,
2420 union perf_event
*event
,
2421 struct perf_sample
*sample
,
2422 struct machine
*machine
)
2424 /* Print before 'exit' deletes anything */
2425 if (print_event_with_time(tool
, event
, sample
, machine
, event
->fork
.pid
,
2426 event
->fork
.tid
, event
->fork
.time
))
2429 return perf_event__process_exit(tool
, event
, sample
, machine
);
2432 static int process_mmap_event(struct perf_tool
*tool
,
2433 union perf_event
*event
,
2434 struct perf_sample
*sample
,
2435 struct machine
*machine
)
2437 if (perf_event__process_mmap(tool
, event
, sample
, machine
) < 0)
2440 return print_event(tool
, event
, sample
, machine
, event
->mmap
.pid
,
2444 static int process_mmap2_event(struct perf_tool
*tool
,
2445 union perf_event
*event
,
2446 struct perf_sample
*sample
,
2447 struct machine
*machine
)
2449 if (perf_event__process_mmap2(tool
, event
, sample
, machine
) < 0)
2452 return print_event(tool
, event
, sample
, machine
, event
->mmap2
.pid
,
2456 static int process_switch_event(struct perf_tool
*tool
,
2457 union perf_event
*event
,
2458 struct perf_sample
*sample
,
2459 struct machine
*machine
)
2461 struct perf_script
*script
= container_of(tool
, struct perf_script
, tool
);
2463 if (perf_event__process_switch(tool
, event
, sample
, machine
) < 0)
2466 if (scripting_ops
&& scripting_ops
->process_switch
)
2467 scripting_ops
->process_switch(event
, sample
, machine
);
2469 if (!script
->show_switch_events
)
2472 return print_event(tool
, event
, sample
, machine
, sample
->pid
,
2476 static int process_auxtrace_error(struct perf_session
*session
,
2477 union perf_event
*event
)
2479 if (scripting_ops
&& scripting_ops
->process_auxtrace_error
) {
2480 scripting_ops
->process_auxtrace_error(session
, event
);
2484 return perf_event__process_auxtrace_error(session
, event
);
2488 process_lost_event(struct perf_tool
*tool
,
2489 union perf_event
*event
,
2490 struct perf_sample
*sample
,
2491 struct machine
*machine
)
2493 return print_event(tool
, event
, sample
, machine
, sample
->pid
,
2498 process_throttle_event(struct perf_tool
*tool __maybe_unused
,
2499 union perf_event
*event
,
2500 struct perf_sample
*sample
,
2501 struct machine
*machine
)
2503 if (scripting_ops
&& scripting_ops
->process_throttle
)
2504 scripting_ops
->process_throttle(event
, sample
, machine
);
2509 process_finished_round_event(struct perf_tool
*tool __maybe_unused
,
2510 union perf_event
*event
,
2511 struct ordered_events
*oe __maybe_unused
)
2514 perf_event__fprintf(event
, NULL
, stdout
);
2519 process_bpf_events(struct perf_tool
*tool __maybe_unused
,
2520 union perf_event
*event
,
2521 struct perf_sample
*sample
,
2522 struct machine
*machine
)
2524 if (machine__process_ksymbol(machine
, event
, sample
) < 0)
2527 return print_event(tool
, event
, sample
, machine
, sample
->pid
,
2531 static int process_text_poke_events(struct perf_tool
*tool
,
2532 union perf_event
*event
,
2533 struct perf_sample
*sample
,
2534 struct machine
*machine
)
2536 if (perf_event__process_text_poke(tool
, event
, sample
, machine
) < 0)
2539 return print_event(tool
, event
, sample
, machine
, sample
->pid
,
2543 static void sig_handler(int sig __maybe_unused
)
2548 static void perf_script__fclose_per_event_dump(struct perf_script
*script
)
2550 struct evlist
*evlist
= script
->session
->evlist
;
2551 struct evsel
*evsel
;
2553 evlist__for_each_entry(evlist
, evsel
) {
2556 evsel_script__delete(evsel
->priv
);
2561 static int perf_script__fopen_per_event_dump(struct perf_script
*script
)
2563 struct evsel
*evsel
;
2565 evlist__for_each_entry(script
->session
->evlist
, evsel
) {
2567 * Already setup? I.e. we may be called twice in cases like
2568 * Intel PT, one for the intel_pt// and dummy events, then
2569 * for the evsels synthesized from the auxtrace info.
2571 * Ses perf_script__process_auxtrace_info.
2573 if (evsel
->priv
!= NULL
)
2576 evsel
->priv
= evsel_script__new(evsel
, script
->session
->data
);
2577 if (evsel
->priv
== NULL
)
2578 goto out_err_fclose
;
2584 perf_script__fclose_per_event_dump(script
);
2588 static int perf_script__setup_per_event_dump(struct perf_script
*script
)
2590 struct evsel
*evsel
;
2591 static struct evsel_script es_stdout
;
2593 if (script
->per_event_dump
)
2594 return perf_script__fopen_per_event_dump(script
);
2596 es_stdout
.fp
= stdout
;
2598 evlist__for_each_entry(script
->session
->evlist
, evsel
)
2599 evsel
->priv
= &es_stdout
;
2604 static void perf_script__exit_per_event_dump_stats(struct perf_script
*script
)
2606 struct evsel
*evsel
;
2608 evlist__for_each_entry(script
->session
->evlist
, evsel
) {
2609 struct evsel_script
*es
= evsel
->priv
;
2611 evsel_script__fprintf(es
, stdout
);
2612 evsel_script__delete(es
);
2617 static void perf_script__exit(struct perf_script
*script
)
2619 perf_thread_map__put(script
->threads
);
2620 perf_cpu_map__put(script
->cpus
);
2623 static int __cmd_script(struct perf_script
*script
)
2627 signal(SIGINT
, sig_handler
);
2629 perf_stat__init_shadow_stats();
2631 /* override event processing functions */
2632 if (script
->show_task_events
) {
2633 script
->tool
.comm
= process_comm_event
;
2634 script
->tool
.fork
= process_fork_event
;
2635 script
->tool
.exit
= process_exit_event
;
2637 if (script
->show_mmap_events
) {
2638 script
->tool
.mmap
= process_mmap_event
;
2639 script
->tool
.mmap2
= process_mmap2_event
;
2641 if (script
->show_switch_events
|| (scripting_ops
&& scripting_ops
->process_switch
))
2642 script
->tool
.context_switch
= process_switch_event
;
2643 if (scripting_ops
&& scripting_ops
->process_auxtrace_error
)
2644 script
->tool
.auxtrace_error
= process_auxtrace_error
;
2645 if (script
->show_namespace_events
)
2646 script
->tool
.namespaces
= process_namespaces_event
;
2647 if (script
->show_cgroup_events
)
2648 script
->tool
.cgroup
= process_cgroup_event
;
2649 if (script
->show_lost_events
)
2650 script
->tool
.lost
= process_lost_event
;
2651 if (script
->show_round_events
) {
2652 script
->tool
.ordered_events
= false;
2653 script
->tool
.finished_round
= process_finished_round_event
;
2655 if (script
->show_bpf_events
) {
2656 script
->tool
.ksymbol
= process_bpf_events
;
2657 script
->tool
.bpf
= process_bpf_events
;
2659 if (script
->show_text_poke_events
) {
2660 script
->tool
.ksymbol
= process_bpf_events
;
2661 script
->tool
.text_poke
= process_text_poke_events
;
2664 if (perf_script__setup_per_event_dump(script
)) {
2665 pr_err("Couldn't create the per event dump files\n");
2669 ret
= perf_session__process_events(script
->session
);
2671 if (script
->per_event_dump
)
2672 perf_script__exit_per_event_dump_stats(script
);
2675 pr_err("Misordered timestamps: %" PRIu64
"\n", nr_unordered
);
2680 struct script_spec
{
2681 struct list_head node
;
2682 struct scripting_ops
*ops
;
2686 static LIST_HEAD(script_specs
);
2688 static struct script_spec
*script_spec__new(const char *spec
,
2689 struct scripting_ops
*ops
)
2691 struct script_spec
*s
= malloc(sizeof(*s
) + strlen(spec
) + 1);
2694 strcpy(s
->spec
, spec
);
2701 static void script_spec__add(struct script_spec
*s
)
2703 list_add_tail(&s
->node
, &script_specs
);
2706 static struct script_spec
*script_spec__find(const char *spec
)
2708 struct script_spec
*s
;
2710 list_for_each_entry(s
, &script_specs
, node
)
2711 if (strcasecmp(s
->spec
, spec
) == 0)
2716 int script_spec_register(const char *spec
, struct scripting_ops
*ops
)
2718 struct script_spec
*s
;
2720 s
= script_spec__find(spec
);
2724 s
= script_spec__new(spec
, ops
);
2728 script_spec__add(s
);
2733 static struct scripting_ops
*script_spec__lookup(const char *spec
)
2735 struct script_spec
*s
= script_spec__find(spec
);
2742 static void list_available_languages(void)
2744 struct script_spec
*s
;
2746 fprintf(stderr
, "\n");
2747 fprintf(stderr
, "Scripting language extensions (used in "
2748 "perf script -s [spec:]script.[spec]):\n\n");
2750 list_for_each_entry(s
, &script_specs
, node
)
2751 fprintf(stderr
, " %-42s [%s]\n", s
->spec
, s
->ops
->name
);
2753 fprintf(stderr
, "\n");
2756 /* Find script file relative to current directory or exec path */
2757 static char *find_script(const char *script
)
2759 char path
[PATH_MAX
];
2761 if (!scripting_ops
) {
2762 const char *ext
= strrchr(script
, '.');
2767 scripting_ops
= script_spec__lookup(++ext
);
2772 if (access(script
, R_OK
)) {
2773 char *exec_path
= get_argv_exec_path();
2777 snprintf(path
, sizeof(path
), "%s/scripts/%s/%s",
2778 exec_path
, scripting_ops
->dirname
, script
);
2781 if (access(script
, R_OK
))
2784 return strdup(script
);
2787 static int parse_scriptname(const struct option
*opt __maybe_unused
,
2788 const char *str
, int unset __maybe_unused
)
2790 char spec
[PATH_MAX
];
2791 const char *script
, *ext
;
2794 if (strcmp(str
, "lang") == 0) {
2795 list_available_languages();
2799 script
= strchr(str
, ':');
2802 if (len
>= PATH_MAX
) {
2803 fprintf(stderr
, "invalid language specifier");
2806 strncpy(spec
, str
, len
);
2808 scripting_ops
= script_spec__lookup(spec
);
2809 if (!scripting_ops
) {
2810 fprintf(stderr
, "invalid language specifier");
2816 ext
= strrchr(script
, '.');
2818 fprintf(stderr
, "invalid script extension");
2821 scripting_ops
= script_spec__lookup(++ext
);
2822 if (!scripting_ops
) {
2823 fprintf(stderr
, "invalid script extension");
2828 script_name
= find_script(script
);
2830 script_name
= strdup(script
);
2835 static int parse_output_fields(const struct option
*opt __maybe_unused
,
2836 const char *arg
, int unset __maybe_unused
)
2838 char *tok
, *strtok_saveptr
= NULL
;
2839 int i
, imax
= ARRAY_SIZE(all_output_options
);
2842 char *str
= strdup(arg
);
2844 enum { DEFAULT
, SET
, ADD
, REMOVE
} change
= DEFAULT
;
2849 /* first word can state for which event type the user is specifying
2850 * the fields. If no type exists, the specified fields apply to all
2851 * event types found in the file minus the invalid fields for a type.
2853 tok
= strchr(str
, ':');
2857 if (!strcmp(str
, "hw"))
2858 type
= PERF_TYPE_HARDWARE
;
2859 else if (!strcmp(str
, "sw"))
2860 type
= PERF_TYPE_SOFTWARE
;
2861 else if (!strcmp(str
, "trace"))
2862 type
= PERF_TYPE_TRACEPOINT
;
2863 else if (!strcmp(str
, "raw"))
2864 type
= PERF_TYPE_RAW
;
2865 else if (!strcmp(str
, "break"))
2866 type
= PERF_TYPE_BREAKPOINT
;
2867 else if (!strcmp(str
, "synth"))
2868 type
= OUTPUT_TYPE_SYNTH
;
2870 fprintf(stderr
, "Invalid event type in field string.\n");
2875 if (output
[type
].user_set
)
2876 pr_warning("Overriding previous field request for %s events.\n",
2879 /* Don't override defaults for +- */
2880 if (strchr(tok
, '+') || strchr(tok
, '-'))
2883 output
[type
].fields
= 0;
2884 output
[type
].user_set
= true;
2885 output
[type
].wildcard_set
= false;
2889 if (strlen(str
) == 0) {
2891 "Cannot set fields to 'none' for all event types.\n");
2896 /* Don't override defaults for +- */
2897 if (strchr(str
, '+') || strchr(str
, '-'))
2900 if (output_set_by_user())
2901 pr_warning("Overriding previous field request for all events.\n");
2903 for (j
= 0; j
< OUTPUT_TYPE_MAX
; ++j
) {
2904 output
[j
].fields
= 0;
2905 output
[j
].user_set
= true;
2906 output
[j
].wildcard_set
= true;
2911 for (tok
= strtok_r(tok
, ",", &strtok_saveptr
); tok
; tok
= strtok_r(NULL
, ",", &strtok_saveptr
)) {
2917 } else if (*tok
== '-') {
2923 if (change
!= SET
&& change
!= DEFAULT
)
2928 for (i
= 0; i
< imax
; ++i
) {
2929 if (strcmp(tok
, all_output_options
[i
].str
) == 0)
2932 if (i
== imax
&& strcmp(tok
, "flags") == 0) {
2933 print_flags
= change
!= REMOVE
;
2937 fprintf(stderr
, "Invalid field requested.\n");
2943 /* add user option to all events types for
2946 for (j
= 0; j
< OUTPUT_TYPE_MAX
; ++j
) {
2947 if (output
[j
].invalid_fields
& all_output_options
[i
].field
) {
2948 pr_warning("\'%s\' not valid for %s events. Ignoring.\n",
2949 all_output_options
[i
].str
, event_type(j
));
2951 if (change
== REMOVE
) {
2952 output
[j
].fields
&= ~all_output_options
[i
].field
;
2953 output
[j
].user_set_fields
&= ~all_output_options
[i
].field
;
2954 output
[j
].user_unset_fields
|= all_output_options
[i
].field
;
2956 output
[j
].fields
|= all_output_options
[i
].field
;
2957 output
[j
].user_set_fields
|= all_output_options
[i
].field
;
2958 output
[j
].user_unset_fields
&= ~all_output_options
[i
].field
;
2960 output
[j
].user_set
= true;
2961 output
[j
].wildcard_set
= true;
2965 if (output
[type
].invalid_fields
& all_output_options
[i
].field
) {
2966 fprintf(stderr
, "\'%s\' not valid for %s events.\n",
2967 all_output_options
[i
].str
, event_type(type
));
2972 if (change
== REMOVE
)
2973 output
[type
].fields
&= ~all_output_options
[i
].field
;
2975 output
[type
].fields
|= all_output_options
[i
].field
;
2976 output
[type
].user_set
= true;
2977 output
[type
].wildcard_set
= true;
2982 if (output
[type
].fields
== 0) {
2983 pr_debug("No fields requested for %s type. "
2984 "Events will not be displayed.\n", event_type(type
));
2990 fprintf(stderr
, "Cannot mix +-field with overridden fields\n");
2997 #define for_each_lang(scripts_path, scripts_dir, lang_dirent) \
2998 while ((lang_dirent = readdir(scripts_dir)) != NULL) \
2999 if ((lang_dirent->d_type == DT_DIR || \
3000 (lang_dirent->d_type == DT_UNKNOWN && \
3001 is_directory(scripts_path, lang_dirent))) && \
3002 (strcmp(lang_dirent->d_name, ".")) && \
3003 (strcmp(lang_dirent->d_name, "..")))
3005 #define for_each_script(lang_path, lang_dir, script_dirent) \
3006 while ((script_dirent = readdir(lang_dir)) != NULL) \
3007 if (script_dirent->d_type != DT_DIR && \
3008 (script_dirent->d_type != DT_UNKNOWN || \
3009 !is_directory(lang_path, script_dirent)))
3012 #define RECORD_SUFFIX "-record"
3013 #define REPORT_SUFFIX "-report"
3015 struct script_desc
{
3016 struct list_head node
;
3022 static LIST_HEAD(script_descs
);
3024 static struct script_desc
*script_desc__new(const char *name
)
3026 struct script_desc
*s
= zalloc(sizeof(*s
));
3028 if (s
!= NULL
&& name
)
3029 s
->name
= strdup(name
);
3034 static void script_desc__delete(struct script_desc
*s
)
3037 zfree(&s
->half_liner
);
3042 static void script_desc__add(struct script_desc
*s
)
3044 list_add_tail(&s
->node
, &script_descs
);
3047 static struct script_desc
*script_desc__find(const char *name
)
3049 struct script_desc
*s
;
3051 list_for_each_entry(s
, &script_descs
, node
)
3052 if (strcasecmp(s
->name
, name
) == 0)
3057 static struct script_desc
*script_desc__findnew(const char *name
)
3059 struct script_desc
*s
= script_desc__find(name
);
3064 s
= script_desc__new(name
);
3068 script_desc__add(s
);
3073 static const char *ends_with(const char *str
, const char *suffix
)
3075 size_t suffix_len
= strlen(suffix
);
3076 const char *p
= str
;
3078 if (strlen(str
) > suffix_len
) {
3079 p
= str
+ strlen(str
) - suffix_len
;
3080 if (!strncmp(p
, suffix
, suffix_len
))
3087 static int read_script_info(struct script_desc
*desc
, const char *filename
)
3089 char line
[BUFSIZ
], *p
;
3092 fp
= fopen(filename
, "r");
3096 while (fgets(line
, sizeof(line
), fp
)) {
3097 p
= skip_spaces(line
);
3103 if (strlen(p
) && *p
== '!')
3107 if (strlen(p
) && p
[strlen(p
) - 1] == '\n')
3108 p
[strlen(p
) - 1] = '\0';
3110 if (!strncmp(p
, "description:", strlen("description:"))) {
3111 p
+= strlen("description:");
3112 desc
->half_liner
= strdup(skip_spaces(p
));
3116 if (!strncmp(p
, "args:", strlen("args:"))) {
3117 p
+= strlen("args:");
3118 desc
->args
= strdup(skip_spaces(p
));
3128 static char *get_script_root(struct dirent
*script_dirent
, const char *suffix
)
3130 char *script_root
, *str
;
3132 script_root
= strdup(script_dirent
->d_name
);
3136 str
= (char *)ends_with(script_root
, suffix
);
3146 static int list_available_scripts(const struct option
*opt __maybe_unused
,
3147 const char *s __maybe_unused
,
3148 int unset __maybe_unused
)
3150 struct dirent
*script_dirent
, *lang_dirent
;
3151 char scripts_path
[MAXPATHLEN
];
3152 DIR *scripts_dir
, *lang_dir
;
3153 char script_path
[MAXPATHLEN
];
3154 char lang_path
[MAXPATHLEN
];
3155 struct script_desc
*desc
;
3156 char first_half
[BUFSIZ
];
3159 snprintf(scripts_path
, MAXPATHLEN
, "%s/scripts", get_argv_exec_path());
3161 scripts_dir
= opendir(scripts_path
);
3164 "open(%s) failed.\n"
3165 "Check \"PERF_EXEC_PATH\" env to set scripts dir.\n",
3170 for_each_lang(scripts_path
, scripts_dir
, lang_dirent
) {
3171 scnprintf(lang_path
, MAXPATHLEN
, "%s/%s/bin", scripts_path
,
3172 lang_dirent
->d_name
);
3173 lang_dir
= opendir(lang_path
);
3177 for_each_script(lang_path
, lang_dir
, script_dirent
) {
3178 script_root
= get_script_root(script_dirent
, REPORT_SUFFIX
);
3180 desc
= script_desc__findnew(script_root
);
3181 scnprintf(script_path
, MAXPATHLEN
, "%s/%s",
3182 lang_path
, script_dirent
->d_name
);
3183 read_script_info(desc
, script_path
);
3189 fprintf(stdout
, "List of available trace scripts:\n");
3190 list_for_each_entry(desc
, &script_descs
, node
) {
3191 sprintf(first_half
, "%s %s", desc
->name
,
3192 desc
->args
? desc
->args
: "");
3193 fprintf(stdout
, " %-36s %s\n", first_half
,
3194 desc
->half_liner
? desc
->half_liner
: "");
3200 static int add_dlarg(const struct option
*opt __maybe_unused
,
3201 const char *s
, int unset __maybe_unused
)
3203 char *arg
= strdup(s
);
3209 a
= realloc(dlargv
, sizeof(dlargv
[0]) * (dlargc
+ 1));
3216 dlargv
[dlargc
++] = arg
;
3221 static void free_dlarg(void)
3224 free(dlargv
[dlargc
]);
3229 * Some scripts specify the required events in their "xxx-record" file,
3230 * this function will check if the events in perf.data match those
3231 * mentioned in the "xxx-record".
3233 * Fixme: All existing "xxx-record" are all in good formats "-e event ",
3234 * which is covered well now. And new parsing code should be added to
3235 * cover the future complex formats like event groups etc.
3237 static int check_ev_match(char *dir_name
, char *scriptname
,
3238 struct perf_session
*session
)
3240 char filename
[MAXPATHLEN
], evname
[128];
3241 char line
[BUFSIZ
], *p
;
3246 scnprintf(filename
, MAXPATHLEN
, "%s/bin/%s-record", dir_name
, scriptname
);
3248 fp
= fopen(filename
, "r");
3252 while (fgets(line
, sizeof(line
), fp
)) {
3253 p
= skip_spaces(line
);
3258 p
= strstr(p
, "-e");
3264 len
= strcspn(p
, " \t");
3268 snprintf(evname
, len
+ 1, "%s", p
);
3271 evlist__for_each_entry(session
->evlist
, pos
) {
3272 if (!strcmp(evsel__name(pos
), evname
)) {
3290 * Return -1 if none is found, otherwise the actual scripts number.
3292 * Currently the only user of this function is the script browser, which
3293 * will list all statically runnable scripts, select one, execute it and
3294 * show the output in a perf browser.
3296 int find_scripts(char **scripts_array
, char **scripts_path_array
, int num
,
3299 struct dirent
*script_dirent
, *lang_dirent
;
3300 char scripts_path
[MAXPATHLEN
], lang_path
[MAXPATHLEN
];
3301 DIR *scripts_dir
, *lang_dir
;
3302 struct perf_session
*session
;
3303 struct perf_data data
= {
3305 .mode
= PERF_DATA_MODE_READ
,
3310 session
= perf_session__new(&data
, NULL
);
3311 if (IS_ERR(session
))
3312 return PTR_ERR(session
);
3314 snprintf(scripts_path
, MAXPATHLEN
, "%s/scripts", get_argv_exec_path());
3316 scripts_dir
= opendir(scripts_path
);
3318 perf_session__delete(session
);
3322 for_each_lang(scripts_path
, scripts_dir
, lang_dirent
) {
3323 scnprintf(lang_path
, MAXPATHLEN
, "%s/%s", scripts_path
,
3324 lang_dirent
->d_name
);
3325 #ifndef HAVE_LIBPERL_SUPPORT
3326 if (strstr(lang_path
, "perl"))
3329 #ifndef HAVE_LIBPYTHON_SUPPORT
3330 if (strstr(lang_path
, "python"))
3334 lang_dir
= opendir(lang_path
);
3338 for_each_script(lang_path
, lang_dir
, script_dirent
) {
3339 /* Skip those real time scripts: xxxtop.p[yl] */
3340 if (strstr(script_dirent
->d_name
, "top."))
3344 snprintf(scripts_path_array
[i
], pathlen
, "%s/%s",
3346 script_dirent
->d_name
);
3347 temp
= strchr(script_dirent
->d_name
, '.');
3348 snprintf(scripts_array
[i
],
3349 (temp
- script_dirent
->d_name
) + 1,
3350 "%s", script_dirent
->d_name
);
3352 if (check_ev_match(lang_path
,
3353 scripts_array
[i
], session
))
3361 closedir(scripts_dir
);
3362 perf_session__delete(session
);
3366 static char *get_script_path(const char *script_root
, const char *suffix
)
3368 struct dirent
*script_dirent
, *lang_dirent
;
3369 char scripts_path
[MAXPATHLEN
];
3370 char script_path
[MAXPATHLEN
];
3371 DIR *scripts_dir
, *lang_dir
;
3372 char lang_path
[MAXPATHLEN
];
3373 char *__script_root
;
3375 snprintf(scripts_path
, MAXPATHLEN
, "%s/scripts", get_argv_exec_path());
3377 scripts_dir
= opendir(scripts_path
);
3381 for_each_lang(scripts_path
, scripts_dir
, lang_dirent
) {
3382 scnprintf(lang_path
, MAXPATHLEN
, "%s/%s/bin", scripts_path
,
3383 lang_dirent
->d_name
);
3384 lang_dir
= opendir(lang_path
);
3388 for_each_script(lang_path
, lang_dir
, script_dirent
) {
3389 __script_root
= get_script_root(script_dirent
, suffix
);
3390 if (__script_root
&& !strcmp(script_root
, __script_root
)) {
3391 free(__script_root
);
3392 closedir(scripts_dir
);
3393 scnprintf(script_path
, MAXPATHLEN
, "%s/%s",
3394 lang_path
, script_dirent
->d_name
);
3396 return strdup(script_path
);
3398 free(__script_root
);
3402 closedir(scripts_dir
);
3407 static bool is_top_script(const char *script_path
)
3409 return ends_with(script_path
, "top") != NULL
;
3412 static int has_required_arg(char *script_path
)
3414 struct script_desc
*desc
;
3418 desc
= script_desc__new(NULL
);
3420 if (read_script_info(desc
, script_path
))
3426 for (p
= desc
->args
; *p
; p
++)
3430 script_desc__delete(desc
);
3435 static int have_cmd(int argc
, const char **argv
)
3437 char **__argv
= malloc(sizeof(const char *) * argc
);
3440 pr_err("malloc failed\n");
3444 memcpy(__argv
, argv
, sizeof(const char *) * argc
);
3445 argc
= parse_options(argc
, (const char **)__argv
, record_options
,
3446 NULL
, PARSE_OPT_STOP_AT_NON_OPTION
);
3449 system_wide
= (argc
== 0);
3454 static void script__setup_sample_type(struct perf_script
*script
)
3456 struct perf_session
*session
= script
->session
;
3457 u64 sample_type
= evlist__combined_sample_type(session
->evlist
);
3459 if (symbol_conf
.use_callchain
|| symbol_conf
.cumulate_callchain
) {
3460 if ((sample_type
& PERF_SAMPLE_REGS_USER
) &&
3461 (sample_type
& PERF_SAMPLE_STACK_USER
)) {
3462 callchain_param
.record_mode
= CALLCHAIN_DWARF
;
3463 dwarf_callchain_users
= true;
3464 } else if (sample_type
& PERF_SAMPLE_BRANCH_STACK
)
3465 callchain_param
.record_mode
= CALLCHAIN_LBR
;
3467 callchain_param
.record_mode
= CALLCHAIN_FP
;
3470 if (script
->stitch_lbr
&& (callchain_param
.record_mode
!= CALLCHAIN_LBR
)) {
3471 pr_warning("Can't find LBR callchain. Switch off --stitch-lbr.\n"
3472 "Please apply --call-graph lbr when recording.\n");
3473 script
->stitch_lbr
= false;
3477 static int process_stat_round_event(struct perf_session
*session
,
3478 union perf_event
*event
)
3480 struct perf_record_stat_round
*round
= &event
->stat_round
;
3481 struct evsel
*counter
;
3483 evlist__for_each_entry(session
->evlist
, counter
) {
3484 perf_stat_process_counter(&stat_config
, counter
);
3485 process_stat(counter
, round
->time
);
3488 process_stat_interval(round
->time
);
3492 static int process_stat_config_event(struct perf_session
*session __maybe_unused
,
3493 union perf_event
*event
)
3495 perf_event__read_stat_config(&stat_config
, &event
->stat_config
);
3499 static int set_maps(struct perf_script
*script
)
3501 struct evlist
*evlist
= script
->session
->evlist
;
3503 if (!script
->cpus
|| !script
->threads
)
3506 if (WARN_ONCE(script
->allocated
, "stats double allocation\n"))
3509 perf_evlist__set_maps(&evlist
->core
, script
->cpus
, script
->threads
);
3511 if (evlist__alloc_stats(evlist
, true))
3514 script
->allocated
= true;
3519 int process_thread_map_event(struct perf_session
*session
,
3520 union perf_event
*event
)
3522 struct perf_tool
*tool
= session
->tool
;
3523 struct perf_script
*script
= container_of(tool
, struct perf_script
, tool
);
3525 if (script
->threads
) {
3526 pr_warning("Extra thread map event, ignoring.\n");
3530 script
->threads
= thread_map__new_event(&event
->thread_map
);
3531 if (!script
->threads
)
3534 return set_maps(script
);
3538 int process_cpu_map_event(struct perf_session
*session
,
3539 union perf_event
*event
)
3541 struct perf_tool
*tool
= session
->tool
;
3542 struct perf_script
*script
= container_of(tool
, struct perf_script
, tool
);
3545 pr_warning("Extra cpu map event, ignoring.\n");
3549 script
->cpus
= cpu_map__new_data(&event
->cpu_map
.data
);
3553 return set_maps(script
);
3556 static int process_feature_event(struct perf_session
*session
,
3557 union perf_event
*event
)
3559 if (event
->feat
.feat_id
< HEADER_LAST_FEATURE
)
3560 return perf_event__process_feature(session
, event
);
3564 #ifdef HAVE_AUXTRACE_SUPPORT
3565 static int perf_script__process_auxtrace_info(struct perf_session
*session
,
3566 union perf_event
*event
)
3568 struct perf_tool
*tool
= session
->tool
;
3570 int ret
= perf_event__process_auxtrace_info(session
, event
);
3573 struct perf_script
*script
= container_of(tool
, struct perf_script
, tool
);
3575 ret
= perf_script__setup_per_event_dump(script
);
3581 #define perf_script__process_auxtrace_info 0
3584 static int parse_insn_trace(const struct option
*opt __maybe_unused
,
3585 const char *str __maybe_unused
,
3586 int unset __maybe_unused
)
3588 parse_output_fields(NULL
, "+insn,-event,-period", 0);
3589 itrace_parse_synth_opts(opt
, "i0ns", 0);
3590 symbol_conf
.nanosecs
= true;
3594 static int parse_xed(const struct option
*opt __maybe_unused
,
3595 const char *str __maybe_unused
,
3596 int unset __maybe_unused
)
3599 force_pager("xed -F insn: -A -64 | less");
3601 force_pager("xed -F insn: -A -64");
3605 static int parse_call_trace(const struct option
*opt __maybe_unused
,
3606 const char *str __maybe_unused
,
3607 int unset __maybe_unused
)
3609 parse_output_fields(NULL
, "-ip,-addr,-event,-period,+callindent", 0);
3610 itrace_parse_synth_opts(opt
, "cewp", 0);
3611 symbol_conf
.nanosecs
= true;
3612 symbol_conf
.pad_output_len_dso
= 50;
3616 static int parse_callret_trace(const struct option
*opt __maybe_unused
,
3617 const char *str __maybe_unused
,
3618 int unset __maybe_unused
)
3620 parse_output_fields(NULL
, "-ip,-addr,-event,-period,+callindent,+flags", 0);
3621 itrace_parse_synth_opts(opt
, "crewp", 0);
3622 symbol_conf
.nanosecs
= true;
3626 int cmd_script(int argc
, const char **argv
)
3628 bool show_full_info
= false;
3629 bool header
= false;
3630 bool header_only
= false;
3631 bool script_started
= false;
3632 char *rec_script_path
= NULL
;
3633 char *rep_script_path
= NULL
;
3634 struct perf_session
*session
;
3635 struct itrace_synth_opts itrace_synth_opts
= {
3637 .default_no_sample
= true,
3640 char *script_path
= NULL
;
3641 const char *dlfilter_file
= NULL
;
3642 const char **__argv
;
3644 struct perf_script script
= {
3646 .sample
= process_sample_event
,
3647 .mmap
= perf_event__process_mmap
,
3648 .mmap2
= perf_event__process_mmap2
,
3649 .comm
= perf_event__process_comm
,
3650 .namespaces
= perf_event__process_namespaces
,
3651 .cgroup
= perf_event__process_cgroup
,
3652 .exit
= perf_event__process_exit
,
3653 .fork
= perf_event__process_fork
,
3654 .attr
= process_attr
,
3655 .event_update
= perf_event__process_event_update
,
3656 .tracing_data
= perf_event__process_tracing_data
,
3657 .feature
= process_feature_event
,
3658 .build_id
= perf_event__process_build_id
,
3659 .id_index
= perf_event__process_id_index
,
3660 .auxtrace_info
= perf_script__process_auxtrace_info
,
3661 .auxtrace
= perf_event__process_auxtrace
,
3662 .auxtrace_error
= perf_event__process_auxtrace_error
,
3663 .stat
= perf_event__process_stat_event
,
3664 .stat_round
= process_stat_round_event
,
3665 .stat_config
= process_stat_config_event
,
3666 .thread_map
= process_thread_map_event
,
3667 .cpu_map
= process_cpu_map_event
,
3668 .throttle
= process_throttle_event
,
3669 .unthrottle
= process_throttle_event
,
3670 .ordered_events
= true,
3671 .ordering_requires_timestamps
= true,
3674 struct perf_data data
= {
3675 .mode
= PERF_DATA_MODE_READ
,
3677 const struct option options
[] = {
3678 OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace
,
3679 "dump raw trace in ASCII"),
3680 OPT_INCR('v', "verbose", &verbose
,
3681 "be more verbose (show symbol address, etc)"),
3682 OPT_BOOLEAN('L', "Latency", &latency_format
,
3683 "show latency attributes (irqs/preemption disabled, etc)"),
3684 OPT_CALLBACK_NOOPT('l', "list", NULL
, NULL
, "list available scripts",
3685 list_available_scripts
),
3686 OPT_CALLBACK_NOOPT(0, "list-dlfilters", NULL
, NULL
, "list available dlfilters",
3687 list_available_dlfilters
),
3688 OPT_CALLBACK('s', "script", NULL
, "name",
3689 "script file name (lang:script name, script name, or *)",
3691 OPT_STRING('g', "gen-script", &generate_script_lang
, "lang",
3692 "generate perf-script.xx script in specified language"),
3693 OPT_STRING(0, "dlfilter", &dlfilter_file
, "file", "filter .so file name"),
3694 OPT_CALLBACK(0, "dlarg", NULL
, "argument", "filter argument",
3696 OPT_STRING('i', "input", &input_name
, "file", "input file name"),
3697 OPT_BOOLEAN('d', "debug-mode", &debug_mode
,
3698 "do various checks like samples ordering and lost events"),
3699 OPT_BOOLEAN(0, "header", &header
, "Show data header."),
3700 OPT_BOOLEAN(0, "header-only", &header_only
, "Show only data header."),
3701 OPT_STRING('k', "vmlinux", &symbol_conf
.vmlinux_name
,
3702 "file", "vmlinux pathname"),
3703 OPT_STRING(0, "kallsyms", &symbol_conf
.kallsyms_name
,
3704 "file", "kallsyms pathname"),
3705 OPT_BOOLEAN('G', "hide-call-graph", &no_callchain
,
3706 "When printing symbols do not display call chain"),
3707 OPT_CALLBACK(0, "symfs", NULL
, "directory",
3708 "Look for files with symbols relative to this directory",
3709 symbol__config_symfs
),
3710 OPT_CALLBACK('F', "fields", NULL
, "str",
3711 "comma separated output fields prepend with 'type:'. "
3712 "+field to add and -field to remove."
3713 "Valid types: hw,sw,trace,raw,synth. "
3714 "Fields: comm,tid,pid,time,cpu,event,trace,ip,sym,dso,"
3715 "addr,symoff,srcline,period,iregs,uregs,brstack,"
3716 "brstacksym,flags,bpf-output,brstackinsn,brstackoff,"
3717 "callindent,insn,insnlen,synth,phys_addr,metric,misc,ipc,tod,"
3718 "data_page_size,code_page_size",
3719 parse_output_fields
),
3720 OPT_BOOLEAN('a', "all-cpus", &system_wide
,
3721 "system-wide collection from all CPUs"),
3722 OPT_STRING(0, "dsos", &symbol_conf
.dso_list_str
, "dso[,dso...]",
3723 "only consider symbols in these DSOs"),
3724 OPT_STRING('S', "symbols", &symbol_conf
.sym_list_str
, "symbol[,symbol...]",
3725 "only consider these symbols"),
3726 OPT_INTEGER(0, "addr-range", &symbol_conf
.addr_range
,
3727 "Use with -S to list traced records within address range"),
3728 OPT_CALLBACK_OPTARG(0, "insn-trace", &itrace_synth_opts
, NULL
, NULL
,
3729 "Decode instructions from itrace", parse_insn_trace
),
3730 OPT_CALLBACK_OPTARG(0, "xed", NULL
, NULL
, NULL
,
3731 "Run xed disassembler on output", parse_xed
),
3732 OPT_CALLBACK_OPTARG(0, "call-trace", &itrace_synth_opts
, NULL
, NULL
,
3733 "Decode calls from from itrace", parse_call_trace
),
3734 OPT_CALLBACK_OPTARG(0, "call-ret-trace", &itrace_synth_opts
, NULL
, NULL
,
3735 "Decode calls and returns from itrace", parse_callret_trace
),
3736 OPT_STRING(0, "graph-function", &symbol_conf
.graph_function
, "symbol[,symbol...]",
3737 "Only print symbols and callees with --call-trace/--call-ret-trace"),
3738 OPT_STRING(0, "stop-bt", &symbol_conf
.bt_stop_list_str
, "symbol[,symbol...]",
3739 "Stop display of callgraph at these symbols"),
3740 OPT_STRING('C', "cpu", &cpu_list
, "cpu", "list of cpus to profile"),
3741 OPT_STRING('c', "comms", &symbol_conf
.comm_list_str
, "comm[,comm...]",
3742 "only display events for these comms"),
3743 OPT_STRING(0, "pid", &symbol_conf
.pid_list_str
, "pid[,pid...]",
3744 "only consider symbols in these pids"),
3745 OPT_STRING(0, "tid", &symbol_conf
.tid_list_str
, "tid[,tid...]",
3746 "only consider symbols in these tids"),
3747 OPT_UINTEGER(0, "max-stack", &scripting_max_stack
,
3748 "Set the maximum stack depth when parsing the callchain, "
3749 "anything beyond the specified depth will be ignored. "
3750 "Default: kernel.perf_event_max_stack or " __stringify(PERF_MAX_STACK_DEPTH
)),
3751 OPT_BOOLEAN(0, "reltime", &reltime
, "Show time stamps relative to start"),
3752 OPT_BOOLEAN(0, "deltatime", &deltatime
, "Show time stamps relative to previous event"),
3753 OPT_BOOLEAN('I', "show-info", &show_full_info
,
3754 "display extended information from perf.data file"),
3755 OPT_BOOLEAN('\0', "show-kernel-path", &symbol_conf
.show_kernel_path
,
3756 "Show the path of [kernel.kallsyms]"),
3757 OPT_BOOLEAN('\0', "show-task-events", &script
.show_task_events
,
3758 "Show the fork/comm/exit events"),
3759 OPT_BOOLEAN('\0', "show-mmap-events", &script
.show_mmap_events
,
3760 "Show the mmap events"),
3761 OPT_BOOLEAN('\0', "show-switch-events", &script
.show_switch_events
,
3762 "Show context switch events (if recorded)"),
3763 OPT_BOOLEAN('\0', "show-namespace-events", &script
.show_namespace_events
,
3764 "Show namespace events (if recorded)"),
3765 OPT_BOOLEAN('\0', "show-cgroup-events", &script
.show_cgroup_events
,
3766 "Show cgroup events (if recorded)"),
3767 OPT_BOOLEAN('\0', "show-lost-events", &script
.show_lost_events
,
3768 "Show lost events (if recorded)"),
3769 OPT_BOOLEAN('\0', "show-round-events", &script
.show_round_events
,
3770 "Show round events (if recorded)"),
3771 OPT_BOOLEAN('\0', "show-bpf-events", &script
.show_bpf_events
,
3772 "Show bpf related events (if recorded)"),
3773 OPT_BOOLEAN('\0', "show-text-poke-events", &script
.show_text_poke_events
,
3774 "Show text poke related events (if recorded)"),
3775 OPT_BOOLEAN('\0', "per-event-dump", &script
.per_event_dump
,
3776 "Dump trace output to files named by the monitored events"),
3777 OPT_BOOLEAN('f', "force", &symbol_conf
.force
, "don't complain, do it"),
3778 OPT_INTEGER(0, "max-blocks", &max_blocks
,
3779 "Maximum number of code blocks to dump with brstackinsn"),
3780 OPT_BOOLEAN(0, "ns", &symbol_conf
.nanosecs
,
3781 "Use 9 decimal places when displaying time"),
3782 OPT_CALLBACK_OPTARG(0, "itrace", &itrace_synth_opts
, NULL
, "opts",
3783 "Instruction Tracing options\n" ITRACE_HELP
,
3784 itrace_parse_synth_opts
),
3785 OPT_BOOLEAN(0, "full-source-path", &srcline_full_filename
,
3786 "Show full source file name path for source lines"),
3787 OPT_BOOLEAN(0, "demangle", &symbol_conf
.demangle
,
3788 "Enable symbol demangling"),
3789 OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf
.demangle_kernel
,
3790 "Enable kernel symbol demangling"),
3791 OPT_STRING(0, "time", &script
.time_str
, "str",
3792 "Time span of interest (start,stop)"),
3793 OPT_BOOLEAN(0, "inline", &symbol_conf
.inline_name
,
3794 "Show inline function"),
3795 OPT_STRING(0, "guestmount", &symbol_conf
.guestmount
, "directory",
3796 "guest mount directory under which every guest os"
3797 " instance has a subdir"),
3798 OPT_STRING(0, "guestvmlinux", &symbol_conf
.default_guest_vmlinux_name
,
3799 "file", "file saving guest os vmlinux"),
3800 OPT_STRING(0, "guestkallsyms", &symbol_conf
.default_guest_kallsyms
,
3801 "file", "file saving guest os /proc/kallsyms"),
3802 OPT_STRING(0, "guestmodules", &symbol_conf
.default_guest_modules
,
3803 "file", "file saving guest os /proc/modules"),
3804 OPT_BOOLEAN('\0', "stitch-lbr", &script
.stitch_lbr
,
3805 "Enable LBR callgraph stitching approach"),
3806 OPTS_EVSWITCH(&script
.evswitch
),
3809 const char * const script_subcommands
[] = { "record", "report", NULL
};
3810 const char *script_usage
[] = {
3811 "perf script [<options>]",
3812 "perf script [<options>] record <script> [<record-options>] <command>",
3813 "perf script [<options>] report <script> [script-args]",
3814 "perf script [<options>] <script> [<record-options>] <command>",
3815 "perf script [<options>] <top-script> [script-args]",
3819 perf_set_singlethreaded();
3823 argc
= parse_options_subcommand(argc
, argv
, options
, script_subcommands
, script_usage
,
3824 PARSE_OPT_STOP_AT_NON_OPTION
);
3826 if (symbol_conf
.guestmount
||
3827 symbol_conf
.default_guest_vmlinux_name
||
3828 symbol_conf
.default_guest_kallsyms
||
3829 symbol_conf
.default_guest_modules
) {
3831 * Enable guest sample processing.
3836 data
.path
= input_name
;
3837 data
.force
= symbol_conf
.force
;
3839 if (argc
> 1 && !strncmp(argv
[0], "rec", strlen("rec"))) {
3840 rec_script_path
= get_script_path(argv
[1], RECORD_SUFFIX
);
3841 if (!rec_script_path
)
3842 return cmd_record(argc
, argv
);
3845 if (argc
> 1 && !strncmp(argv
[0], "rep", strlen("rep"))) {
3846 rep_script_path
= get_script_path(argv
[1], REPORT_SUFFIX
);
3847 if (!rep_script_path
) {
3849 "Please specify a valid report script"
3850 "(see 'perf script -l' for listing)\n");
3855 if (reltime
&& deltatime
) {
3857 "reltime and deltatime - the two don't get along well. "
3858 "Please limit to --reltime or --deltatime.\n");
3862 if ((itrace_synth_opts
.callchain
|| itrace_synth_opts
.add_callchain
) &&
3863 itrace_synth_opts
.callchain_sz
> scripting_max_stack
)
3864 scripting_max_stack
= itrace_synth_opts
.callchain_sz
;
3866 /* make sure PERF_EXEC_PATH is set for scripts */
3867 set_argv_exec_path(get_argv_exec_path());
3869 if (argc
&& !script_name
&& !rec_script_path
&& !rep_script_path
) {
3874 rec_script_path
= get_script_path(argv
[0], RECORD_SUFFIX
);
3875 rep_script_path
= get_script_path(argv
[0], REPORT_SUFFIX
);
3877 if (!rec_script_path
&& !rep_script_path
) {
3878 script_name
= find_script(argv
[0]);
3884 usage_with_options_msg(script_usage
, options
,
3885 "Couldn't find script `%s'\n\n See perf"
3886 " script -l for available scripts.\n", argv
[0]);
3889 if (is_top_script(argv
[0])) {
3890 rep_args
= argc
- 1;
3894 rep_args
= has_required_arg(rep_script_path
);
3895 rec_args
= (argc
- 1) - rep_args
;
3897 usage_with_options_msg(script_usage
, options
,
3898 "`%s' script requires options."
3899 "\n\n See perf script -l for available "
3900 "scripts and options.\n", argv
[0]);
3904 if (pipe(live_pipe
) < 0) {
3905 perror("failed to create pipe");
3911 perror("failed to fork");
3918 dup2(live_pipe
[1], 1);
3919 close(live_pipe
[0]);
3921 if (is_top_script(argv
[0])) {
3923 } else if (!system_wide
) {
3924 if (have_cmd(argc
- rep_args
, &argv
[rep_args
]) != 0) {
3930 __argv
= malloc((argc
+ 6) * sizeof(const char *));
3932 pr_err("malloc failed\n");
3937 __argv
[j
++] = "/bin/sh";
3938 __argv
[j
++] = rec_script_path
;
3944 for (i
= rep_args
+ 1; i
< argc
; i
++)
3945 __argv
[j
++] = argv
[i
];
3948 execvp("/bin/sh", (char **)__argv
);
3953 dup2(live_pipe
[0], 0);
3954 close(live_pipe
[1]);
3956 __argv
= malloc((argc
+ 4) * sizeof(const char *));
3958 pr_err("malloc failed\n");
3964 __argv
[j
++] = "/bin/sh";
3965 __argv
[j
++] = rep_script_path
;
3966 for (i
= 1; i
< rep_args
+ 1; i
++)
3967 __argv
[j
++] = argv
[i
];
3972 execvp("/bin/sh", (char **)__argv
);
3977 if (rec_script_path
)
3978 script_path
= rec_script_path
;
3979 if (rep_script_path
)
3980 script_path
= rep_script_path
;
3985 if (!rec_script_path
)
3986 system_wide
= false;
3987 else if (!system_wide
) {
3988 if (have_cmd(argc
- 1, &argv
[1]) != 0) {
3994 __argv
= malloc((argc
+ 2) * sizeof(const char *));
3996 pr_err("malloc failed\n");
4001 __argv
[j
++] = "/bin/sh";
4002 __argv
[j
++] = script_path
;
4005 for (i
= 2; i
< argc
; i
++)
4006 __argv
[j
++] = argv
[i
];
4009 execvp("/bin/sh", (char **)__argv
);
4014 if (dlfilter_file
) {
4015 dlfilter
= dlfilter__new(dlfilter_file
, dlargc
, dlargv
);
4025 session
= perf_session__new(&data
, &script
.tool
);
4026 if (IS_ERR(session
))
4027 return PTR_ERR(session
);
4029 if (header
|| header_only
) {
4030 script
.tool
.show_feat_hdr
= SHOW_FEAT_HEADER
;
4031 perf_session__fprintf_info(session
, stdout
, show_full_info
);
4036 script
.tool
.show_feat_hdr
= SHOW_FEAT_HEADER_FULL_INFO
;
4038 if (symbol__init(&session
->header
.env
) < 0)
4042 if (data
.is_pipe
) { /* Assume pipe_mode indicates native_arch */
4044 } else if (session
->header
.env
.arch
) {
4045 if (!strcmp(uts
.machine
, session
->header
.env
.arch
))
4047 else if (!strcmp(uts
.machine
, "x86_64") &&
4048 !strcmp(session
->header
.env
.arch
, "i386"))
4052 script
.session
= session
;
4053 script__setup_sample_type(&script
);
4055 if ((output
[PERF_TYPE_HARDWARE
].fields
& PERF_OUTPUT_CALLINDENT
) ||
4056 symbol_conf
.graph_function
)
4057 itrace_synth_opts
.thread_stack
= true;
4059 session
->itrace_synth_opts
= &itrace_synth_opts
;
4062 err
= perf_session__cpu_bitmap(session
, cpu_list
, cpu_bitmap
);
4065 itrace_synth_opts
.cpu_bitmap
= cpu_bitmap
;
4069 symbol_conf
.use_callchain
= true;
4071 symbol_conf
.use_callchain
= false;
4073 if (session
->tevent
.pevent
&&
4074 tep_set_function_resolver(session
->tevent
.pevent
,
4075 machine__resolve_kernel_addr
,
4076 &session
->machines
.host
) < 0) {
4077 pr_err("%s: failed to set libtraceevent function resolver\n", __func__
);
4082 if (generate_script_lang
) {
4083 struct stat perf_stat
;
4086 if (output_set_by_user()) {
4088 "custom fields not supported for generated scripts");
4093 input
= open(data
.path
, O_RDONLY
); /* input_name */
4096 perror("failed to open file");
4100 err
= fstat(input
, &perf_stat
);
4102 perror("failed to stat file");
4106 if (!perf_stat
.st_size
) {
4107 fprintf(stderr
, "zero-sized file, nothing to do!\n");
4111 scripting_ops
= script_spec__lookup(generate_script_lang
);
4112 if (!scripting_ops
) {
4113 fprintf(stderr
, "invalid language specifier");
4118 err
= scripting_ops
->generate_script(session
->tevent
.pevent
,
4123 err
= dlfilter__start(dlfilter
, session
);
4128 err
= scripting_ops
->start_script(script_name
, argc
, argv
, session
);
4131 pr_debug("perf script started with script %s\n\n", script_name
);
4132 script_started
= true;
4136 err
= perf_session__check_output_opt(session
);
4140 if (script
.time_str
) {
4141 err
= perf_time__parse_for_ranges_reltime(script
.time_str
, session
,
4142 &script
.ptime_range
,
4149 itrace_synth_opts__set_time_range(&itrace_synth_opts
,
4154 err
= evswitch__init(&script
.evswitch
, session
->evlist
, stderr
);
4158 if (zstd_init(&(session
->zstd_data
), 0) < 0)
4159 pr_warning("Decompression initialization failed. Reported data may be incomplete.\n");
4161 err
= __cmd_script(&script
);
4166 if (script
.ptime_range
) {
4167 itrace_synth_opts__clear_time_range(&itrace_synth_opts
);
4168 zfree(&script
.ptime_range
);
4171 zstd_fini(&(session
->zstd_data
));
4172 evlist__free_stats(session
->evlist
);
4173 perf_session__delete(session
);
4174 perf_script__exit(&script
);
4177 cleanup_scripting();
4178 dlfilter__cleanup(dlfilter
);