1 #include "builtin.h" 2 3 #include "perf.h" 4 #include "util/cache.h" 5 #include "util/debug.h" 6 #include <subcmd/exec-cmd.h> 7 #include "util/header.h" 8 #include <subcmd/parse-options.h> 9 #include "util/perf_regs.h" 10 #include "util/session.h" 11 #include "util/tool.h" 12 #include "util/symbol.h" 13 #include "util/thread.h" 14 #include "util/trace-event.h" 15 #include "util/util.h" 16 #include "util/evlist.h" 17 #include "util/evsel.h" 18 #include "util/sort.h" 19 #include "util/data.h" 20 #include "util/auxtrace.h" 21 #include "util/cpumap.h" 22 #include "util/thread_map.h" 23 #include "util/stat.h" 24 #include <linux/bitmap.h> 25 #include "asm/bug.h" 26 #include "util/mem-events.h" 27 28 static char const *script_name; 29 static char const *generate_script_lang; 30 static bool debug_mode; 31 static u64 last_timestamp; 32 static u64 nr_unordered; 33 static bool no_callchain; 34 static bool latency_format; 35 static bool system_wide; 36 static bool print_flags; 37 static bool nanosecs; 38 static const char *cpu_list; 39 static DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS); 40 static struct perf_stat_config stat_config; 41 42 unsigned int scripting_max_stack = PERF_MAX_STACK_DEPTH; 43 44 enum perf_output_field { 45 PERF_OUTPUT_COMM = 1U << 0, 46 PERF_OUTPUT_TID = 1U << 1, 47 PERF_OUTPUT_PID = 1U << 2, 48 PERF_OUTPUT_TIME = 1U << 3, 49 PERF_OUTPUT_CPU = 1U << 4, 50 PERF_OUTPUT_EVNAME = 1U << 5, 51 PERF_OUTPUT_TRACE = 1U << 6, 52 PERF_OUTPUT_IP = 1U << 7, 53 PERF_OUTPUT_SYM = 1U << 8, 54 PERF_OUTPUT_DSO = 1U << 9, 55 PERF_OUTPUT_ADDR = 1U << 10, 56 PERF_OUTPUT_SYMOFFSET = 1U << 11, 57 PERF_OUTPUT_SRCLINE = 1U << 12, 58 PERF_OUTPUT_PERIOD = 1U << 13, 59 PERF_OUTPUT_IREGS = 1U << 14, 60 PERF_OUTPUT_BRSTACK = 1U << 15, 61 PERF_OUTPUT_BRSTACKSYM = 1U << 16, 62 PERF_OUTPUT_DATA_SRC = 1U << 17, 63 PERF_OUTPUT_WEIGHT = 1U << 18, 64 PERF_OUTPUT_BPF_OUTPUT = 1U << 19, 65 }; 66 67 struct output_option { 68 const char *str; 69 enum perf_output_field field; 70 } all_output_options[] = { 71 {.str = "comm", .field = PERF_OUTPUT_COMM}, 72 {.str = "tid", .field = PERF_OUTPUT_TID}, 73 {.str = "pid", .field = PERF_OUTPUT_PID}, 74 {.str = "time", .field = PERF_OUTPUT_TIME}, 75 {.str = "cpu", .field = PERF_OUTPUT_CPU}, 76 {.str = "event", .field = PERF_OUTPUT_EVNAME}, 77 {.str = "trace", .field = PERF_OUTPUT_TRACE}, 78 {.str = "ip", .field = PERF_OUTPUT_IP}, 79 {.str = "sym", .field = PERF_OUTPUT_SYM}, 80 {.str = "dso", .field = PERF_OUTPUT_DSO}, 81 {.str = "addr", .field = PERF_OUTPUT_ADDR}, 82 {.str = "symoff", .field = PERF_OUTPUT_SYMOFFSET}, 83 {.str = "srcline", .field = PERF_OUTPUT_SRCLINE}, 84 {.str = "period", .field = PERF_OUTPUT_PERIOD}, 85 {.str = "iregs", .field = PERF_OUTPUT_IREGS}, 86 {.str = "brstack", .field = PERF_OUTPUT_BRSTACK}, 87 {.str = "brstacksym", .field = PERF_OUTPUT_BRSTACKSYM}, 88 {.str = "data_src", .field = PERF_OUTPUT_DATA_SRC}, 89 {.str = "weight", .field = PERF_OUTPUT_WEIGHT}, 90 {.str = "bpf-output", .field = PERF_OUTPUT_BPF_OUTPUT}, 91 }; 92 93 /* default set to maintain compatibility with current format */ 94 static struct { 95 bool user_set; 96 bool wildcard_set; 97 unsigned int print_ip_opts; 98 u64 fields; 99 u64 invalid_fields; 100 } output[PERF_TYPE_MAX] = { 101 102 [PERF_TYPE_HARDWARE] = { 103 .user_set = false, 104 105 .fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID | 106 PERF_OUTPUT_CPU | PERF_OUTPUT_TIME | 107 PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP | 108 PERF_OUTPUT_SYM | PERF_OUTPUT_DSO | 109 PERF_OUTPUT_PERIOD, 110 111 .invalid_fields = PERF_OUTPUT_TRACE | PERF_OUTPUT_BPF_OUTPUT, 112 }, 113 114 [PERF_TYPE_SOFTWARE] = { 115 .user_set = false, 116 117 .fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID | 118 PERF_OUTPUT_CPU | PERF_OUTPUT_TIME | 119 PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP | 120 PERF_OUTPUT_SYM | PERF_OUTPUT_DSO | 121 PERF_OUTPUT_PERIOD | PERF_OUTPUT_BPF_OUTPUT, 122 123 .invalid_fields = PERF_OUTPUT_TRACE, 124 }, 125 126 [PERF_TYPE_TRACEPOINT] = { 127 .user_set = false, 128 129 .fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID | 130 PERF_OUTPUT_CPU | PERF_OUTPUT_TIME | 131 PERF_OUTPUT_EVNAME | PERF_OUTPUT_TRACE 132 }, 133 134 [PERF_TYPE_RAW] = { 135 .user_set = false, 136 137 .fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID | 138 PERF_OUTPUT_CPU | PERF_OUTPUT_TIME | 139 PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP | 140 PERF_OUTPUT_SYM | PERF_OUTPUT_DSO | 141 PERF_OUTPUT_PERIOD | PERF_OUTPUT_ADDR | 142 PERF_OUTPUT_DATA_SRC | PERF_OUTPUT_WEIGHT, 143 144 .invalid_fields = PERF_OUTPUT_TRACE | PERF_OUTPUT_BPF_OUTPUT, 145 }, 146 147 [PERF_TYPE_BREAKPOINT] = { 148 .user_set = false, 149 150 .fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID | 151 PERF_OUTPUT_CPU | PERF_OUTPUT_TIME | 152 PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP | 153 PERF_OUTPUT_SYM | PERF_OUTPUT_DSO | 154 PERF_OUTPUT_PERIOD, 155 156 .invalid_fields = PERF_OUTPUT_TRACE | PERF_OUTPUT_BPF_OUTPUT, 157 }, 158 }; 159 160 static bool output_set_by_user(void) 161 { 162 int j; 163 for (j = 0; j < PERF_TYPE_MAX; ++j) { 164 if (output[j].user_set) 165 return true; 166 } 167 return false; 168 } 169 170 static const char *output_field2str(enum perf_output_field field) 171 { 172 int i, imax = ARRAY_SIZE(all_output_options); 173 const char *str = ""; 174 175 for (i = 0; i < imax; ++i) { 176 if (all_output_options[i].field == field) { 177 str = all_output_options[i].str; 178 break; 179 } 180 } 181 return str; 182 } 183 184 #define PRINT_FIELD(x) (output[attr->type].fields & PERF_OUTPUT_##x) 185 186 static int perf_evsel__do_check_stype(struct perf_evsel *evsel, 187 u64 sample_type, const char *sample_msg, 188 enum perf_output_field field, 189 bool allow_user_set) 190 { 191 struct perf_event_attr *attr = &evsel->attr; 192 int type = attr->type; 193 const char *evname; 194 195 if (attr->sample_type & sample_type) 196 return 0; 197 198 if (output[type].user_set) { 199 if (allow_user_set) 200 return 0; 201 evname = perf_evsel__name(evsel); 202 pr_err("Samples for '%s' event do not have %s attribute set. " 203 "Cannot print '%s' field.\n", 204 evname, sample_msg, output_field2str(field)); 205 return -1; 206 } 207 208 /* user did not ask for it explicitly so remove from the default list */ 209 output[type].fields &= ~field; 210 evname = perf_evsel__name(evsel); 211 pr_debug("Samples for '%s' event do not have %s attribute set. " 212 "Skipping '%s' field.\n", 213 evname, sample_msg, output_field2str(field)); 214 215 return 0; 216 } 217 218 static int perf_evsel__check_stype(struct perf_evsel *evsel, 219 u64 sample_type, const char *sample_msg, 220 enum perf_output_field field) 221 { 222 return perf_evsel__do_check_stype(evsel, sample_type, sample_msg, field, 223 false); 224 } 225 226 static int perf_evsel__check_attr(struct perf_evsel *evsel, 227 struct perf_session *session) 228 { 229 struct perf_event_attr *attr = &evsel->attr; 230 bool allow_user_set; 231 232 if (perf_header__has_feat(&session->header, HEADER_STAT)) 233 return 0; 234 235 allow_user_set = perf_header__has_feat(&session->header, 236 HEADER_AUXTRACE); 237 238 if (PRINT_FIELD(TRACE) && 239 !perf_session__has_traces(session, "record -R")) 240 return -EINVAL; 241 242 if (PRINT_FIELD(IP)) { 243 if (perf_evsel__check_stype(evsel, PERF_SAMPLE_IP, "IP", 244 PERF_OUTPUT_IP)) 245 return -EINVAL; 246 } 247 248 if (PRINT_FIELD(ADDR) && 249 perf_evsel__do_check_stype(evsel, PERF_SAMPLE_ADDR, "ADDR", 250 PERF_OUTPUT_ADDR, allow_user_set)) 251 return -EINVAL; 252 253 if (PRINT_FIELD(DATA_SRC) && 254 perf_evsel__check_stype(evsel, PERF_SAMPLE_DATA_SRC, "DATA_SRC", 255 PERF_OUTPUT_DATA_SRC)) 256 return -EINVAL; 257 258 if (PRINT_FIELD(WEIGHT) && 259 perf_evsel__check_stype(evsel, PERF_SAMPLE_WEIGHT, "WEIGHT", 260 PERF_OUTPUT_WEIGHT)) 261 return -EINVAL; 262 263 if (PRINT_FIELD(SYM) && !PRINT_FIELD(IP) && !PRINT_FIELD(ADDR)) { 264 pr_err("Display of symbols requested but neither sample IP nor " 265 "sample address\nis selected. Hence, no addresses to convert " 266 "to symbols.\n"); 267 return -EINVAL; 268 } 269 if (PRINT_FIELD(SYMOFFSET) && !PRINT_FIELD(SYM)) { 270 pr_err("Display of offsets requested but symbol is not" 271 "selected.\n"); 272 return -EINVAL; 273 } 274 if (PRINT_FIELD(DSO) && !PRINT_FIELD(IP) && !PRINT_FIELD(ADDR)) { 275 pr_err("Display of DSO requested but neither sample IP nor " 276 "sample address\nis selected. Hence, no addresses to convert " 277 "to DSO.\n"); 278 return -EINVAL; 279 } 280 if (PRINT_FIELD(SRCLINE) && !PRINT_FIELD(IP)) { 281 pr_err("Display of source line number requested but sample IP is not\n" 282 "selected. Hence, no address to lookup the source line number.\n"); 283 return -EINVAL; 284 } 285 286 if ((PRINT_FIELD(PID) || PRINT_FIELD(TID)) && 287 perf_evsel__check_stype(evsel, PERF_SAMPLE_TID, "TID", 288 PERF_OUTPUT_TID|PERF_OUTPUT_PID)) 289 return -EINVAL; 290 291 if (PRINT_FIELD(TIME) && 292 perf_evsel__check_stype(evsel, PERF_SAMPLE_TIME, "TIME", 293 PERF_OUTPUT_TIME)) 294 return -EINVAL; 295 296 if (PRINT_FIELD(CPU) && 297 perf_evsel__do_check_stype(evsel, PERF_SAMPLE_CPU, "CPU", 298 PERF_OUTPUT_CPU, allow_user_set)) 299 return -EINVAL; 300 301 if (PRINT_FIELD(PERIOD) && 302 perf_evsel__check_stype(evsel, PERF_SAMPLE_PERIOD, "PERIOD", 303 PERF_OUTPUT_PERIOD)) 304 return -EINVAL; 305 306 if (PRINT_FIELD(IREGS) && 307 perf_evsel__check_stype(evsel, PERF_SAMPLE_REGS_INTR, "IREGS", 308 PERF_OUTPUT_IREGS)) 309 return -EINVAL; 310 311 return 0; 312 } 313 314 static void set_print_ip_opts(struct perf_event_attr *attr) 315 { 316 unsigned int type = attr->type; 317 318 output[type].print_ip_opts = 0; 319 if (PRINT_FIELD(IP)) 320 output[type].print_ip_opts |= PRINT_IP_OPT_IP; 321 322 if (PRINT_FIELD(SYM)) 323 output[type].print_ip_opts |= PRINT_IP_OPT_SYM; 324 325 if (PRINT_FIELD(DSO)) 326 output[type].print_ip_opts |= PRINT_IP_OPT_DSO; 327 328 if (PRINT_FIELD(SYMOFFSET)) 329 output[type].print_ip_opts |= PRINT_IP_OPT_SYMOFFSET; 330 331 if (PRINT_FIELD(SRCLINE)) 332 output[type].print_ip_opts |= PRINT_IP_OPT_SRCLINE; 333 } 334 335 /* 336 * verify all user requested events exist and the samples 337 * have the expected data 338 */ 339 static int perf_session__check_output_opt(struct perf_session *session) 340 { 341 int j; 342 struct perf_evsel *evsel; 343 344 for (j = 0; j < PERF_TYPE_MAX; ++j) { 345 evsel = perf_session__find_first_evtype(session, j); 346 347 /* 348 * even if fields is set to 0 (ie., show nothing) event must 349 * exist if user explicitly includes it on the command line 350 */ 351 if (!evsel && output[j].user_set && !output[j].wildcard_set) { 352 pr_err("%s events do not exist. " 353 "Remove corresponding -f option to proceed.\n", 354 event_type(j)); 355 return -1; 356 } 357 358 if (evsel && output[j].fields && 359 perf_evsel__check_attr(evsel, session)) 360 return -1; 361 362 if (evsel == NULL) 363 continue; 364 365 set_print_ip_opts(&evsel->attr); 366 } 367 368 if (!no_callchain) { 369 bool use_callchain = false; 370 371 evlist__for_each(session->evlist, evsel) { 372 if (evsel->attr.sample_type & PERF_SAMPLE_CALLCHAIN) { 373 use_callchain = true; 374 break; 375 } 376 } 377 if (!use_callchain) 378 symbol_conf.use_callchain = false; 379 } 380 381 /* 382 * set default for tracepoints to print symbols only 383 * if callchains are present 384 */ 385 if (symbol_conf.use_callchain && 386 !output[PERF_TYPE_TRACEPOINT].user_set) { 387 struct perf_event_attr *attr; 388 389 j = PERF_TYPE_TRACEPOINT; 390 evsel = perf_session__find_first_evtype(session, j); 391 if (evsel == NULL) 392 goto out; 393 394 attr = &evsel->attr; 395 396 if (attr->sample_type & PERF_SAMPLE_CALLCHAIN) { 397 output[j].fields |= PERF_OUTPUT_IP; 398 output[j].fields |= PERF_OUTPUT_SYM; 399 output[j].fields |= PERF_OUTPUT_DSO; 400 set_print_ip_opts(attr); 401 } 402 } 403 404 out: 405 return 0; 406 } 407 408 static void print_sample_iregs(struct perf_sample *sample, 409 struct perf_event_attr *attr) 410 { 411 struct regs_dump *regs = &sample->intr_regs; 412 uint64_t mask = attr->sample_regs_intr; 413 unsigned i = 0, r; 414 415 if (!regs) 416 return; 417 418 for_each_set_bit(r, (unsigned long *) &mask, sizeof(mask) * 8) { 419 u64 val = regs->regs[i++]; 420 printf("%5s:0x%"PRIx64" ", perf_reg_name(r), val); 421 } 422 } 423 424 static void print_sample_start(struct perf_sample *sample, 425 struct thread *thread, 426 struct perf_evsel *evsel) 427 { 428 struct perf_event_attr *attr = &evsel->attr; 429 unsigned long secs; 430 unsigned long usecs; 431 unsigned long long nsecs; 432 433 if (PRINT_FIELD(COMM)) { 434 if (latency_format) 435 printf("%8.8s ", thread__comm_str(thread)); 436 else if (PRINT_FIELD(IP) && symbol_conf.use_callchain) 437 printf("%s ", thread__comm_str(thread)); 438 else 439 printf("%16s ", thread__comm_str(thread)); 440 } 441 442 if (PRINT_FIELD(PID) && PRINT_FIELD(TID)) 443 printf("%5d/%-5d ", sample->pid, sample->tid); 444 else if (PRINT_FIELD(PID)) 445 printf("%5d ", sample->pid); 446 else if (PRINT_FIELD(TID)) 447 printf("%5d ", sample->tid); 448 449 if (PRINT_FIELD(CPU)) { 450 if (latency_format) 451 printf("%3d ", sample->cpu); 452 else 453 printf("[%03d] ", sample->cpu); 454 } 455 456 if (PRINT_FIELD(TIME)) { 457 nsecs = sample->time; 458 secs = nsecs / NSECS_PER_SEC; 459 nsecs -= secs * NSECS_PER_SEC; 460 usecs = nsecs / NSECS_PER_USEC; 461 if (nanosecs) 462 printf("%5lu.%09llu: ", secs, nsecs); 463 else 464 printf("%5lu.%06lu: ", secs, usecs); 465 } 466 } 467 468 static inline char 469 mispred_str(struct branch_entry *br) 470 { 471 if (!(br->flags.mispred || br->flags.predicted)) 472 return '-'; 473 474 return br->flags.predicted ? 'P' : 'M'; 475 } 476 477 static void print_sample_brstack(struct perf_sample *sample) 478 { 479 struct branch_stack *br = sample->branch_stack; 480 u64 i; 481 482 if (!(br && br->nr)) 483 return; 484 485 for (i = 0; i < br->nr; i++) { 486 printf(" 0x%"PRIx64"/0x%"PRIx64"/%c/%c/%c/%d ", 487 br->entries[i].from, 488 br->entries[i].to, 489 mispred_str( br->entries + i), 490 br->entries[i].flags.in_tx? 'X' : '-', 491 br->entries[i].flags.abort? 'A' : '-', 492 br->entries[i].flags.cycles); 493 } 494 } 495 496 static void print_sample_brstacksym(struct perf_sample *sample, 497 struct thread *thread) 498 { 499 struct branch_stack *br = sample->branch_stack; 500 struct addr_location alf, alt; 501 u64 i, from, to; 502 503 if (!(br && br->nr)) 504 return; 505 506 for (i = 0; i < br->nr; i++) { 507 508 memset(&alf, 0, sizeof(alf)); 509 memset(&alt, 0, sizeof(alt)); 510 from = br->entries[i].from; 511 to = br->entries[i].to; 512 513 thread__find_addr_map(thread, sample->cpumode, MAP__FUNCTION, from, &alf); 514 if (alf.map) 515 alf.sym = map__find_symbol(alf.map, alf.addr, NULL); 516 517 thread__find_addr_map(thread, sample->cpumode, MAP__FUNCTION, to, &alt); 518 if (alt.map) 519 alt.sym = map__find_symbol(alt.map, alt.addr, NULL); 520 521 symbol__fprintf_symname_offs(alf.sym, &alf, stdout); 522 putchar('/'); 523 symbol__fprintf_symname_offs(alt.sym, &alt, stdout); 524 printf("/%c/%c/%c/%d ", 525 mispred_str( br->entries + i), 526 br->entries[i].flags.in_tx? 'X' : '-', 527 br->entries[i].flags.abort? 'A' : '-', 528 br->entries[i].flags.cycles); 529 } 530 } 531 532 533 static void print_sample_addr(struct perf_sample *sample, 534 struct thread *thread, 535 struct perf_event_attr *attr) 536 { 537 struct addr_location al; 538 539 printf("%16" PRIx64, sample->addr); 540 541 if (!sample_addr_correlates_sym(attr)) 542 return; 543 544 thread__resolve(thread, &al, sample); 545 546 if (PRINT_FIELD(SYM)) { 547 printf(" "); 548 if (PRINT_FIELD(SYMOFFSET)) 549 symbol__fprintf_symname_offs(al.sym, &al, stdout); 550 else 551 symbol__fprintf_symname(al.sym, stdout); 552 } 553 554 if (PRINT_FIELD(DSO)) { 555 printf(" ("); 556 map__fprintf_dsoname(al.map, stdout); 557 printf(")"); 558 } 559 } 560 561 static void print_sample_bts(struct perf_sample *sample, 562 struct perf_evsel *evsel, 563 struct thread *thread, 564 struct addr_location *al) 565 { 566 struct perf_event_attr *attr = &evsel->attr; 567 bool print_srcline_last = false; 568 569 /* print branch_from information */ 570 if (PRINT_FIELD(IP)) { 571 unsigned int print_opts = output[attr->type].print_ip_opts; 572 573 if (symbol_conf.use_callchain && sample->callchain) { 574 printf("\n"); 575 } else { 576 printf(" "); 577 if (print_opts & PRINT_IP_OPT_SRCLINE) { 578 print_srcline_last = true; 579 print_opts &= ~PRINT_IP_OPT_SRCLINE; 580 } 581 } 582 perf_evsel__print_ip(evsel, sample, al, print_opts, 583 scripting_max_stack); 584 } 585 586 /* print branch_to information */ 587 if (PRINT_FIELD(ADDR) || 588 ((evsel->attr.sample_type & PERF_SAMPLE_ADDR) && 589 !output[attr->type].user_set)) { 590 printf(" => "); 591 print_sample_addr(sample, thread, attr); 592 } 593 594 if (print_srcline_last) 595 map__fprintf_srcline(al->map, al->addr, "\n ", stdout); 596 597 printf("\n"); 598 } 599 600 static void print_sample_flags(u32 flags) 601 { 602 const char *chars = PERF_IP_FLAG_CHARS; 603 const int n = strlen(PERF_IP_FLAG_CHARS); 604 char str[33]; 605 int i, pos = 0; 606 607 for (i = 0; i < n; i++, flags >>= 1) { 608 if (flags & 1) 609 str[pos++] = chars[i]; 610 } 611 for (; i < 32; i++, flags >>= 1) { 612 if (flags & 1) 613 str[pos++] = '?'; 614 } 615 str[pos] = 0; 616 printf(" %-4s ", str); 617 } 618 619 struct printer_data { 620 int line_no; 621 bool hit_nul; 622 bool is_printable; 623 }; 624 625 static void 626 print_sample_bpf_output_printer(enum binary_printer_ops op, 627 unsigned int val, 628 void *extra) 629 { 630 unsigned char ch = (unsigned char)val; 631 struct printer_data *printer_data = extra; 632 633 switch (op) { 634 case BINARY_PRINT_DATA_BEGIN: 635 printf("\n"); 636 break; 637 case BINARY_PRINT_LINE_BEGIN: 638 printf("%17s", !printer_data->line_no ? "BPF output:" : 639 " "); 640 break; 641 case BINARY_PRINT_ADDR: 642 printf(" %04x:", val); 643 break; 644 case BINARY_PRINT_NUM_DATA: 645 printf(" %02x", val); 646 break; 647 case BINARY_PRINT_NUM_PAD: 648 printf(" "); 649 break; 650 case BINARY_PRINT_SEP: 651 printf(" "); 652 break; 653 case BINARY_PRINT_CHAR_DATA: 654 if (printer_data->hit_nul && ch) 655 printer_data->is_printable = false; 656 657 if (!isprint(ch)) { 658 printf("%c", '.'); 659 660 if (!printer_data->is_printable) 661 break; 662 663 if (ch == '\0') 664 printer_data->hit_nul = true; 665 else 666 printer_data->is_printable = false; 667 } else { 668 printf("%c", ch); 669 } 670 break; 671 case BINARY_PRINT_CHAR_PAD: 672 printf(" "); 673 break; 674 case BINARY_PRINT_LINE_END: 675 printf("\n"); 676 printer_data->line_no++; 677 break; 678 case BINARY_PRINT_DATA_END: 679 default: 680 break; 681 } 682 } 683 684 static void print_sample_bpf_output(struct perf_sample *sample) 685 { 686 unsigned int nr_bytes = sample->raw_size; 687 struct printer_data printer_data = {0, false, true}; 688 689 print_binary(sample->raw_data, nr_bytes, 8, 690 print_sample_bpf_output_printer, &printer_data); 691 692 if (printer_data.is_printable && printer_data.hit_nul) 693 printf("%17s \"%s\"\n", "BPF string:", 694 (char *)(sample->raw_data)); 695 } 696 697 struct perf_script { 698 struct perf_tool tool; 699 struct perf_session *session; 700 bool show_task_events; 701 bool show_mmap_events; 702 bool show_switch_events; 703 bool allocated; 704 struct cpu_map *cpus; 705 struct thread_map *threads; 706 int name_width; 707 }; 708 709 static int perf_evlist__max_name_len(struct perf_evlist *evlist) 710 { 711 struct perf_evsel *evsel; 712 int max = 0; 713 714 evlist__for_each(evlist, evsel) { 715 int len = strlen(perf_evsel__name(evsel)); 716 717 max = MAX(len, max); 718 } 719 720 return max; 721 } 722 723 static size_t data_src__printf(u64 data_src) 724 { 725 struct mem_info mi = { .data_src.val = data_src }; 726 char decode[100]; 727 char out[100]; 728 static int maxlen; 729 int len; 730 731 perf_script__meminfo_scnprintf(decode, 100, &mi); 732 733 len = scnprintf(out, 100, "%16" PRIx64 " %s", data_src, decode); 734 if (maxlen < len) 735 maxlen = len; 736 737 return printf("%-*s", maxlen, out); 738 } 739 740 static void process_event(struct perf_script *script, 741 struct perf_sample *sample, struct perf_evsel *evsel, 742 struct addr_location *al) 743 { 744 struct thread *thread = al->thread; 745 struct perf_event_attr *attr = &evsel->attr; 746 747 if (output[attr->type].fields == 0) 748 return; 749 750 print_sample_start(sample, thread, evsel); 751 752 if (PRINT_FIELD(PERIOD)) 753 printf("%10" PRIu64 " ", sample->period); 754 755 if (PRINT_FIELD(EVNAME)) { 756 const char *evname = perf_evsel__name(evsel); 757 758 if (!script->name_width) 759 script->name_width = perf_evlist__max_name_len(script->session->evlist); 760 761 printf("%*s: ", script->name_width, 762 evname ? evname : "[unknown]"); 763 } 764 765 if (print_flags) 766 print_sample_flags(sample->flags); 767 768 if (is_bts_event(attr)) { 769 print_sample_bts(sample, evsel, thread, al); 770 return; 771 } 772 773 if (PRINT_FIELD(TRACE)) 774 event_format__print(evsel->tp_format, sample->cpu, 775 sample->raw_data, sample->raw_size); 776 if (PRINT_FIELD(ADDR)) 777 print_sample_addr(sample, thread, attr); 778 779 if (PRINT_FIELD(DATA_SRC)) 780 data_src__printf(sample->data_src); 781 782 if (PRINT_FIELD(WEIGHT)) 783 printf("%16" PRIu64, sample->weight); 784 785 if (PRINT_FIELD(IP)) { 786 if (!symbol_conf.use_callchain) 787 printf(" "); 788 else 789 printf("\n"); 790 791 perf_evsel__print_ip(evsel, sample, al, 792 output[attr->type].print_ip_opts, 793 scripting_max_stack); 794 } 795 796 if (PRINT_FIELD(IREGS)) 797 print_sample_iregs(sample, attr); 798 799 if (PRINT_FIELD(BRSTACK)) 800 print_sample_brstack(sample); 801 else if (PRINT_FIELD(BRSTACKSYM)) 802 print_sample_brstacksym(sample, thread); 803 804 if (perf_evsel__is_bpf_output(evsel) && PRINT_FIELD(BPF_OUTPUT)) 805 print_sample_bpf_output(sample); 806 807 printf("\n"); 808 } 809 810 static struct scripting_ops *scripting_ops; 811 812 static void __process_stat(struct perf_evsel *counter, u64 tstamp) 813 { 814 int nthreads = thread_map__nr(counter->threads); 815 int ncpus = perf_evsel__nr_cpus(counter); 816 int cpu, thread; 817 static int header_printed; 818 819 if (counter->system_wide) 820 nthreads = 1; 821 822 if (!header_printed) { 823 printf("%3s %8s %15s %15s %15s %15s %s\n", 824 "CPU", "THREAD", "VAL", "ENA", "RUN", "TIME", "EVENT"); 825 header_printed = 1; 826 } 827 828 for (thread = 0; thread < nthreads; thread++) { 829 for (cpu = 0; cpu < ncpus; cpu++) { 830 struct perf_counts_values *counts; 831 832 counts = perf_counts(counter->counts, cpu, thread); 833 834 printf("%3d %8d %15" PRIu64 " %15" PRIu64 " %15" PRIu64 " %15" PRIu64 " %s\n", 835 counter->cpus->map[cpu], 836 thread_map__pid(counter->threads, thread), 837 counts->val, 838 counts->ena, 839 counts->run, 840 tstamp, 841 perf_evsel__name(counter)); 842 } 843 } 844 } 845 846 static void process_stat(struct perf_evsel *counter, u64 tstamp) 847 { 848 if (scripting_ops && scripting_ops->process_stat) 849 scripting_ops->process_stat(&stat_config, counter, tstamp); 850 else 851 __process_stat(counter, tstamp); 852 } 853 854 static void process_stat_interval(u64 tstamp) 855 { 856 if (scripting_ops && scripting_ops->process_stat_interval) 857 scripting_ops->process_stat_interval(tstamp); 858 } 859 860 static void setup_scripting(void) 861 { 862 setup_perl_scripting(); 863 setup_python_scripting(); 864 } 865 866 static int flush_scripting(void) 867 { 868 return scripting_ops ? scripting_ops->flush_script() : 0; 869 } 870 871 static int cleanup_scripting(void) 872 { 873 pr_debug("\nperf script stopped\n"); 874 875 return scripting_ops ? scripting_ops->stop_script() : 0; 876 } 877 878 static int process_sample_event(struct perf_tool *tool, 879 union perf_event *event, 880 struct perf_sample *sample, 881 struct perf_evsel *evsel, 882 struct machine *machine) 883 { 884 struct perf_script *scr = container_of(tool, struct perf_script, tool); 885 struct addr_location al; 886 887 if (debug_mode) { 888 if (sample->time < last_timestamp) { 889 pr_err("Samples misordered, previous: %" PRIu64 890 " this: %" PRIu64 "\n", last_timestamp, 891 sample->time); 892 nr_unordered++; 893 } 894 last_timestamp = sample->time; 895 return 0; 896 } 897 898 if (machine__resolve(machine, &al, sample) < 0) { 899 pr_err("problem processing %d event, skipping it.\n", 900 event->header.type); 901 return -1; 902 } 903 904 if (al.filtered) 905 goto out_put; 906 907 if (cpu_list && !test_bit(sample->cpu, cpu_bitmap)) 908 goto out_put; 909 910 if (scripting_ops) 911 scripting_ops->process_event(event, sample, evsel, &al); 912 else 913 process_event(scr, sample, evsel, &al); 914 915 out_put: 916 addr_location__put(&al); 917 return 0; 918 } 919 920 static int process_attr(struct perf_tool *tool, union perf_event *event, 921 struct perf_evlist **pevlist) 922 { 923 struct perf_script *scr = container_of(tool, struct perf_script, tool); 924 struct perf_evlist *evlist; 925 struct perf_evsel *evsel, *pos; 926 int err; 927 928 err = perf_event__process_attr(tool, event, pevlist); 929 if (err) 930 return err; 931 932 evlist = *pevlist; 933 evsel = perf_evlist__last(*pevlist); 934 935 if (evsel->attr.type >= PERF_TYPE_MAX) 936 return 0; 937 938 evlist__for_each(evlist, pos) { 939 if (pos->attr.type == evsel->attr.type && pos != evsel) 940 return 0; 941 } 942 943 set_print_ip_opts(&evsel->attr); 944 945 if (evsel->attr.sample_type) 946 err = perf_evsel__check_attr(evsel, scr->session); 947 948 return err; 949 } 950 951 static int process_comm_event(struct perf_tool *tool, 952 union perf_event *event, 953 struct perf_sample *sample, 954 struct machine *machine) 955 { 956 struct thread *thread; 957 struct perf_script *script = container_of(tool, struct perf_script, tool); 958 struct perf_session *session = script->session; 959 struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id); 960 int ret = -1; 961 962 thread = machine__findnew_thread(machine, event->comm.pid, event->comm.tid); 963 if (thread == NULL) { 964 pr_debug("problem processing COMM event, skipping it.\n"); 965 return -1; 966 } 967 968 if (perf_event__process_comm(tool, event, sample, machine) < 0) 969 goto out; 970 971 if (!evsel->attr.sample_id_all) { 972 sample->cpu = 0; 973 sample->time = 0; 974 sample->tid = event->comm.tid; 975 sample->pid = event->comm.pid; 976 } 977 print_sample_start(sample, thread, evsel); 978 perf_event__fprintf(event, stdout); 979 ret = 0; 980 out: 981 thread__put(thread); 982 return ret; 983 } 984 985 static int process_fork_event(struct perf_tool *tool, 986 union perf_event *event, 987 struct perf_sample *sample, 988 struct machine *machine) 989 { 990 struct thread *thread; 991 struct perf_script *script = container_of(tool, struct perf_script, tool); 992 struct perf_session *session = script->session; 993 struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id); 994 995 if (perf_event__process_fork(tool, event, sample, machine) < 0) 996 return -1; 997 998 thread = machine__findnew_thread(machine, event->fork.pid, event->fork.tid); 999 if (thread == NULL) { 1000 pr_debug("problem processing FORK event, skipping it.\n"); 1001 return -1; 1002 } 1003 1004 if (!evsel->attr.sample_id_all) { 1005 sample->cpu = 0; 1006 sample->time = event->fork.time; 1007 sample->tid = event->fork.tid; 1008 sample->pid = event->fork.pid; 1009 } 1010 print_sample_start(sample, thread, evsel); 1011 perf_event__fprintf(event, stdout); 1012 thread__put(thread); 1013 1014 return 0; 1015 } 1016 static int process_exit_event(struct perf_tool *tool, 1017 union perf_event *event, 1018 struct perf_sample *sample, 1019 struct machine *machine) 1020 { 1021 int err = 0; 1022 struct thread *thread; 1023 struct perf_script *script = container_of(tool, struct perf_script, tool); 1024 struct perf_session *session = script->session; 1025 struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id); 1026 1027 thread = machine__findnew_thread(machine, event->fork.pid, event->fork.tid); 1028 if (thread == NULL) { 1029 pr_debug("problem processing EXIT event, skipping it.\n"); 1030 return -1; 1031 } 1032 1033 if (!evsel->attr.sample_id_all) { 1034 sample->cpu = 0; 1035 sample->time = 0; 1036 sample->tid = event->fork.tid; 1037 sample->pid = event->fork.pid; 1038 } 1039 print_sample_start(sample, thread, evsel); 1040 perf_event__fprintf(event, stdout); 1041 1042 if (perf_event__process_exit(tool, event, sample, machine) < 0) 1043 err = -1; 1044 1045 thread__put(thread); 1046 return err; 1047 } 1048 1049 static int process_mmap_event(struct perf_tool *tool, 1050 union perf_event *event, 1051 struct perf_sample *sample, 1052 struct machine *machine) 1053 { 1054 struct thread *thread; 1055 struct perf_script *script = container_of(tool, struct perf_script, tool); 1056 struct perf_session *session = script->session; 1057 struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id); 1058 1059 if (perf_event__process_mmap(tool, event, sample, machine) < 0) 1060 return -1; 1061 1062 thread = machine__findnew_thread(machine, event->mmap.pid, event->mmap.tid); 1063 if (thread == NULL) { 1064 pr_debug("problem processing MMAP event, skipping it.\n"); 1065 return -1; 1066 } 1067 1068 if (!evsel->attr.sample_id_all) { 1069 sample->cpu = 0; 1070 sample->time = 0; 1071 sample->tid = event->mmap.tid; 1072 sample->pid = event->mmap.pid; 1073 } 1074 print_sample_start(sample, thread, evsel); 1075 perf_event__fprintf(event, stdout); 1076 thread__put(thread); 1077 return 0; 1078 } 1079 1080 static int process_mmap2_event(struct perf_tool *tool, 1081 union perf_event *event, 1082 struct perf_sample *sample, 1083 struct machine *machine) 1084 { 1085 struct thread *thread; 1086 struct perf_script *script = container_of(tool, struct perf_script, tool); 1087 struct perf_session *session = script->session; 1088 struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id); 1089 1090 if (perf_event__process_mmap2(tool, event, sample, machine) < 0) 1091 return -1; 1092 1093 thread = machine__findnew_thread(machine, event->mmap2.pid, event->mmap2.tid); 1094 if (thread == NULL) { 1095 pr_debug("problem processing MMAP2 event, skipping it.\n"); 1096 return -1; 1097 } 1098 1099 if (!evsel->attr.sample_id_all) { 1100 sample->cpu = 0; 1101 sample->time = 0; 1102 sample->tid = event->mmap2.tid; 1103 sample->pid = event->mmap2.pid; 1104 } 1105 print_sample_start(sample, thread, evsel); 1106 perf_event__fprintf(event, stdout); 1107 thread__put(thread); 1108 return 0; 1109 } 1110 1111 static int process_switch_event(struct perf_tool *tool, 1112 union perf_event *event, 1113 struct perf_sample *sample, 1114 struct machine *machine) 1115 { 1116 struct thread *thread; 1117 struct perf_script *script = container_of(tool, struct perf_script, tool); 1118 struct perf_session *session = script->session; 1119 struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id); 1120 1121 if (perf_event__process_switch(tool, event, sample, machine) < 0) 1122 return -1; 1123 1124 thread = machine__findnew_thread(machine, sample->pid, 1125 sample->tid); 1126 if (thread == NULL) { 1127 pr_debug("problem processing SWITCH event, skipping it.\n"); 1128 return -1; 1129 } 1130 1131 print_sample_start(sample, thread, evsel); 1132 perf_event__fprintf(event, stdout); 1133 thread__put(thread); 1134 return 0; 1135 } 1136 1137 static void sig_handler(int sig __maybe_unused) 1138 { 1139 session_done = 1; 1140 } 1141 1142 static int __cmd_script(struct perf_script *script) 1143 { 1144 int ret; 1145 1146 signal(SIGINT, sig_handler); 1147 1148 /* override event processing functions */ 1149 if (script->show_task_events) { 1150 script->tool.comm = process_comm_event; 1151 script->tool.fork = process_fork_event; 1152 script->tool.exit = process_exit_event; 1153 } 1154 if (script->show_mmap_events) { 1155 script->tool.mmap = process_mmap_event; 1156 script->tool.mmap2 = process_mmap2_event; 1157 } 1158 if (script->show_switch_events) 1159 script->tool.context_switch = process_switch_event; 1160 1161 ret = perf_session__process_events(script->session); 1162 1163 if (debug_mode) 1164 pr_err("Misordered timestamps: %" PRIu64 "\n", nr_unordered); 1165 1166 return ret; 1167 } 1168 1169 struct script_spec { 1170 struct list_head node; 1171 struct scripting_ops *ops; 1172 char spec[0]; 1173 }; 1174 1175 static LIST_HEAD(script_specs); 1176 1177 static struct script_spec *script_spec__new(const char *spec, 1178 struct scripting_ops *ops) 1179 { 1180 struct script_spec *s = malloc(sizeof(*s) + strlen(spec) + 1); 1181 1182 if (s != NULL) { 1183 strcpy(s->spec, spec); 1184 s->ops = ops; 1185 } 1186 1187 return s; 1188 } 1189 1190 static void script_spec__add(struct script_spec *s) 1191 { 1192 list_add_tail(&s->node, &script_specs); 1193 } 1194 1195 static struct script_spec *script_spec__find(const char *spec) 1196 { 1197 struct script_spec *s; 1198 1199 list_for_each_entry(s, &script_specs, node) 1200 if (strcasecmp(s->spec, spec) == 0) 1201 return s; 1202 return NULL; 1203 } 1204 1205 int script_spec_register(const char *spec, struct scripting_ops *ops) 1206 { 1207 struct script_spec *s; 1208 1209 s = script_spec__find(spec); 1210 if (s) 1211 return -1; 1212 1213 s = script_spec__new(spec, ops); 1214 if (!s) 1215 return -1; 1216 else 1217 script_spec__add(s); 1218 1219 return 0; 1220 } 1221 1222 static struct scripting_ops *script_spec__lookup(const char *spec) 1223 { 1224 struct script_spec *s = script_spec__find(spec); 1225 if (!s) 1226 return NULL; 1227 1228 return s->ops; 1229 } 1230 1231 static void list_available_languages(void) 1232 { 1233 struct script_spec *s; 1234 1235 fprintf(stderr, "\n"); 1236 fprintf(stderr, "Scripting language extensions (used in " 1237 "perf script -s [spec:]script.[spec]):\n\n"); 1238 1239 list_for_each_entry(s, &script_specs, node) 1240 fprintf(stderr, " %-42s [%s]\n", s->spec, s->ops->name); 1241 1242 fprintf(stderr, "\n"); 1243 } 1244 1245 static int parse_scriptname(const struct option *opt __maybe_unused, 1246 const char *str, int unset __maybe_unused) 1247 { 1248 char spec[PATH_MAX]; 1249 const char *script, *ext; 1250 int len; 1251 1252 if (strcmp(str, "lang") == 0) { 1253 list_available_languages(); 1254 exit(0); 1255 } 1256 1257 script = strchr(str, ':'); 1258 if (script) { 1259 len = script - str; 1260 if (len >= PATH_MAX) { 1261 fprintf(stderr, "invalid language specifier"); 1262 return -1; 1263 } 1264 strncpy(spec, str, len); 1265 spec[len] = '\0'; 1266 scripting_ops = script_spec__lookup(spec); 1267 if (!scripting_ops) { 1268 fprintf(stderr, "invalid language specifier"); 1269 return -1; 1270 } 1271 script++; 1272 } else { 1273 script = str; 1274 ext = strrchr(script, '.'); 1275 if (!ext) { 1276 fprintf(stderr, "invalid script extension"); 1277 return -1; 1278 } 1279 scripting_ops = script_spec__lookup(++ext); 1280 if (!scripting_ops) { 1281 fprintf(stderr, "invalid script extension"); 1282 return -1; 1283 } 1284 } 1285 1286 script_name = strdup(script); 1287 1288 return 0; 1289 } 1290 1291 static int parse_output_fields(const struct option *opt __maybe_unused, 1292 const char *arg, int unset __maybe_unused) 1293 { 1294 char *tok; 1295 int i, imax = ARRAY_SIZE(all_output_options); 1296 int j; 1297 int rc = 0; 1298 char *str = strdup(arg); 1299 int type = -1; 1300 1301 if (!str) 1302 return -ENOMEM; 1303 1304 /* first word can state for which event type the user is specifying 1305 * the fields. If no type exists, the specified fields apply to all 1306 * event types found in the file minus the invalid fields for a type. 1307 */ 1308 tok = strchr(str, ':'); 1309 if (tok) { 1310 *tok = '\0'; 1311 tok++; 1312 if (!strcmp(str, "hw")) 1313 type = PERF_TYPE_HARDWARE; 1314 else if (!strcmp(str, "sw")) 1315 type = PERF_TYPE_SOFTWARE; 1316 else if (!strcmp(str, "trace")) 1317 type = PERF_TYPE_TRACEPOINT; 1318 else if (!strcmp(str, "raw")) 1319 type = PERF_TYPE_RAW; 1320 else if (!strcmp(str, "break")) 1321 type = PERF_TYPE_BREAKPOINT; 1322 else { 1323 fprintf(stderr, "Invalid event type in field string.\n"); 1324 rc = -EINVAL; 1325 goto out; 1326 } 1327 1328 if (output[type].user_set) 1329 pr_warning("Overriding previous field request for %s events.\n", 1330 event_type(type)); 1331 1332 output[type].fields = 0; 1333 output[type].user_set = true; 1334 output[type].wildcard_set = false; 1335 1336 } else { 1337 tok = str; 1338 if (strlen(str) == 0) { 1339 fprintf(stderr, 1340 "Cannot set fields to 'none' for all event types.\n"); 1341 rc = -EINVAL; 1342 goto out; 1343 } 1344 1345 if (output_set_by_user()) 1346 pr_warning("Overriding previous field request for all events.\n"); 1347 1348 for (j = 0; j < PERF_TYPE_MAX; ++j) { 1349 output[j].fields = 0; 1350 output[j].user_set = true; 1351 output[j].wildcard_set = true; 1352 } 1353 } 1354 1355 for (tok = strtok(tok, ","); tok; tok = strtok(NULL, ",")) { 1356 for (i = 0; i < imax; ++i) { 1357 if (strcmp(tok, all_output_options[i].str) == 0) 1358 break; 1359 } 1360 if (i == imax && strcmp(tok, "flags") == 0) { 1361 print_flags = true; 1362 continue; 1363 } 1364 if (i == imax) { 1365 fprintf(stderr, "Invalid field requested.\n"); 1366 rc = -EINVAL; 1367 goto out; 1368 } 1369 1370 if (type == -1) { 1371 /* add user option to all events types for 1372 * which it is valid 1373 */ 1374 for (j = 0; j < PERF_TYPE_MAX; ++j) { 1375 if (output[j].invalid_fields & all_output_options[i].field) { 1376 pr_warning("\'%s\' not valid for %s events. Ignoring.\n", 1377 all_output_options[i].str, event_type(j)); 1378 } else 1379 output[j].fields |= all_output_options[i].field; 1380 } 1381 } else { 1382 if (output[type].invalid_fields & all_output_options[i].field) { 1383 fprintf(stderr, "\'%s\' not valid for %s events.\n", 1384 all_output_options[i].str, event_type(type)); 1385 1386 rc = -EINVAL; 1387 goto out; 1388 } 1389 output[type].fields |= all_output_options[i].field; 1390 } 1391 } 1392 1393 if (type >= 0) { 1394 if (output[type].fields == 0) { 1395 pr_debug("No fields requested for %s type. " 1396 "Events will not be displayed.\n", event_type(type)); 1397 } 1398 } 1399 1400 out: 1401 free(str); 1402 return rc; 1403 } 1404 1405 /* Helper function for filesystems that return a dent->d_type DT_UNKNOWN */ 1406 static int is_directory(const char *base_path, const struct dirent *dent) 1407 { 1408 char path[PATH_MAX]; 1409 struct stat st; 1410 1411 sprintf(path, "%s/%s", base_path, dent->d_name); 1412 if (stat(path, &st)) 1413 return 0; 1414 1415 return S_ISDIR(st.st_mode); 1416 } 1417 1418 #define for_each_lang(scripts_path, scripts_dir, lang_dirent, lang_next)\ 1419 while (!readdir_r(scripts_dir, &lang_dirent, &lang_next) && \ 1420 lang_next) \ 1421 if ((lang_dirent.d_type == DT_DIR || \ 1422 (lang_dirent.d_type == DT_UNKNOWN && \ 1423 is_directory(scripts_path, &lang_dirent))) && \ 1424 (strcmp(lang_dirent.d_name, ".")) && \ 1425 (strcmp(lang_dirent.d_name, ".."))) 1426 1427 #define for_each_script(lang_path, lang_dir, script_dirent, script_next)\ 1428 while (!readdir_r(lang_dir, &script_dirent, &script_next) && \ 1429 script_next) \ 1430 if (script_dirent.d_type != DT_DIR && \ 1431 (script_dirent.d_type != DT_UNKNOWN || \ 1432 !is_directory(lang_path, &script_dirent))) 1433 1434 1435 #define RECORD_SUFFIX "-record" 1436 #define REPORT_SUFFIX "-report" 1437 1438 struct script_desc { 1439 struct list_head node; 1440 char *name; 1441 char *half_liner; 1442 char *args; 1443 }; 1444 1445 static LIST_HEAD(script_descs); 1446 1447 static struct script_desc *script_desc__new(const char *name) 1448 { 1449 struct script_desc *s = zalloc(sizeof(*s)); 1450 1451 if (s != NULL && name) 1452 s->name = strdup(name); 1453 1454 return s; 1455 } 1456 1457 static void script_desc__delete(struct script_desc *s) 1458 { 1459 zfree(&s->name); 1460 zfree(&s->half_liner); 1461 zfree(&s->args); 1462 free(s); 1463 } 1464 1465 static void script_desc__add(struct script_desc *s) 1466 { 1467 list_add_tail(&s->node, &script_descs); 1468 } 1469 1470 static struct script_desc *script_desc__find(const char *name) 1471 { 1472 struct script_desc *s; 1473 1474 list_for_each_entry(s, &script_descs, node) 1475 if (strcasecmp(s->name, name) == 0) 1476 return s; 1477 return NULL; 1478 } 1479 1480 static struct script_desc *script_desc__findnew(const char *name) 1481 { 1482 struct script_desc *s = script_desc__find(name); 1483 1484 if (s) 1485 return s; 1486 1487 s = script_desc__new(name); 1488 if (!s) 1489 goto out_delete_desc; 1490 1491 script_desc__add(s); 1492 1493 return s; 1494 1495 out_delete_desc: 1496 script_desc__delete(s); 1497 1498 return NULL; 1499 } 1500 1501 static const char *ends_with(const char *str, const char *suffix) 1502 { 1503 size_t suffix_len = strlen(suffix); 1504 const char *p = str; 1505 1506 if (strlen(str) > suffix_len) { 1507 p = str + strlen(str) - suffix_len; 1508 if (!strncmp(p, suffix, suffix_len)) 1509 return p; 1510 } 1511 1512 return NULL; 1513 } 1514 1515 static int read_script_info(struct script_desc *desc, const char *filename) 1516 { 1517 char line[BUFSIZ], *p; 1518 FILE *fp; 1519 1520 fp = fopen(filename, "r"); 1521 if (!fp) 1522 return -1; 1523 1524 while (fgets(line, sizeof(line), fp)) { 1525 p = ltrim(line); 1526 if (strlen(p) == 0) 1527 continue; 1528 if (*p != '#') 1529 continue; 1530 p++; 1531 if (strlen(p) && *p == '!') 1532 continue; 1533 1534 p = ltrim(p); 1535 if (strlen(p) && p[strlen(p) - 1] == '\n') 1536 p[strlen(p) - 1] = '\0'; 1537 1538 if (!strncmp(p, "description:", strlen("description:"))) { 1539 p += strlen("description:"); 1540 desc->half_liner = strdup(ltrim(p)); 1541 continue; 1542 } 1543 1544 if (!strncmp(p, "args:", strlen("args:"))) { 1545 p += strlen("args:"); 1546 desc->args = strdup(ltrim(p)); 1547 continue; 1548 } 1549 } 1550 1551 fclose(fp); 1552 1553 return 0; 1554 } 1555 1556 static char *get_script_root(struct dirent *script_dirent, const char *suffix) 1557 { 1558 char *script_root, *str; 1559 1560 script_root = strdup(script_dirent->d_name); 1561 if (!script_root) 1562 return NULL; 1563 1564 str = (char *)ends_with(script_root, suffix); 1565 if (!str) { 1566 free(script_root); 1567 return NULL; 1568 } 1569 1570 *str = '\0'; 1571 return script_root; 1572 } 1573 1574 static int list_available_scripts(const struct option *opt __maybe_unused, 1575 const char *s __maybe_unused, 1576 int unset __maybe_unused) 1577 { 1578 struct dirent *script_next, *lang_next, script_dirent, lang_dirent; 1579 char scripts_path[MAXPATHLEN]; 1580 DIR *scripts_dir, *lang_dir; 1581 char script_path[MAXPATHLEN]; 1582 char lang_path[MAXPATHLEN]; 1583 struct script_desc *desc; 1584 char first_half[BUFSIZ]; 1585 char *script_root; 1586 1587 snprintf(scripts_path, MAXPATHLEN, "%s/scripts", get_argv_exec_path()); 1588 1589 scripts_dir = opendir(scripts_path); 1590 if (!scripts_dir) 1591 return -1; 1592 1593 for_each_lang(scripts_path, scripts_dir, lang_dirent, lang_next) { 1594 snprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path, 1595 lang_dirent.d_name); 1596 lang_dir = opendir(lang_path); 1597 if (!lang_dir) 1598 continue; 1599 1600 for_each_script(lang_path, lang_dir, script_dirent, script_next) { 1601 script_root = get_script_root(&script_dirent, REPORT_SUFFIX); 1602 if (script_root) { 1603 desc = script_desc__findnew(script_root); 1604 snprintf(script_path, MAXPATHLEN, "%s/%s", 1605 lang_path, script_dirent.d_name); 1606 read_script_info(desc, script_path); 1607 free(script_root); 1608 } 1609 } 1610 } 1611 1612 fprintf(stdout, "List of available trace scripts:\n"); 1613 list_for_each_entry(desc, &script_descs, node) { 1614 sprintf(first_half, "%s %s", desc->name, 1615 desc->args ? desc->args : ""); 1616 fprintf(stdout, " %-36s %s\n", first_half, 1617 desc->half_liner ? desc->half_liner : ""); 1618 } 1619 1620 exit(0); 1621 } 1622 1623 /* 1624 * Some scripts specify the required events in their "xxx-record" file, 1625 * this function will check if the events in perf.data match those 1626 * mentioned in the "xxx-record". 1627 * 1628 * Fixme: All existing "xxx-record" are all in good formats "-e event ", 1629 * which is covered well now. And new parsing code should be added to 1630 * cover the future complexing formats like event groups etc. 1631 */ 1632 static int check_ev_match(char *dir_name, char *scriptname, 1633 struct perf_session *session) 1634 { 1635 char filename[MAXPATHLEN], evname[128]; 1636 char line[BUFSIZ], *p; 1637 struct perf_evsel *pos; 1638 int match, len; 1639 FILE *fp; 1640 1641 sprintf(filename, "%s/bin/%s-record", dir_name, scriptname); 1642 1643 fp = fopen(filename, "r"); 1644 if (!fp) 1645 return -1; 1646 1647 while (fgets(line, sizeof(line), fp)) { 1648 p = ltrim(line); 1649 if (*p == '#') 1650 continue; 1651 1652 while (strlen(p)) { 1653 p = strstr(p, "-e"); 1654 if (!p) 1655 break; 1656 1657 p += 2; 1658 p = ltrim(p); 1659 len = strcspn(p, " \t"); 1660 if (!len) 1661 break; 1662 1663 snprintf(evname, len + 1, "%s", p); 1664 1665 match = 0; 1666 evlist__for_each(session->evlist, pos) { 1667 if (!strcmp(perf_evsel__name(pos), evname)) { 1668 match = 1; 1669 break; 1670 } 1671 } 1672 1673 if (!match) { 1674 fclose(fp); 1675 return -1; 1676 } 1677 } 1678 } 1679 1680 fclose(fp); 1681 return 0; 1682 } 1683 1684 /* 1685 * Return -1 if none is found, otherwise the actual scripts number. 1686 * 1687 * Currently the only user of this function is the script browser, which 1688 * will list all statically runnable scripts, select one, execute it and 1689 * show the output in a perf browser. 1690 */ 1691 int find_scripts(char **scripts_array, char **scripts_path_array) 1692 { 1693 struct dirent *script_next, *lang_next, script_dirent, lang_dirent; 1694 char scripts_path[MAXPATHLEN], lang_path[MAXPATHLEN]; 1695 DIR *scripts_dir, *lang_dir; 1696 struct perf_session *session; 1697 struct perf_data_file file = { 1698 .path = input_name, 1699 .mode = PERF_DATA_MODE_READ, 1700 }; 1701 char *temp; 1702 int i = 0; 1703 1704 session = perf_session__new(&file, false, NULL); 1705 if (!session) 1706 return -1; 1707 1708 snprintf(scripts_path, MAXPATHLEN, "%s/scripts", get_argv_exec_path()); 1709 1710 scripts_dir = opendir(scripts_path); 1711 if (!scripts_dir) { 1712 perf_session__delete(session); 1713 return -1; 1714 } 1715 1716 for_each_lang(scripts_path, scripts_dir, lang_dirent, lang_next) { 1717 snprintf(lang_path, MAXPATHLEN, "%s/%s", scripts_path, 1718 lang_dirent.d_name); 1719 #ifdef NO_LIBPERL 1720 if (strstr(lang_path, "perl")) 1721 continue; 1722 #endif 1723 #ifdef NO_LIBPYTHON 1724 if (strstr(lang_path, "python")) 1725 continue; 1726 #endif 1727 1728 lang_dir = opendir(lang_path); 1729 if (!lang_dir) 1730 continue; 1731 1732 for_each_script(lang_path, lang_dir, script_dirent, script_next) { 1733 /* Skip those real time scripts: xxxtop.p[yl] */ 1734 if (strstr(script_dirent.d_name, "top.")) 1735 continue; 1736 sprintf(scripts_path_array[i], "%s/%s", lang_path, 1737 script_dirent.d_name); 1738 temp = strchr(script_dirent.d_name, '.'); 1739 snprintf(scripts_array[i], 1740 (temp - script_dirent.d_name) + 1, 1741 "%s", script_dirent.d_name); 1742 1743 if (check_ev_match(lang_path, 1744 scripts_array[i], session)) 1745 continue; 1746 1747 i++; 1748 } 1749 closedir(lang_dir); 1750 } 1751 1752 closedir(scripts_dir); 1753 perf_session__delete(session); 1754 return i; 1755 } 1756 1757 static char *get_script_path(const char *script_root, const char *suffix) 1758 { 1759 struct dirent *script_next, *lang_next, script_dirent, lang_dirent; 1760 char scripts_path[MAXPATHLEN]; 1761 char script_path[MAXPATHLEN]; 1762 DIR *scripts_dir, *lang_dir; 1763 char lang_path[MAXPATHLEN]; 1764 char *__script_root; 1765 1766 snprintf(scripts_path, MAXPATHLEN, "%s/scripts", get_argv_exec_path()); 1767 1768 scripts_dir = opendir(scripts_path); 1769 if (!scripts_dir) 1770 return NULL; 1771 1772 for_each_lang(scripts_path, scripts_dir, lang_dirent, lang_next) { 1773 snprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path, 1774 lang_dirent.d_name); 1775 lang_dir = opendir(lang_path); 1776 if (!lang_dir) 1777 continue; 1778 1779 for_each_script(lang_path, lang_dir, script_dirent, script_next) { 1780 __script_root = get_script_root(&script_dirent, suffix); 1781 if (__script_root && !strcmp(script_root, __script_root)) { 1782 free(__script_root); 1783 closedir(lang_dir); 1784 closedir(scripts_dir); 1785 snprintf(script_path, MAXPATHLEN, "%s/%s", 1786 lang_path, script_dirent.d_name); 1787 return strdup(script_path); 1788 } 1789 free(__script_root); 1790 } 1791 closedir(lang_dir); 1792 } 1793 closedir(scripts_dir); 1794 1795 return NULL; 1796 } 1797 1798 static bool is_top_script(const char *script_path) 1799 { 1800 return ends_with(script_path, "top") == NULL ? false : true; 1801 } 1802 1803 static int has_required_arg(char *script_path) 1804 { 1805 struct script_desc *desc; 1806 int n_args = 0; 1807 char *p; 1808 1809 desc = script_desc__new(NULL); 1810 1811 if (read_script_info(desc, script_path)) 1812 goto out; 1813 1814 if (!desc->args) 1815 goto out; 1816 1817 for (p = desc->args; *p; p++) 1818 if (*p == '<') 1819 n_args++; 1820 out: 1821 script_desc__delete(desc); 1822 1823 return n_args; 1824 } 1825 1826 static int have_cmd(int argc, const char **argv) 1827 { 1828 char **__argv = malloc(sizeof(const char *) * argc); 1829 1830 if (!__argv) { 1831 pr_err("malloc failed\n"); 1832 return -1; 1833 } 1834 1835 memcpy(__argv, argv, sizeof(const char *) * argc); 1836 argc = parse_options(argc, (const char **)__argv, record_options, 1837 NULL, PARSE_OPT_STOP_AT_NON_OPTION); 1838 free(__argv); 1839 1840 system_wide = (argc == 0); 1841 1842 return 0; 1843 } 1844 1845 static void script__setup_sample_type(struct perf_script *script) 1846 { 1847 struct perf_session *session = script->session; 1848 u64 sample_type = perf_evlist__combined_sample_type(session->evlist); 1849 1850 if (symbol_conf.use_callchain || symbol_conf.cumulate_callchain) { 1851 if ((sample_type & PERF_SAMPLE_REGS_USER) && 1852 (sample_type & PERF_SAMPLE_STACK_USER)) 1853 callchain_param.record_mode = CALLCHAIN_DWARF; 1854 else if (sample_type & PERF_SAMPLE_BRANCH_STACK) 1855 callchain_param.record_mode = CALLCHAIN_LBR; 1856 else 1857 callchain_param.record_mode = CALLCHAIN_FP; 1858 } 1859 } 1860 1861 static int process_stat_round_event(struct perf_tool *tool __maybe_unused, 1862 union perf_event *event, 1863 struct perf_session *session) 1864 { 1865 struct stat_round_event *round = &event->stat_round; 1866 struct perf_evsel *counter; 1867 1868 evlist__for_each(session->evlist, counter) { 1869 perf_stat_process_counter(&stat_config, counter); 1870 process_stat(counter, round->time); 1871 } 1872 1873 process_stat_interval(round->time); 1874 return 0; 1875 } 1876 1877 static int process_stat_config_event(struct perf_tool *tool __maybe_unused, 1878 union perf_event *event, 1879 struct perf_session *session __maybe_unused) 1880 { 1881 perf_event__read_stat_config(&stat_config, &event->stat_config); 1882 return 0; 1883 } 1884 1885 static int set_maps(struct perf_script *script) 1886 { 1887 struct perf_evlist *evlist = script->session->evlist; 1888 1889 if (!script->cpus || !script->threads) 1890 return 0; 1891 1892 if (WARN_ONCE(script->allocated, "stats double allocation\n")) 1893 return -EINVAL; 1894 1895 perf_evlist__set_maps(evlist, script->cpus, script->threads); 1896 1897 if (perf_evlist__alloc_stats(evlist, true)) 1898 return -ENOMEM; 1899 1900 script->allocated = true; 1901 return 0; 1902 } 1903 1904 static 1905 int process_thread_map_event(struct perf_tool *tool, 1906 union perf_event *event, 1907 struct perf_session *session __maybe_unused) 1908 { 1909 struct perf_script *script = container_of(tool, struct perf_script, tool); 1910 1911 if (script->threads) { 1912 pr_warning("Extra thread map event, ignoring.\n"); 1913 return 0; 1914 } 1915 1916 script->threads = thread_map__new_event(&event->thread_map); 1917 if (!script->threads) 1918 return -ENOMEM; 1919 1920 return set_maps(script); 1921 } 1922 1923 static 1924 int process_cpu_map_event(struct perf_tool *tool __maybe_unused, 1925 union perf_event *event, 1926 struct perf_session *session __maybe_unused) 1927 { 1928 struct perf_script *script = container_of(tool, struct perf_script, tool); 1929 1930 if (script->cpus) { 1931 pr_warning("Extra cpu map event, ignoring.\n"); 1932 return 0; 1933 } 1934 1935 script->cpus = cpu_map__new_data(&event->cpu_map.data); 1936 if (!script->cpus) 1937 return -ENOMEM; 1938 1939 return set_maps(script); 1940 } 1941 1942 int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused) 1943 { 1944 bool show_full_info = false; 1945 bool header = false; 1946 bool header_only = false; 1947 bool script_started = false; 1948 char *rec_script_path = NULL; 1949 char *rep_script_path = NULL; 1950 struct perf_session *session; 1951 struct itrace_synth_opts itrace_synth_opts = { .set = false, }; 1952 char *script_path = NULL; 1953 const char **__argv; 1954 int i, j, err = 0; 1955 struct perf_script script = { 1956 .tool = { 1957 .sample = process_sample_event, 1958 .mmap = perf_event__process_mmap, 1959 .mmap2 = perf_event__process_mmap2, 1960 .comm = perf_event__process_comm, 1961 .exit = perf_event__process_exit, 1962 .fork = perf_event__process_fork, 1963 .attr = process_attr, 1964 .tracing_data = perf_event__process_tracing_data, 1965 .build_id = perf_event__process_build_id, 1966 .id_index = perf_event__process_id_index, 1967 .auxtrace_info = perf_event__process_auxtrace_info, 1968 .auxtrace = perf_event__process_auxtrace, 1969 .auxtrace_error = perf_event__process_auxtrace_error, 1970 .stat = perf_event__process_stat_event, 1971 .stat_round = process_stat_round_event, 1972 .stat_config = process_stat_config_event, 1973 .thread_map = process_thread_map_event, 1974 .cpu_map = process_cpu_map_event, 1975 .ordered_events = true, 1976 .ordering_requires_timestamps = true, 1977 }, 1978 }; 1979 struct perf_data_file file = { 1980 .mode = PERF_DATA_MODE_READ, 1981 }; 1982 const struct option options[] = { 1983 OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace, 1984 "dump raw trace in ASCII"), 1985 OPT_INCR('v', "verbose", &verbose, 1986 "be more verbose (show symbol address, etc)"), 1987 OPT_BOOLEAN('L', "Latency", &latency_format, 1988 "show latency attributes (irqs/preemption disabled, etc)"), 1989 OPT_CALLBACK_NOOPT('l', "list", NULL, NULL, "list available scripts", 1990 list_available_scripts), 1991 OPT_CALLBACK('s', "script", NULL, "name", 1992 "script file name (lang:script name, script name, or *)", 1993 parse_scriptname), 1994 OPT_STRING('g', "gen-script", &generate_script_lang, "lang", 1995 "generate perf-script.xx script in specified language"), 1996 OPT_STRING('i', "input", &input_name, "file", "input file name"), 1997 OPT_BOOLEAN('d', "debug-mode", &debug_mode, 1998 "do various checks like samples ordering and lost events"), 1999 OPT_BOOLEAN(0, "header", &header, "Show data header."), 2000 OPT_BOOLEAN(0, "header-only", &header_only, "Show only data header."), 2001 OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name, 2002 "file", "vmlinux pathname"), 2003 OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name, 2004 "file", "kallsyms pathname"), 2005 OPT_BOOLEAN('G', "hide-call-graph", &no_callchain, 2006 "When printing symbols do not display call chain"), 2007 OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory", 2008 "Look for files with symbols relative to this directory"), 2009 OPT_CALLBACK('F', "fields", NULL, "str", 2010 "comma separated output fields prepend with 'type:'. " 2011 "Valid types: hw,sw,trace,raw. " 2012 "Fields: comm,tid,pid,time,cpu,event,trace,ip,sym,dso," 2013 "addr,symoff,period,iregs,brstack,brstacksym,flags", parse_output_fields), 2014 OPT_BOOLEAN('a', "all-cpus", &system_wide, 2015 "system-wide collection from all CPUs"), 2016 OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]", 2017 "only consider these symbols"), 2018 OPT_STRING('C', "cpu", &cpu_list, "cpu", "list of cpus to profile"), 2019 OPT_STRING('c', "comms", &symbol_conf.comm_list_str, "comm[,comm...]", 2020 "only display events for these comms"), 2021 OPT_STRING(0, "pid", &symbol_conf.pid_list_str, "pid[,pid...]", 2022 "only consider symbols in these pids"), 2023 OPT_STRING(0, "tid", &symbol_conf.tid_list_str, "tid[,tid...]", 2024 "only consider symbols in these tids"), 2025 OPT_BOOLEAN('I', "show-info", &show_full_info, 2026 "display extended information from perf.data file"), 2027 OPT_BOOLEAN('\0', "show-kernel-path", &symbol_conf.show_kernel_path, 2028 "Show the path of [kernel.kallsyms]"), 2029 OPT_BOOLEAN('\0', "show-task-events", &script.show_task_events, 2030 "Show the fork/comm/exit events"), 2031 OPT_BOOLEAN('\0', "show-mmap-events", &script.show_mmap_events, 2032 "Show the mmap events"), 2033 OPT_BOOLEAN('\0', "show-switch-events", &script.show_switch_events, 2034 "Show context switch events (if recorded)"), 2035 OPT_BOOLEAN('f', "force", &file.force, "don't complain, do it"), 2036 OPT_BOOLEAN(0, "ns", &nanosecs, 2037 "Use 9 decimal places when displaying time"), 2038 OPT_CALLBACK_OPTARG(0, "itrace", &itrace_synth_opts, NULL, "opts", 2039 "Instruction Tracing options", 2040 itrace_parse_synth_opts), 2041 OPT_BOOLEAN(0, "full-source-path", &srcline_full_filename, 2042 "Show full source file name path for source lines"), 2043 OPT_BOOLEAN(0, "demangle", &symbol_conf.demangle, 2044 "Enable symbol demangling"), 2045 OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf.demangle_kernel, 2046 "Enable kernel symbol demangling"), 2047 2048 OPT_END() 2049 }; 2050 const char * const script_subcommands[] = { "record", "report", NULL }; 2051 const char *script_usage[] = { 2052 "perf script [<options>]", 2053 "perf script [<options>] record <script> [<record-options>] <command>", 2054 "perf script [<options>] report <script> [script-args]", 2055 "perf script [<options>] <script> [<record-options>] <command>", 2056 "perf script [<options>] <top-script> [script-args]", 2057 NULL 2058 }; 2059 2060 setup_scripting(); 2061 2062 argc = parse_options_subcommand(argc, argv, options, script_subcommands, script_usage, 2063 PARSE_OPT_STOP_AT_NON_OPTION); 2064 2065 file.path = input_name; 2066 2067 if (argc > 1 && !strncmp(argv[0], "rec", strlen("rec"))) { 2068 rec_script_path = get_script_path(argv[1], RECORD_SUFFIX); 2069 if (!rec_script_path) 2070 return cmd_record(argc, argv, NULL); 2071 } 2072 2073 if (argc > 1 && !strncmp(argv[0], "rep", strlen("rep"))) { 2074 rep_script_path = get_script_path(argv[1], REPORT_SUFFIX); 2075 if (!rep_script_path) { 2076 fprintf(stderr, 2077 "Please specify a valid report script" 2078 "(see 'perf script -l' for listing)\n"); 2079 return -1; 2080 } 2081 } 2082 2083 if (itrace_synth_opts.callchain && 2084 itrace_synth_opts.callchain_sz > scripting_max_stack) 2085 scripting_max_stack = itrace_synth_opts.callchain_sz; 2086 2087 /* make sure PERF_EXEC_PATH is set for scripts */ 2088 set_argv_exec_path(get_argv_exec_path()); 2089 2090 if (argc && !script_name && !rec_script_path && !rep_script_path) { 2091 int live_pipe[2]; 2092 int rep_args; 2093 pid_t pid; 2094 2095 rec_script_path = get_script_path(argv[0], RECORD_SUFFIX); 2096 rep_script_path = get_script_path(argv[0], REPORT_SUFFIX); 2097 2098 if (!rec_script_path && !rep_script_path) { 2099 usage_with_options_msg(script_usage, options, 2100 "Couldn't find script `%s'\n\n See perf" 2101 " script -l for available scripts.\n", argv[0]); 2102 } 2103 2104 if (is_top_script(argv[0])) { 2105 rep_args = argc - 1; 2106 } else { 2107 int rec_args; 2108 2109 rep_args = has_required_arg(rep_script_path); 2110 rec_args = (argc - 1) - rep_args; 2111 if (rec_args < 0) { 2112 usage_with_options_msg(script_usage, options, 2113 "`%s' script requires options." 2114 "\n\n See perf script -l for available " 2115 "scripts and options.\n", argv[0]); 2116 } 2117 } 2118 2119 if (pipe(live_pipe) < 0) { 2120 perror("failed to create pipe"); 2121 return -1; 2122 } 2123 2124 pid = fork(); 2125 if (pid < 0) { 2126 perror("failed to fork"); 2127 return -1; 2128 } 2129 2130 if (!pid) { 2131 j = 0; 2132 2133 dup2(live_pipe[1], 1); 2134 close(live_pipe[0]); 2135 2136 if (is_top_script(argv[0])) { 2137 system_wide = true; 2138 } else if (!system_wide) { 2139 if (have_cmd(argc - rep_args, &argv[rep_args]) != 0) { 2140 err = -1; 2141 goto out; 2142 } 2143 } 2144 2145 __argv = malloc((argc + 6) * sizeof(const char *)); 2146 if (!__argv) { 2147 pr_err("malloc failed\n"); 2148 err = -ENOMEM; 2149 goto out; 2150 } 2151 2152 __argv[j++] = "/bin/sh"; 2153 __argv[j++] = rec_script_path; 2154 if (system_wide) 2155 __argv[j++] = "-a"; 2156 __argv[j++] = "-q"; 2157 __argv[j++] = "-o"; 2158 __argv[j++] = "-"; 2159 for (i = rep_args + 1; i < argc; i++) 2160 __argv[j++] = argv[i]; 2161 __argv[j++] = NULL; 2162 2163 execvp("/bin/sh", (char **)__argv); 2164 free(__argv); 2165 exit(-1); 2166 } 2167 2168 dup2(live_pipe[0], 0); 2169 close(live_pipe[1]); 2170 2171 __argv = malloc((argc + 4) * sizeof(const char *)); 2172 if (!__argv) { 2173 pr_err("malloc failed\n"); 2174 err = -ENOMEM; 2175 goto out; 2176 } 2177 2178 j = 0; 2179 __argv[j++] = "/bin/sh"; 2180 __argv[j++] = rep_script_path; 2181 for (i = 1; i < rep_args + 1; i++) 2182 __argv[j++] = argv[i]; 2183 __argv[j++] = "-i"; 2184 __argv[j++] = "-"; 2185 __argv[j++] = NULL; 2186 2187 execvp("/bin/sh", (char **)__argv); 2188 free(__argv); 2189 exit(-1); 2190 } 2191 2192 if (rec_script_path) 2193 script_path = rec_script_path; 2194 if (rep_script_path) 2195 script_path = rep_script_path; 2196 2197 if (script_path) { 2198 j = 0; 2199 2200 if (!rec_script_path) 2201 system_wide = false; 2202 else if (!system_wide) { 2203 if (have_cmd(argc - 1, &argv[1]) != 0) { 2204 err = -1; 2205 goto out; 2206 } 2207 } 2208 2209 __argv = malloc((argc + 2) * sizeof(const char *)); 2210 if (!__argv) { 2211 pr_err("malloc failed\n"); 2212 err = -ENOMEM; 2213 goto out; 2214 } 2215 2216 __argv[j++] = "/bin/sh"; 2217 __argv[j++] = script_path; 2218 if (system_wide) 2219 __argv[j++] = "-a"; 2220 for (i = 2; i < argc; i++) 2221 __argv[j++] = argv[i]; 2222 __argv[j++] = NULL; 2223 2224 execvp("/bin/sh", (char **)__argv); 2225 free(__argv); 2226 exit(-1); 2227 } 2228 2229 if (!script_name) 2230 setup_pager(); 2231 2232 session = perf_session__new(&file, false, &script.tool); 2233 if (session == NULL) 2234 return -1; 2235 2236 if (header || header_only) { 2237 perf_session__fprintf_info(session, stdout, show_full_info); 2238 if (header_only) 2239 goto out_delete; 2240 } 2241 2242 if (symbol__init(&session->header.env) < 0) 2243 goto out_delete; 2244 2245 script.session = session; 2246 script__setup_sample_type(&script); 2247 2248 session->itrace_synth_opts = &itrace_synth_opts; 2249 2250 if (cpu_list) { 2251 err = perf_session__cpu_bitmap(session, cpu_list, cpu_bitmap); 2252 if (err < 0) 2253 goto out_delete; 2254 } 2255 2256 if (!no_callchain) 2257 symbol_conf.use_callchain = true; 2258 else 2259 symbol_conf.use_callchain = false; 2260 2261 if (session->tevent.pevent && 2262 pevent_set_function_resolver(session->tevent.pevent, 2263 machine__resolve_kernel_addr, 2264 &session->machines.host) < 0) { 2265 pr_err("%s: failed to set libtraceevent function resolver\n", __func__); 2266 return -1; 2267 } 2268 2269 if (generate_script_lang) { 2270 struct stat perf_stat; 2271 int input; 2272 2273 if (output_set_by_user()) { 2274 fprintf(stderr, 2275 "custom fields not supported for generated scripts"); 2276 err = -EINVAL; 2277 goto out_delete; 2278 } 2279 2280 input = open(file.path, O_RDONLY); /* input_name */ 2281 if (input < 0) { 2282 err = -errno; 2283 perror("failed to open file"); 2284 goto out_delete; 2285 } 2286 2287 err = fstat(input, &perf_stat); 2288 if (err < 0) { 2289 perror("failed to stat file"); 2290 goto out_delete; 2291 } 2292 2293 if (!perf_stat.st_size) { 2294 fprintf(stderr, "zero-sized file, nothing to do!\n"); 2295 goto out_delete; 2296 } 2297 2298 scripting_ops = script_spec__lookup(generate_script_lang); 2299 if (!scripting_ops) { 2300 fprintf(stderr, "invalid language specifier"); 2301 err = -ENOENT; 2302 goto out_delete; 2303 } 2304 2305 err = scripting_ops->generate_script(session->tevent.pevent, 2306 "perf-script"); 2307 goto out_delete; 2308 } 2309 2310 if (script_name) { 2311 err = scripting_ops->start_script(script_name, argc, argv); 2312 if (err) 2313 goto out_delete; 2314 pr_debug("perf script started with script %s\n\n", script_name); 2315 script_started = true; 2316 } 2317 2318 2319 err = perf_session__check_output_opt(session); 2320 if (err < 0) 2321 goto out_delete; 2322 2323 err = __cmd_script(&script); 2324 2325 flush_scripting(); 2326 2327 out_delete: 2328 perf_evlist__free_stats(session->evlist); 2329 perf_session__delete(session); 2330 2331 if (script_started) 2332 cleanup_scripting(); 2333 out: 2334 return err; 2335 } 2336