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