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