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