tools/perf/builtin-script.c

   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__do_check_stype(evsel, PERF_SAMPLE_WEIGHT_TYPE, "WEIGHT", PERF_OUTPUT_WEIGHT, allow_user_set))
 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__do_check_stype(evsel, PERF_SAMPLE_PHYS_ADDR, "PHYS_ADDR", PERF_OUTPUT_PHYS_ADDR, allow_user_set))
 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, &ltime) == NULL) {
 706                 scnprintf(buf, buflen, "failed");
 707         } else {
 708                 strftime(date, sizeof(date), DEFAULT_TOD_FMT, &ltime);
 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, thread;
2119         struct perf_cpu cpu;
2120         static int header_printed;
2121
2122         if (counter->core.system_wide)
2123                 nthreads = 1;
2124
2125         if (!header_printed) {
2126                 printf("%3s %8s %15s %15s %15s %15s %s\n",
2127                        "CPU", "THREAD", "VAL", "ENA", "RUN", "TIME", "EVENT");
2128                 header_printed = 1;
2129         }
2130
2131         for (thread = 0; thread < nthreads; thread++) {
2132                 perf_cpu_map__for_each_cpu(cpu, idx, evsel__cpus(counter)) {
2133                         struct perf_counts_values *counts;
2134
2135                         counts = perf_counts(counter->counts, idx, thread);
2136
2137                         printf("%3d %8d %15" PRIu64 " %15" PRIu64 " %15" PRIu64 " %15" PRIu64 " %s\n",
2138                                 cpu.cpu,
2139                                 perf_thread_map__pid(counter->core.threads, thread),
2140                                 counts->val,
2141                                 counts->ena,
2142                                 counts->run,
2143                                 tstamp,
2144                                 evsel__name(counter));
2145                 }
2146         }
2147 }
2148
2149 static void process_stat(struct evsel *counter, u64 tstamp)
2150 {
2151         if (scripting_ops && scripting_ops->process_stat)
2152                 scripting_ops->process_stat(&stat_config, counter, tstamp);
2153         else
2154                 __process_stat(counter, tstamp);
2155 }
2156
2157 static void process_stat_interval(u64 tstamp)
2158 {
2159         if (scripting_ops && scripting_ops->process_stat_interval)
2160                 scripting_ops->process_stat_interval(tstamp);
2161 }
2162
2163 static void setup_scripting(void)
2164 {
2165         setup_perl_scripting();
2166         setup_python_scripting();
2167 }
2168
2169 static int flush_scripting(void)
2170 {
2171         return scripting_ops ? scripting_ops->flush_script() : 0;
2172 }
2173
2174 static int cleanup_scripting(void)
2175 {
2176         pr_debug("\nperf script stopped\n");
2177
2178         return scripting_ops ? scripting_ops->stop_script() : 0;
2179 }
2180
2181 static bool filter_cpu(struct perf_sample *sample)
2182 {
2183         if (cpu_list && sample->cpu != (u32)-1)
2184                 return !test_bit(sample->cpu, cpu_bitmap);
2185         return false;
2186 }
2187
2188 static int process_sample_event(struct perf_tool *tool,
2189                                 union perf_event *event,
2190                                 struct perf_sample *sample,
2191                                 struct evsel *evsel,
2192                                 struct machine *machine)
2193 {
2194         struct perf_script *scr = container_of(tool, struct perf_script, tool);
2195         struct addr_location al;
2196         struct addr_location addr_al;
2197         int ret = 0;
2198
2199         /* Set thread to NULL to indicate addr_al and al are not initialized */
2200         addr_al.thread = NULL;
2201         al.thread = NULL;
2202
2203         ret = dlfilter__filter_event_early(dlfilter, event, sample, evsel, machine, &al, &addr_al);
2204         if (ret) {
2205                 if (ret > 0)
2206                         ret = 0;
2207                 goto out_put;
2208         }
2209
2210         if (perf_time__ranges_skip_sample(scr->ptime_range, scr->range_num,
2211                                           sample->time)) {
2212                 goto out_put;
2213         }
2214
2215         if (debug_mode) {
2216                 if (sample->time < last_timestamp) {
2217                         pr_err("Samples misordered, previous: %" PRIu64
2218                                 " this: %" PRIu64 "\n", last_timestamp,
2219                                 sample->time);
2220                         nr_unordered++;
2221                 }
2222                 last_timestamp = sample->time;
2223                 goto out_put;
2224         }
2225
2226         if (filter_cpu(sample))
2227                 goto out_put;
2228
2229         if (!al.thread && machine__resolve(machine, &al, sample) < 0) {
2230                 pr_err("problem processing %d event, skipping it.\n",
2231                        event->header.type);
2232                 ret = -1;
2233                 goto out_put;
2234         }
2235
2236         if (al.filtered)
2237                 goto out_put;
2238
2239         if (!show_event(sample, evsel, al.thread, &al, &addr_al))
2240                 goto out_put;
2241
2242         if (evswitch__discard(&scr->evswitch, evsel))
2243                 goto out_put;
2244
2245         ret = dlfilter__filter_event(dlfilter, event, sample, evsel, machine, &al, &addr_al);
2246         if (ret) {
2247                 if (ret > 0)
2248                         ret = 0;
2249                 goto out_put;
2250         }
2251
2252         if (scripting_ops) {
2253                 struct addr_location *addr_al_ptr = NULL;
2254
2255                 if ((evsel->core.attr.sample_type & PERF_SAMPLE_ADDR) &&
2256                     sample_addr_correlates_sym(&evsel->core.attr)) {
2257                         if (!addr_al.thread)
2258                                 thread__resolve(al.thread, &addr_al, sample);
2259                         addr_al_ptr = &addr_al;
2260                 }
2261                 scripting_ops->process_event(event, sample, evsel, &al, addr_al_ptr);
2262         } else {
2263                 process_event(scr, sample, evsel, &al, &addr_al, machine);
2264         }
2265
2266 out_put:
2267         if (al.thread)
2268                 addr_location__put(&al);
2269         return ret;
2270 }
2271
2272 static int process_attr(struct perf_tool *tool, union perf_event *event,
2273                         struct evlist **pevlist)
2274 {
2275         struct perf_script *scr = container_of(tool, struct perf_script, tool);
2276         struct evlist *evlist;
2277         struct evsel *evsel, *pos;
2278         u64 sample_type;
2279         int err;
2280         static struct evsel_script *es;
2281
2282         err = perf_event__process_attr(tool, event, pevlist);
2283         if (err)
2284                 return err;
2285
2286         evlist = *pevlist;
2287         evsel = evlist__last(*pevlist);
2288
2289         if (!evsel->priv) {
2290                 if (scr->per_event_dump) {
2291                         evsel->priv = evsel_script__new(evsel, scr->session->data);
2292                 } else {
2293                         es = zalloc(sizeof(*es));
2294                         if (!es)
2295                                 return -ENOMEM;
2296                         es->fp = stdout;
2297                         evsel->priv = es;
2298                 }
2299         }
2300
2301         if (evsel->core.attr.type >= PERF_TYPE_MAX &&
2302             evsel->core.attr.type != PERF_TYPE_SYNTH)
2303                 return 0;
2304
2305         evlist__for_each_entry(evlist, pos) {
2306                 if (pos->core.attr.type == evsel->core.attr.type && pos != evsel)
2307                         return 0;
2308         }
2309
2310         if (evsel->core.attr.sample_type) {
2311                 err = evsel__check_attr(evsel, scr->session);
2312                 if (err)
2313                         return err;
2314         }
2315
2316         /*
2317          * Check if we need to enable callchains based
2318          * on events sample_type.
2319          */
2320         sample_type = evlist__combined_sample_type(evlist);
2321         callchain_param_setup(sample_type, perf_env__arch((*pevlist)->env));
2322
2323         /* Enable fields for callchain entries */
2324         if (symbol_conf.use_callchain &&
2325             (sample_type & PERF_SAMPLE_CALLCHAIN ||
2326              sample_type & PERF_SAMPLE_BRANCH_STACK ||
2327              (sample_type & PERF_SAMPLE_REGS_USER &&
2328               sample_type & PERF_SAMPLE_STACK_USER))) {
2329                 int type = output_type(evsel->core.attr.type);
2330
2331                 if (!(output[type].user_unset_fields & PERF_OUTPUT_IP))
2332                         output[type].fields |= PERF_OUTPUT_IP;
2333                 if (!(output[type].user_unset_fields & PERF_OUTPUT_SYM))
2334                         output[type].fields |= PERF_OUTPUT_SYM;
2335         }
2336         set_print_ip_opts(&evsel->core.attr);
2337         return 0;
2338 }
2339
2340 static int print_event_with_time(struct perf_tool *tool,
2341                                  union perf_event *event,
2342                                  struct perf_sample *sample,
2343                                  struct machine *machine,
2344                                  pid_t pid, pid_t tid, u64 timestamp)
2345 {
2346         struct perf_script *script = container_of(tool, struct perf_script, tool);
2347         struct perf_session *session = script->session;
2348         struct evsel *evsel = evlist__id2evsel(session->evlist, sample->id);
2349         struct thread *thread = NULL;
2350
2351         if (evsel && !evsel->core.attr.sample_id_all) {
2352                 sample->cpu = 0;
2353                 sample->time = timestamp;
2354                 sample->pid = pid;
2355                 sample->tid = tid;
2356         }
2357
2358         if (filter_cpu(sample))
2359                 return 0;
2360
2361         if (tid != -1)
2362                 thread = machine__findnew_thread(machine, pid, tid);
2363
2364         if (evsel) {
2365                 perf_sample__fprintf_start(script, sample, thread, evsel,
2366                                            event->header.type, stdout);
2367         }
2368
2369         perf_event__fprintf(event, machine, stdout);
2370
2371         thread__put(thread);
2372
2373         return 0;
2374 }
2375
2376 static int print_event(struct perf_tool *tool, union perf_event *event,
2377                        struct perf_sample *sample, struct machine *machine,
2378                        pid_t pid, pid_t tid)
2379 {
2380         return print_event_with_time(tool, event, sample, machine, pid, tid, 0);
2381 }
2382
2383 static int process_comm_event(struct perf_tool *tool,
2384                               union perf_event *event,
2385                               struct perf_sample *sample,
2386                               struct machine *machine)
2387 {
2388         if (perf_event__process_comm(tool, event, sample, machine) < 0)
2389                 return -1;
2390
2391         return print_event(tool, event, sample, machine, event->comm.pid,
2392                            event->comm.tid);
2393 }
2394
2395 static int process_namespaces_event(struct perf_tool *tool,
2396                                     union perf_event *event,
2397                                     struct perf_sample *sample,
2398                                     struct machine *machine)
2399 {
2400         if (perf_event__process_namespaces(tool, event, sample, machine) < 0)
2401                 return -1;
2402
2403         return print_event(tool, event, sample, machine, event->namespaces.pid,
2404                            event->namespaces.tid);
2405 }
2406
2407 static int process_cgroup_event(struct perf_tool *tool,
2408                                 union perf_event *event,
2409                                 struct perf_sample *sample,
2410                                 struct machine *machine)
2411 {
2412         if (perf_event__process_cgroup(tool, event, sample, machine) < 0)
2413                 return -1;
2414
2415         return print_event(tool, event, sample, machine, sample->pid,
2416                             sample->tid);
2417 }
2418
2419 static int process_fork_event(struct perf_tool *tool,
2420                               union perf_event *event,
2421                               struct perf_sample *sample,
2422                               struct machine *machine)
2423 {
2424         if (perf_event__process_fork(tool, event, sample, machine) < 0)
2425                 return -1;
2426
2427         return print_event_with_time(tool, event, sample, machine,
2428                                      event->fork.pid, event->fork.tid,
2429                                      event->fork.time);
2430 }
2431 static int process_exit_event(struct perf_tool *tool,
2432                               union perf_event *event,
2433                               struct perf_sample *sample,
2434                               struct machine *machine)
2435 {
2436         /* Print before 'exit' deletes anything */
2437         if (print_event_with_time(tool, event, sample, machine, event->fork.pid,
2438                                   event->fork.tid, event->fork.time))
2439                 return -1;
2440
2441         return perf_event__process_exit(tool, event, sample, machine);
2442 }
2443
2444 static int process_mmap_event(struct perf_tool *tool,
2445                               union perf_event *event,
2446                               struct perf_sample *sample,
2447                               struct machine *machine)
2448 {
2449         if (perf_event__process_mmap(tool, event, sample, machine) < 0)
2450                 return -1;
2451
2452         return print_event(tool, event, sample, machine, event->mmap.pid,
2453                            event->mmap.tid);
2454 }
2455
2456 static int process_mmap2_event(struct perf_tool *tool,
2457                               union perf_event *event,
2458                               struct perf_sample *sample,
2459                               struct machine *machine)
2460 {
2461         if (perf_event__process_mmap2(tool, event, sample, machine) < 0)
2462                 return -1;
2463
2464         return print_event(tool, event, sample, machine, event->mmap2.pid,
2465                            event->mmap2.tid);
2466 }
2467
2468 static int process_switch_event(struct perf_tool *tool,
2469                                 union perf_event *event,
2470                                 struct perf_sample *sample,
2471                                 struct machine *machine)
2472 {
2473         struct perf_script *script = container_of(tool, struct perf_script, tool);
2474
2475         if (perf_event__process_switch(tool, event, sample, machine) < 0)
2476                 return -1;
2477
2478         if (scripting_ops && scripting_ops->process_switch && !filter_cpu(sample))
2479                 scripting_ops->process_switch(event, sample, machine);
2480
2481         if (!script->show_switch_events)
2482                 return 0;
2483
2484         return print_event(tool, event, sample, machine, sample->pid,
2485                            sample->tid);
2486 }
2487
2488 static int process_auxtrace_error(struct perf_session *session,
2489                                   union perf_event *event)
2490 {
2491         if (scripting_ops && scripting_ops->process_auxtrace_error) {
2492                 scripting_ops->process_auxtrace_error(session, event);
2493                 return 0;
2494         }
2495
2496         return perf_event__process_auxtrace_error(session, event);
2497 }
2498
2499 static int
2500 process_lost_event(struct perf_tool *tool,
2501                    union perf_event *event,
2502                    struct perf_sample *sample,
2503                    struct machine *machine)
2504 {
2505         return print_event(tool, event, sample, machine, sample->pid,
2506                            sample->tid);
2507 }
2508
2509 static int
2510 process_throttle_event(struct perf_tool *tool __maybe_unused,
2511                        union perf_event *event,
2512                        struct perf_sample *sample,
2513                        struct machine *machine)
2514 {
2515         if (scripting_ops && scripting_ops->process_throttle)
2516                 scripting_ops->process_throttle(event, sample, machine);
2517         return 0;
2518 }
2519
2520 static int
2521 process_finished_round_event(struct perf_tool *tool __maybe_unused,
2522                              union perf_event *event,
2523                              struct ordered_events *oe __maybe_unused)
2524
2525 {
2526         perf_event__fprintf(event, NULL, stdout);
2527         return 0;
2528 }
2529
2530 static int
2531 process_bpf_events(struct perf_tool *tool __maybe_unused,
2532                    union perf_event *event,
2533                    struct perf_sample *sample,
2534                    struct machine *machine)
2535 {
2536         if (machine__process_ksymbol(machine, event, sample) < 0)
2537                 return -1;
2538
2539         return print_event(tool, event, sample, machine, sample->pid,
2540                            sample->tid);
2541 }
2542
2543 static int process_text_poke_events(struct perf_tool *tool,
2544                                     union perf_event *event,
2545                                     struct perf_sample *sample,
2546                                     struct machine *machine)
2547 {
2548         if (perf_event__process_text_poke(tool, event, sample, machine) < 0)
2549                 return -1;
2550
2551         return print_event(tool, event, sample, machine, sample->pid,
2552                            sample->tid);
2553 }
2554
2555 static void sig_handler(int sig __maybe_unused)
2556 {
2557         session_done = 1;
2558 }
2559
2560 static void perf_script__fclose_per_event_dump(struct perf_script *script)
2561 {
2562         struct evlist *evlist = script->session->evlist;
2563         struct evsel *evsel;
2564
2565         evlist__for_each_entry(evlist, evsel) {
2566                 if (!evsel->priv)
2567                         break;
2568                 evsel_script__delete(evsel->priv);
2569                 evsel->priv = NULL;
2570         }
2571 }
2572
2573 static int perf_script__fopen_per_event_dump(struct perf_script *script)
2574 {
2575         struct evsel *evsel;
2576
2577         evlist__for_each_entry(script->session->evlist, evsel) {
2578                 /*
2579                  * Already setup? I.e. we may be called twice in cases like
2580                  * Intel PT, one for the intel_pt// and dummy events, then
2581                  * for the evsels synthesized from the auxtrace info.
2582                  *
2583                  * Ses perf_script__process_auxtrace_info.
2584                  */
2585                 if (evsel->priv != NULL)
2586                         continue;
2587
2588                 evsel->priv = evsel_script__new(evsel, script->session->data);
2589                 if (evsel->priv == NULL)
2590                         goto out_err_fclose;
2591         }
2592
2593         return 0;
2594
2595 out_err_fclose:
2596         perf_script__fclose_per_event_dump(script);
2597         return -1;
2598 }
2599
2600 static int perf_script__setup_per_event_dump(struct perf_script *script)
2601 {
2602         struct evsel *evsel;
2603         static struct evsel_script es_stdout;
2604
2605         if (script->per_event_dump)
2606                 return perf_script__fopen_per_event_dump(script);
2607
2608         es_stdout.fp = stdout;
2609
2610         evlist__for_each_entry(script->session->evlist, evsel)
2611                 evsel->priv = &es_stdout;
2612
2613         return 0;
2614 }
2615
2616 static void perf_script__exit_per_event_dump_stats(struct perf_script *script)
2617 {
2618         struct evsel *evsel;
2619
2620         evlist__for_each_entry(script->session->evlist, evsel) {
2621                 struct evsel_script *es = evsel->priv;
2622
2623                 evsel_script__fprintf(es, stdout);
2624                 evsel_script__delete(es);
2625                 evsel->priv = NULL;
2626         }
2627 }
2628
2629 static void perf_script__exit(struct perf_script *script)
2630 {
2631         perf_thread_map__put(script->threads);
2632         perf_cpu_map__put(script->cpus);
2633 }
2634
2635 static int __cmd_script(struct perf_script *script)
2636 {
2637         int ret;
2638
2639         signal(SIGINT, sig_handler);
2640
2641         perf_stat__init_shadow_stats();
2642
2643         /* override event processing functions */
2644         if (script->show_task_events) {
2645                 script->tool.comm = process_comm_event;
2646                 script->tool.fork = process_fork_event;
2647                 script->tool.exit = process_exit_event;
2648         }
2649         if (script->show_mmap_events) {
2650                 script->tool.mmap = process_mmap_event;
2651                 script->tool.mmap2 = process_mmap2_event;
2652         }
2653         if (script->show_switch_events || (scripting_ops && scripting_ops->process_switch))
2654                 script->tool.context_switch = process_switch_event;
2655         if (scripting_ops && scripting_ops->process_auxtrace_error)
2656                 script->tool.auxtrace_error = process_auxtrace_error;
2657         if (script->show_namespace_events)
2658                 script->tool.namespaces = process_namespaces_event;
2659         if (script->show_cgroup_events)
2660                 script->tool.cgroup = process_cgroup_event;
2661         if (script->show_lost_events)
2662                 script->tool.lost = process_lost_event;
2663         if (script->show_round_events) {
2664                 script->tool.ordered_events = false;
2665                 script->tool.finished_round = process_finished_round_event;
2666         }
2667         if (script->show_bpf_events) {
2668                 script->tool.ksymbol = process_bpf_events;
2669                 script->tool.bpf     = process_bpf_events;
2670         }
2671         if (script->show_text_poke_events) {
2672                 script->tool.ksymbol   = process_bpf_events;
2673                 script->tool.text_poke = process_text_poke_events;
2674         }
2675
2676         if (perf_script__setup_per_event_dump(script)) {
2677                 pr_err("Couldn't create the per event dump files\n");
2678                 return -1;
2679         }
2680
2681         ret = perf_session__process_events(script->session);
2682
2683         if (script->per_event_dump)
2684                 perf_script__exit_per_event_dump_stats(script);
2685
2686         if (debug_mode)
2687                 pr_err("Misordered timestamps: %" PRIu64 "\n", nr_unordered);
2688
2689         return ret;
2690 }
2691
2692 struct script_spec {
2693         struct list_head        node;
2694         struct scripting_ops    *ops;
2695         char                    spec[];
2696 };
2697
2698 static LIST_HEAD(script_specs);
2699
2700 static struct script_spec *script_spec__new(const char *spec,
2701                                             struct scripting_ops *ops)
2702 {
2703         struct script_spec *s = malloc(sizeof(*s) + strlen(spec) + 1);
2704
2705         if (s != NULL) {
2706                 strcpy(s->spec, spec);
2707                 s->ops = ops;
2708         }
2709
2710         return s;
2711 }
2712
2713 static void script_spec__add(struct script_spec *s)
2714 {
2715         list_add_tail(&s->node, &script_specs);
2716 }
2717
2718 static struct script_spec *script_spec__find(const char *spec)
2719 {
2720         struct script_spec *s;
2721
2722         list_for_each_entry(s, &script_specs, node)
2723                 if (strcasecmp(s->spec, spec) == 0)
2724                         return s;
2725         return NULL;
2726 }
2727
2728 int script_spec_register(const char *spec, struct scripting_ops *ops)
2729 {
2730         struct script_spec *s;
2731
2732         s = script_spec__find(spec);
2733         if (s)
2734                 return -1;
2735
2736         s = script_spec__new(spec, ops);
2737         if (!s)
2738                 return -1;
2739         else
2740                 script_spec__add(s);
2741
2742         return 0;
2743 }
2744
2745 static struct scripting_ops *script_spec__lookup(const char *spec)
2746 {
2747         struct script_spec *s = script_spec__find(spec);
2748         if (!s)
2749                 return NULL;
2750
2751         return s->ops;
2752 }
2753
2754 static void list_available_languages(void)
2755 {
2756         struct script_spec *s;
2757
2758         fprintf(stderr, "\n");
2759         fprintf(stderr, "Scripting language extensions (used in "
2760                 "perf script -s [spec:]script.[spec]):\n\n");
2761
2762         list_for_each_entry(s, &script_specs, node)
2763                 fprintf(stderr, "  %-42s [%s]\n", s->spec, s->ops->name);
2764
2765         fprintf(stderr, "\n");
2766 }
2767
2768 /* Find script file relative to current directory or exec path */
2769 static char *find_script(const char *script)
2770 {
2771         char path[PATH_MAX];
2772
2773         if (!scripting_ops) {
2774                 const char *ext = strrchr(script, '.');
2775
2776                 if (!ext)
2777                         return NULL;
2778
2779                 scripting_ops = script_spec__lookup(++ext);
2780                 if (!scripting_ops)
2781                         return NULL;
2782         }
2783
2784         if (access(script, R_OK)) {
2785                 char *exec_path = get_argv_exec_path();
2786
2787                 if (!exec_path)
2788                         return NULL;
2789                 snprintf(path, sizeof(path), "%s/scripts/%s/%s",
2790                          exec_path, scripting_ops->dirname, script);
2791                 free(exec_path);
2792                 script = path;
2793                 if (access(script, R_OK))
2794                         return NULL;
2795         }
2796         return strdup(script);
2797 }
2798
2799 static int parse_scriptname(const struct option *opt __maybe_unused,
2800                             const char *str, int unset __maybe_unused)
2801 {
2802         char spec[PATH_MAX];
2803         const char *script, *ext;
2804         int len;
2805
2806         if (strcmp(str, "lang") == 0) {
2807                 list_available_languages();
2808                 exit(0);
2809         }
2810
2811         script = strchr(str, ':');
2812         if (script) {
2813                 len = script - str;
2814                 if (len >= PATH_MAX) {
2815                         fprintf(stderr, "invalid language specifier");
2816                         return -1;
2817                 }
2818                 strncpy(spec, str, len);
2819                 spec[len] = '\0';
2820                 scripting_ops = script_spec__lookup(spec);
2821                 if (!scripting_ops) {
2822                         fprintf(stderr, "invalid language specifier");
2823                         return -1;
2824                 }
2825                 script++;
2826         } else {
2827                 script = str;
2828                 ext = strrchr(script, '.');
2829                 if (!ext) {
2830                         fprintf(stderr, "invalid script extension");
2831                         return -1;
2832                 }
2833                 scripting_ops = script_spec__lookup(++ext);
2834                 if (!scripting_ops) {
2835                         fprintf(stderr, "invalid script extension");
2836                         return -1;
2837                 }
2838         }
2839
2840         script_name = find_script(script);
2841         if (!script_name)
2842                 script_name = strdup(script);
2843
2844         return 0;
2845 }
2846
2847 static int parse_output_fields(const struct option *opt __maybe_unused,
2848                             const char *arg, int unset __maybe_unused)
2849 {
2850         char *tok, *strtok_saveptr = NULL;
2851         int i, imax = ARRAY_SIZE(all_output_options);
2852         int j;
2853         int rc = 0;
2854         char *str = strdup(arg);
2855         int type = -1;
2856         enum { DEFAULT, SET, ADD, REMOVE } change = DEFAULT;
2857
2858         if (!str)
2859                 return -ENOMEM;
2860
2861         /* first word can state for which event type the user is specifying
2862          * the fields. If no type exists, the specified fields apply to all
2863          * event types found in the file minus the invalid fields for a type.
2864          */
2865         tok = strchr(str, ':');
2866         if (tok) {
2867                 *tok = '\0';
2868                 tok++;
2869                 if (!strcmp(str, "hw"))
2870                         type = PERF_TYPE_HARDWARE;
2871                 else if (!strcmp(str, "sw"))
2872                         type = PERF_TYPE_SOFTWARE;
2873                 else if (!strcmp(str, "trace"))
2874                         type = PERF_TYPE_TRACEPOINT;
2875                 else if (!strcmp(str, "raw"))
2876                         type = PERF_TYPE_RAW;
2877                 else if (!strcmp(str, "break"))
2878                         type = PERF_TYPE_BREAKPOINT;
2879                 else if (!strcmp(str, "synth"))
2880                         type = OUTPUT_TYPE_SYNTH;
2881                 else {
2882                         fprintf(stderr, "Invalid event type in field string.\n");
2883                         rc = -EINVAL;
2884                         goto out;
2885                 }
2886
2887                 if (output[type].user_set)
2888                         pr_warning("Overriding previous field request for %s events.\n",
2889                                    event_type(type));
2890
2891                 /* Don't override defaults for +- */
2892                 if (strchr(tok, '+') || strchr(tok, '-'))
2893                         goto parse;
2894
2895                 output[type].fields = 0;
2896                 output[type].user_set = true;
2897                 output[type].wildcard_set = false;
2898
2899         } else {
2900                 tok = str;
2901                 if (strlen(str) == 0) {
2902                         fprintf(stderr,
2903                                 "Cannot set fields to 'none' for all event types.\n");
2904                         rc = -EINVAL;
2905                         goto out;
2906                 }
2907
2908                 /* Don't override defaults for +- */
2909                 if (strchr(str, '+') || strchr(str, '-'))
2910                         goto parse;
2911
2912                 if (output_set_by_user())
2913                         pr_warning("Overriding previous field request for all events.\n");
2914
2915                 for (j = 0; j < OUTPUT_TYPE_MAX; ++j) {
2916                         output[j].fields = 0;
2917                         output[j].user_set = true;
2918                         output[j].wildcard_set = true;
2919                 }
2920         }
2921
2922 parse:
2923         for (tok = strtok_r(tok, ",", &strtok_saveptr); tok; tok = strtok_r(NULL, ",", &strtok_saveptr)) {
2924                 if (*tok == '+') {
2925                         if (change == SET)
2926                                 goto out_badmix;
2927                         change = ADD;
2928                         tok++;
2929                 } else if (*tok == '-') {
2930                         if (change == SET)
2931                                 goto out_badmix;
2932                         change = REMOVE;
2933                         tok++;
2934                 } else {
2935                         if (change != SET && change != DEFAULT)
2936                                 goto out_badmix;
2937                         change = SET;
2938                 }
2939
2940                 for (i = 0; i < imax; ++i) {
2941                         if (strcmp(tok, all_output_options[i].str) == 0)
2942                                 break;
2943                 }
2944                 if (i == imax && strcmp(tok, "flags") == 0) {
2945                         print_flags = change != REMOVE;
2946                         continue;
2947                 }
2948                 if (i == imax) {
2949                         fprintf(stderr, "Invalid field requested.\n");
2950                         rc = -EINVAL;
2951                         goto out;
2952                 }
2953
2954                 if (type == -1) {
2955                         /* add user option to all events types for
2956                          * which it is valid
2957                          */
2958                         for (j = 0; j < OUTPUT_TYPE_MAX; ++j) {
2959                                 if (output[j].invalid_fields & all_output_options[i].field) {
2960                                         pr_warning("\'%s\' not valid for %s events. Ignoring.\n",
2961                                                    all_output_options[i].str, event_type(j));
2962                                 } else {
2963                                         if (change == REMOVE) {
2964                                                 output[j].fields &= ~all_output_options[i].field;
2965                                                 output[j].user_set_fields &= ~all_output_options[i].field;
2966                                                 output[j].user_unset_fields |= all_output_options[i].field;
2967                                         } else {
2968                                                 output[j].fields |= all_output_options[i].field;
2969                                                 output[j].user_set_fields |= all_output_options[i].field;
2970                                                 output[j].user_unset_fields &= ~all_output_options[i].field;
2971                                         }
2972                                         output[j].user_set = true;
2973                                         output[j].wildcard_set = true;
2974                                 }
2975                         }
2976                 } else {
2977                         if (output[type].invalid_fields & all_output_options[i].field) {
2978                                 fprintf(stderr, "\'%s\' not valid for %s events.\n",
2979                                          all_output_options[i].str, event_type(type));
2980
2981                                 rc = -EINVAL;
2982                                 goto out;
2983                         }
2984                         if (change == REMOVE)
2985                                 output[type].fields &= ~all_output_options[i].field;
2986                         else
2987                                 output[type].fields |= all_output_options[i].field;
2988                         output[type].user_set = true;
2989                         output[type].wildcard_set = true;
2990                 }
2991         }
2992
2993         if (type >= 0) {
2994                 if (output[type].fields == 0) {
2995                         pr_debug("No fields requested for %s type. "
2996                                  "Events will not be displayed.\n", event_type(type));
2997                 }
2998         }
2999         goto out;
3000
3001 out_badmix:
3002         fprintf(stderr, "Cannot mix +-field with overridden fields\n");
3003         rc = -EINVAL;
3004 out:
3005         free(str);
3006         return rc;
3007 }
3008
3009 #define for_each_lang(scripts_path, scripts_dir, lang_dirent)           \
3010         while ((lang_dirent = readdir(scripts_dir)) != NULL)            \
3011                 if ((lang_dirent->d_type == DT_DIR ||                   \
3012                      (lang_dirent->d_type == DT_UNKNOWN &&              \
3013                       is_directory(scripts_path, lang_dirent))) &&      \
3014                     (strcmp(lang_dirent->d_name, ".")) &&               \
3015                     (strcmp(lang_dirent->d_name, "..")))
3016
3017 #define for_each_script(lang_path, lang_dir, script_dirent)             \
3018         while ((script_dirent = readdir(lang_dir)) != NULL)             \
3019                 if (script_dirent->d_type != DT_DIR &&                  \
3020                     (script_dirent->d_type != DT_UNKNOWN ||             \
3021                      !is_directory(lang_path, script_dirent)))
3022
3023
3024 #define RECORD_SUFFIX                   "-record"
3025 #define REPORT_SUFFIX                   "-report"
3026
3027 struct script_desc {
3028         struct list_head        node;
3029         char                    *name;
3030         char                    *half_liner;
3031         char                    *args;
3032 };
3033
3034 static LIST_HEAD(script_descs);
3035
3036 static struct script_desc *script_desc__new(const char *name)
3037 {
3038         struct script_desc *s = zalloc(sizeof(*s));
3039
3040         if (s != NULL && name)
3041                 s->name = strdup(name);
3042
3043         return s;
3044 }
3045
3046 static void script_desc__delete(struct script_desc *s)
3047 {
3048         zfree(&s->name);
3049         zfree(&s->half_liner);
3050         zfree(&s->args);
3051         free(s);
3052 }
3053
3054 static void script_desc__add(struct script_desc *s)
3055 {
3056         list_add_tail(&s->node, &script_descs);
3057 }
3058
3059 static struct script_desc *script_desc__find(const char *name)
3060 {
3061         struct script_desc *s;
3062
3063         list_for_each_entry(s, &script_descs, node)
3064                 if (strcasecmp(s->name, name) == 0)
3065                         return s;
3066         return NULL;
3067 }
3068
3069 static struct script_desc *script_desc__findnew(const char *name)
3070 {
3071         struct script_desc *s = script_desc__find(name);
3072
3073         if (s)
3074                 return s;
3075
3076         s = script_desc__new(name);
3077         if (!s)
3078                 return NULL;
3079
3080         script_desc__add(s);
3081
3082         return s;
3083 }
3084
3085 static const char *ends_with(const char *str, const char *suffix)
3086 {
3087         size_t suffix_len = strlen(suffix);
3088         const char *p = str;
3089
3090         if (strlen(str) > suffix_len) {
3091                 p = str + strlen(str) - suffix_len;
3092                 if (!strncmp(p, suffix, suffix_len))
3093                         return p;
3094         }
3095
3096         return NULL;
3097 }
3098
3099 static int read_script_info(struct script_desc *desc, const char *filename)
3100 {
3101         char line[BUFSIZ], *p;
3102         FILE *fp;
3103
3104         fp = fopen(filename, "r");
3105         if (!fp)
3106                 return -1;
3107
3108         while (fgets(line, sizeof(line), fp)) {
3109                 p = skip_spaces(line);
3110                 if (strlen(p) == 0)
3111                         continue;
3112                 if (*p != '#')
3113                         continue;
3114                 p++;
3115                 if (strlen(p) && *p == '!')
3116                         continue;
3117
3118                 p = skip_spaces(p);
3119                 if (strlen(p) && p[strlen(p) - 1] == '\n')
3120                         p[strlen(p) - 1] = '\0';
3121
3122                 if (!strncmp(p, "description:", strlen("description:"))) {
3123                         p += strlen("description:");
3124                         desc->half_liner = strdup(skip_spaces(p));
3125                         continue;
3126                 }
3127
3128                 if (!strncmp(p, "args:", strlen("args:"))) {
3129                         p += strlen("args:");
3130                         desc->args = strdup(skip_spaces(p));
3131                         continue;
3132                 }
3133         }
3134
3135         fclose(fp);
3136
3137         return 0;
3138 }
3139
3140 static char *get_script_root(struct dirent *script_dirent, const char *suffix)
3141 {
3142         char *script_root, *str;
3143
3144         script_root = strdup(script_dirent->d_name);
3145         if (!script_root)
3146                 return NULL;
3147
3148         str = (char *)ends_with(script_root, suffix);
3149         if (!str) {
3150                 free(script_root);
3151                 return NULL;
3152         }
3153
3154         *str = '\0';
3155         return script_root;
3156 }
3157
3158 static int list_available_scripts(const struct option *opt __maybe_unused,
3159                                   const char *s __maybe_unused,
3160                                   int unset __maybe_unused)
3161 {
3162         struct dirent *script_dirent, *lang_dirent;
3163         char scripts_path[MAXPATHLEN];
3164         DIR *scripts_dir, *lang_dir;
3165         char script_path[MAXPATHLEN];
3166         char lang_path[MAXPATHLEN];
3167         struct script_desc *desc;
3168         char first_half[BUFSIZ];
3169         char *script_root;
3170
3171         snprintf(scripts_path, MAXPATHLEN, "%s/scripts", get_argv_exec_path());
3172
3173         scripts_dir = opendir(scripts_path);
3174         if (!scripts_dir) {
3175                 fprintf(stdout,
3176                         "open(%s) failed.\n"
3177                         "Check \"PERF_EXEC_PATH\" env to set scripts dir.\n",
3178                         scripts_path);
3179                 exit(-1);
3180         }
3181
3182         for_each_lang(scripts_path, scripts_dir, lang_dirent) {
3183                 scnprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path,
3184                           lang_dirent->d_name);
3185                 lang_dir = opendir(lang_path);
3186                 if (!lang_dir)
3187                         continue;
3188
3189                 for_each_script(lang_path, lang_dir, script_dirent) {
3190                         script_root = get_script_root(script_dirent, REPORT_SUFFIX);
3191                         if (script_root) {
3192                                 desc = script_desc__findnew(script_root);
3193                                 scnprintf(script_path, MAXPATHLEN, "%s/%s",
3194                                           lang_path, script_dirent->d_name);
3195                                 read_script_info(desc, script_path);
3196                                 free(script_root);
3197                         }
3198                 }
3199         }
3200
3201         fprintf(stdout, "List of available trace scripts:\n");
3202         list_for_each_entry(desc, &script_descs, node) {
3203                 sprintf(first_half, "%s %s", desc->name,
3204                         desc->args ? desc->args : "");
3205                 fprintf(stdout, "  %-36s %s\n", first_half,
3206                         desc->half_liner ? desc->half_liner : "");
3207         }
3208
3209         exit(0);
3210 }
3211
3212 static int add_dlarg(const struct option *opt __maybe_unused,
3213                      const char *s, int unset __maybe_unused)
3214 {
3215         char *arg = strdup(s);
3216         void *a;
3217
3218         if (!arg)
3219                 return -1;
3220
3221         a = realloc(dlargv, sizeof(dlargv[0]) * (dlargc + 1));
3222         if (!a) {
3223                 free(arg);
3224                 return -1;
3225         }
3226
3227         dlargv = a;
3228         dlargv[dlargc++] = arg;
3229
3230         return 0;
3231 }
3232
3233 static void free_dlarg(void)
3234 {
3235         while (dlargc--)
3236                 free(dlargv[dlargc]);
3237         free(dlargv);
3238 }
3239
3240 /*
3241  * Some scripts specify the required events in their "xxx-record" file,
3242  * this function will check if the events in perf.data match those
3243  * mentioned in the "xxx-record".
3244  *
3245  * Fixme: All existing "xxx-record" are all in good formats "-e event ",
3246  * which is covered well now. And new parsing code should be added to
3247  * cover the future complex formats like event groups etc.
3248  */
3249 static int check_ev_match(char *dir_name, char *scriptname,
3250                         struct perf_session *session)
3251 {
3252         char filename[MAXPATHLEN], evname[128];
3253         char line[BUFSIZ], *p;
3254         struct evsel *pos;
3255         int match, len;
3256         FILE *fp;
3257
3258         scnprintf(filename, MAXPATHLEN, "%s/bin/%s-record", dir_name, scriptname);
3259
3260         fp = fopen(filename, "r");
3261         if (!fp)
3262                 return -1;
3263
3264         while (fgets(line, sizeof(line), fp)) {
3265                 p = skip_spaces(line);
3266                 if (*p == '#')
3267                         continue;
3268
3269                 while (strlen(p)) {
3270                         p = strstr(p, "-e");
3271                         if (!p)
3272                                 break;
3273
3274                         p += 2;
3275                         p = skip_spaces(p);
3276                         len = strcspn(p, " \t");
3277                         if (!len)
3278                                 break;
3279
3280                         snprintf(evname, len + 1, "%s", p);
3281
3282                         match = 0;
3283                         evlist__for_each_entry(session->evlist, pos) {
3284                                 if (!strcmp(evsel__name(pos), evname)) {
3285                                         match = 1;
3286                                         break;
3287                                 }
3288                         }
3289
3290                         if (!match) {
3291                                 fclose(fp);
3292                                 return -1;
3293                         }
3294                 }
3295         }
3296
3297         fclose(fp);
3298         return 0;
3299 }
3300
3301 /*
3302  * Return -1 if none is found, otherwise the actual scripts number.
3303  *
3304  * Currently the only user of this function is the script browser, which
3305  * will list all statically runnable scripts, select one, execute it and
3306  * show the output in a perf browser.
3307  */
3308 int find_scripts(char **scripts_array, char **scripts_path_array, int num,
3309                  int pathlen)
3310 {
3311         struct dirent *script_dirent, *lang_dirent;
3312         char scripts_path[MAXPATHLEN], lang_path[MAXPATHLEN];
3313         DIR *scripts_dir, *lang_dir;
3314         struct perf_session *session;
3315         struct perf_data data = {
3316                 .path = input_name,
3317                 .mode = PERF_DATA_MODE_READ,
3318         };
3319         char *temp;
3320         int i = 0;
3321
3322         session = perf_session__new(&data, NULL);
3323         if (IS_ERR(session))
3324                 return PTR_ERR(session);
3325
3326         snprintf(scripts_path, MAXPATHLEN, "%s/scripts", get_argv_exec_path());
3327
3328         scripts_dir = opendir(scripts_path);
3329         if (!scripts_dir) {
3330                 perf_session__delete(session);
3331                 return -1;
3332         }
3333
3334         for_each_lang(scripts_path, scripts_dir, lang_dirent) {
3335                 scnprintf(lang_path, MAXPATHLEN, "%s/%s", scripts_path,
3336                           lang_dirent->d_name);
3337 #ifndef HAVE_LIBPERL_SUPPORT
3338                 if (strstr(lang_path, "perl"))
3339                         continue;
3340 #endif
3341 #ifndef HAVE_LIBPYTHON_SUPPORT
3342                 if (strstr(lang_path, "python"))
3343                         continue;
3344 #endif
3345
3346                 lang_dir = opendir(lang_path);
3347                 if (!lang_dir)
3348                         continue;
3349
3350                 for_each_script(lang_path, lang_dir, script_dirent) {
3351                         /* Skip those real time scripts: xxxtop.p[yl] */
3352                         if (strstr(script_dirent->d_name, "top."))
3353                                 continue;
3354                         if (i >= num)
3355                                 break;
3356                         snprintf(scripts_path_array[i], pathlen, "%s/%s",
3357                                 lang_path,
3358                                 script_dirent->d_name);
3359                         temp = strchr(script_dirent->d_name, '.');
3360                         snprintf(scripts_array[i],
3361                                 (temp - script_dirent->d_name) + 1,
3362                                 "%s", script_dirent->d_name);
3363
3364                         if (check_ev_match(lang_path,
3365                                         scripts_array[i], session))
3366                                 continue;
3367
3368                         i++;
3369                 }
3370                 closedir(lang_dir);
3371         }
3372
3373         closedir(scripts_dir);
3374         perf_session__delete(session);
3375         return i;
3376 }
3377
3378 static char *get_script_path(const char *script_root, const char *suffix)
3379 {
3380         struct dirent *script_dirent, *lang_dirent;
3381         char scripts_path[MAXPATHLEN];
3382         char script_path[MAXPATHLEN];
3383         DIR *scripts_dir, *lang_dir;
3384         char lang_path[MAXPATHLEN];
3385         char *__script_root;
3386
3387         snprintf(scripts_path, MAXPATHLEN, "%s/scripts", get_argv_exec_path());
3388
3389         scripts_dir = opendir(scripts_path);
3390         if (!scripts_dir)
3391                 return NULL;
3392
3393         for_each_lang(scripts_path, scripts_dir, lang_dirent) {
3394                 scnprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path,
3395                           lang_dirent->d_name);
3396                 lang_dir = opendir(lang_path);
3397                 if (!lang_dir)
3398                         continue;
3399
3400                 for_each_script(lang_path, lang_dir, script_dirent) {
3401                         __script_root = get_script_root(script_dirent, suffix);
3402                         if (__script_root && !strcmp(script_root, __script_root)) {
3403                                 free(__script_root);
3404                                 closedir(scripts_dir);
3405                                 scnprintf(script_path, MAXPATHLEN, "%s/%s",
3406                                           lang_path, script_dirent->d_name);
3407                                 closedir(lang_dir);
3408                                 return strdup(script_path);
3409                         }
3410                         free(__script_root);
3411                 }
3412                 closedir(lang_dir);
3413         }
3414         closedir(scripts_dir);
3415
3416         return NULL;
3417 }
3418
3419 static bool is_top_script(const char *script_path)
3420 {
3421         return ends_with(script_path, "top") != NULL;
3422 }
3423
3424 static int has_required_arg(char *script_path)
3425 {
3426         struct script_desc *desc;
3427         int n_args = 0;
3428         char *p;
3429
3430         desc = script_desc__new(NULL);
3431
3432         if (read_script_info(desc, script_path))
3433                 goto out;
3434
3435         if (!desc->args)
3436                 goto out;
3437
3438         for (p = desc->args; *p; p++)
3439                 if (*p == '<')
3440                         n_args++;
3441 out:
3442         script_desc__delete(desc);
3443
3444         return n_args;
3445 }
3446
3447 static int have_cmd(int argc, const char **argv)
3448 {
3449         char **__argv = malloc(sizeof(const char *) * argc);
3450
3451         if (!__argv) {
3452                 pr_err("malloc failed\n");
3453                 return -1;
3454         }
3455
3456         memcpy(__argv, argv, sizeof(const char *) * argc);
3457         argc = parse_options(argc, (const char **)__argv, record_options,
3458                              NULL, PARSE_OPT_STOP_AT_NON_OPTION);
3459         free(__argv);
3460
3461         system_wide = (argc == 0);
3462
3463         return 0;
3464 }
3465
3466 static void script__setup_sample_type(struct perf_script *script)
3467 {
3468         struct perf_session *session = script->session;
3469         u64 sample_type = evlist__combined_sample_type(session->evlist);
3470
3471         callchain_param_setup(sample_type, perf_env__arch(session->machines.host.env));
3472
3473         if (script->stitch_lbr && (callchain_param.record_mode != CALLCHAIN_LBR)) {
3474                 pr_warning("Can't find LBR callchain. Switch off --stitch-lbr.\n"
3475                            "Please apply --call-graph lbr when recording.\n");
3476                 script->stitch_lbr = false;
3477         }
3478 }
3479
3480 static int process_stat_round_event(struct perf_session *session,
3481                                     union perf_event *event)
3482 {
3483         struct perf_record_stat_round *round = &event->stat_round;
3484         struct evsel *counter;
3485
3486         evlist__for_each_entry(session->evlist, counter) {
3487                 perf_stat_process_counter(&stat_config, counter);
3488                 process_stat(counter, round->time);
3489         }
3490
3491         process_stat_interval(round->time);
3492         return 0;
3493 }
3494
3495 static int process_stat_config_event(struct perf_session *session __maybe_unused,
3496                                      union perf_event *event)
3497 {
3498         perf_event__read_stat_config(&stat_config, &event->stat_config);
3499         return 0;
3500 }
3501
3502 static int set_maps(struct perf_script *script)
3503 {
3504         struct evlist *evlist = script->session->evlist;
3505
3506         if (!script->cpus || !script->threads)
3507                 return 0;
3508
3509         if (WARN_ONCE(script->allocated, "stats double allocation\n"))
3510                 return -EINVAL;
3511
3512         perf_evlist__set_maps(&evlist->core, script->cpus, script->threads);
3513
3514         if (evlist__alloc_stats(evlist, true))
3515                 return -ENOMEM;
3516
3517         script->allocated = true;
3518         return 0;
3519 }
3520
3521 static
3522 int process_thread_map_event(struct perf_session *session,
3523                              union perf_event *event)
3524 {
3525         struct perf_tool *tool = session->tool;
3526         struct perf_script *script = container_of(tool, struct perf_script, tool);
3527
3528         if (script->threads) {
3529                 pr_warning("Extra thread map event, ignoring.\n");
3530                 return 0;
3531         }
3532
3533         script->threads = thread_map__new_event(&event->thread_map);
3534         if (!script->threads)
3535                 return -ENOMEM;
3536
3537         return set_maps(script);
3538 }
3539
3540 static
3541 int process_cpu_map_event(struct perf_session *session,
3542                           union perf_event *event)
3543 {
3544         struct perf_tool *tool = session->tool;
3545         struct perf_script *script = container_of(tool, struct perf_script, tool);
3546
3547         if (script->cpus) {
3548                 pr_warning("Extra cpu map event, ignoring.\n");
3549                 return 0;
3550         }
3551
3552         script->cpus = cpu_map__new_data(&event->cpu_map.data);
3553         if (!script->cpus)
3554                 return -ENOMEM;
3555
3556         return set_maps(script);
3557 }
3558
3559 static int process_feature_event(struct perf_session *session,
3560                                  union perf_event *event)
3561 {
3562         if (event->feat.feat_id < HEADER_LAST_FEATURE)
3563                 return perf_event__process_feature(session, event);
3564         return 0;
3565 }
3566
3567 #ifdef HAVE_AUXTRACE_SUPPORT
3568 static int perf_script__process_auxtrace_info(struct perf_session *session,
3569                                               union perf_event *event)
3570 {
3571         struct perf_tool *tool = session->tool;
3572
3573         int ret = perf_event__process_auxtrace_info(session, event);
3574
3575         if (ret == 0) {
3576                 struct perf_script *script = container_of(tool, struct perf_script, tool);
3577
3578                 ret = perf_script__setup_per_event_dump(script);
3579         }
3580
3581         return ret;
3582 }
3583 #else
3584 #define perf_script__process_auxtrace_info 0
3585 #endif
3586
3587 static int parse_insn_trace(const struct option *opt __maybe_unused,
3588                             const char *str __maybe_unused,
3589                             int unset __maybe_unused)
3590 {
3591         parse_output_fields(NULL, "+insn,-event,-period", 0);
3592         itrace_parse_synth_opts(opt, "i0ns", 0);
3593         symbol_conf.nanosecs = true;
3594         return 0;
3595 }
3596
3597 static int parse_xed(const struct option *opt __maybe_unused,
3598                      const char *str __maybe_unused,
3599                      int unset __maybe_unused)
3600 {
3601         if (isatty(1))
3602                 force_pager("xed -F insn: -A -64 | less");
3603         else
3604                 force_pager("xed -F insn: -A -64");
3605         return 0;
3606 }
3607
3608 static int parse_call_trace(const struct option *opt __maybe_unused,
3609                             const char *str __maybe_unused,
3610                             int unset __maybe_unused)
3611 {
3612         parse_output_fields(NULL, "-ip,-addr,-event,-period,+callindent", 0);
3613         itrace_parse_synth_opts(opt, "cewp", 0);
3614         symbol_conf.nanosecs = true;
3615         symbol_conf.pad_output_len_dso = 50;
3616         return 0;
3617 }
3618
3619 static int parse_callret_trace(const struct option *opt __maybe_unused,
3620                             const char *str __maybe_unused,
3621                             int unset __maybe_unused)
3622 {
3623         parse_output_fields(NULL, "-ip,-addr,-event,-period,+callindent,+flags", 0);
3624         itrace_parse_synth_opts(opt, "crewp", 0);
3625         symbol_conf.nanosecs = true;
3626         return 0;
3627 }
3628
3629 int cmd_script(int argc, const char **argv)
3630 {
3631         bool show_full_info = false;
3632         bool header = false;
3633         bool header_only = false;
3634         bool script_started = false;
3635         char *rec_script_path = NULL;
3636         char *rep_script_path = NULL;
3637         struct perf_session *session;
3638         struct itrace_synth_opts itrace_synth_opts = {
3639                 .set = false,
3640                 .default_no_sample = true,
3641         };
3642         struct utsname uts;
3643         char *script_path = NULL;
3644         const char *dlfilter_file = NULL;
3645         const char **__argv;
3646         int i, j, err = 0;
3647         struct perf_script script = {
3648                 .tool = {
3649                         .sample          = process_sample_event,
3650                         .mmap            = perf_event__process_mmap,
3651                         .mmap2           = perf_event__process_mmap2,
3652                         .comm            = perf_event__process_comm,
3653                         .namespaces      = perf_event__process_namespaces,
3654                         .cgroup          = perf_event__process_cgroup,
3655                         .exit            = perf_event__process_exit,
3656                         .fork            = perf_event__process_fork,
3657                         .attr            = process_attr,
3658                         .event_update   = perf_event__process_event_update,
3659                         .tracing_data    = perf_event__process_tracing_data,
3660                         .feature         = process_feature_event,
3661                         .build_id        = perf_event__process_build_id,
3662                         .id_index        = perf_event__process_id_index,
3663                         .auxtrace_info   = perf_script__process_auxtrace_info,
3664                         .auxtrace        = perf_event__process_auxtrace,
3665                         .auxtrace_error  = perf_event__process_auxtrace_error,
3666                         .stat            = perf_event__process_stat_event,
3667                         .stat_round      = process_stat_round_event,
3668                         .stat_config     = process_stat_config_event,
3669                         .thread_map      = process_thread_map_event,
3670                         .cpu_map         = process_cpu_map_event,
3671                         .throttle        = process_throttle_event,
3672                         .unthrottle      = process_throttle_event,
3673                         .ordered_events  = true,
3674                         .ordering_requires_timestamps = true,
3675                 },
3676         };
3677         struct perf_data data = {
3678                 .mode = PERF_DATA_MODE_READ,
3679         };
3680         const struct option options[] = {
3681         OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
3682                     "dump raw trace in ASCII"),
3683         OPT_INCR('v', "verbose", &verbose,
3684                  "be more verbose (show symbol address, etc)"),
3685         OPT_BOOLEAN('L', "Latency", &latency_format,
3686                     "show latency attributes (irqs/preemption disabled, etc)"),
3687         OPT_CALLBACK_NOOPT('l', "list", NULL, NULL, "list available scripts",
3688                            list_available_scripts),
3689         OPT_CALLBACK_NOOPT(0, "list-dlfilters", NULL, NULL, "list available dlfilters",
3690                            list_available_dlfilters),
3691         OPT_CALLBACK('s', "script", NULL, "name",
3692                      "script file name (lang:script name, script name, or *)",
3693                      parse_scriptname),
3694         OPT_STRING('g', "gen-script", &generate_script_lang, "lang",
3695                    "generate perf-script.xx script in specified language"),
3696         OPT_STRING(0, "dlfilter", &dlfilter_file, "file", "filter .so file name"),
3697         OPT_CALLBACK(0, "dlarg", NULL, "argument", "filter argument",
3698                      add_dlarg),
3699         OPT_STRING('i', "input", &input_name, "file", "input file name"),
3700         OPT_BOOLEAN('d', "debug-mode", &debug_mode,
3701                    "do various checks like samples ordering and lost events"),
3702         OPT_BOOLEAN(0, "header", &header, "Show data header."),
3703         OPT_BOOLEAN(0, "header-only", &header_only, "Show only data header."),
3704         OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
3705                    "file", "vmlinux pathname"),
3706         OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name,
3707                    "file", "kallsyms pathname"),
3708         OPT_BOOLEAN('G', "hide-call-graph", &no_callchain,
3709                     "When printing symbols do not display call chain"),
3710         OPT_CALLBACK(0, "symfs", NULL, "directory",
3711                      "Look for files with symbols relative to this directory",
3712                      symbol__config_symfs),
3713         OPT_CALLBACK('F', "fields", NULL, "str",
3714                      "comma separated output fields prepend with 'type:'. "
3715                      "+field to add and -field to remove."
3716                      "Valid types: hw,sw,trace,raw,synth. "
3717                      "Fields: comm,tid,pid,time,cpu,event,trace,ip,sym,dso,"
3718                      "addr,symoff,srcline,period,iregs,uregs,brstack,"
3719                      "brstacksym,flags,bpf-output,brstackinsn,brstackoff,"
3720                      "callindent,insn,insnlen,synth,phys_addr,metric,misc,ipc,tod,"
3721                      "data_page_size,code_page_size,ins_lat",
3722                      parse_output_fields),
3723         OPT_BOOLEAN('a', "all-cpus", &system_wide,
3724                     "system-wide collection from all CPUs"),
3725         OPT_STRING(0, "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
3726                    "only consider symbols in these DSOs"),
3727         OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
3728                    "only consider these symbols"),
3729         OPT_INTEGER(0, "addr-range", &symbol_conf.addr_range,
3730                     "Use with -S to list traced records within address range"),
3731         OPT_CALLBACK_OPTARG(0, "insn-trace", &itrace_synth_opts, NULL, NULL,
3732                         "Decode instructions from itrace", parse_insn_trace),
3733         OPT_CALLBACK_OPTARG(0, "xed", NULL, NULL, NULL,
3734                         "Run xed disassembler on output", parse_xed),
3735         OPT_CALLBACK_OPTARG(0, "call-trace", &itrace_synth_opts, NULL, NULL,
3736                         "Decode calls from from itrace", parse_call_trace),
3737         OPT_CALLBACK_OPTARG(0, "call-ret-trace", &itrace_synth_opts, NULL, NULL,
3738                         "Decode calls and returns from itrace", parse_callret_trace),
3739         OPT_STRING(0, "graph-function", &symbol_conf.graph_function, "symbol[,symbol...]",
3740                         "Only print symbols and callees with --call-trace/--call-ret-trace"),
3741         OPT_STRING(0, "stop-bt", &symbol_conf.bt_stop_list_str, "symbol[,symbol...]",
3742                    "Stop display of callgraph at these symbols"),
3743         OPT_STRING('C', "cpu", &cpu_list, "cpu", "list of cpus to profile"),
3744         OPT_STRING('c', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
3745                    "only display events for these comms"),
3746         OPT_STRING(0, "pid", &symbol_conf.pid_list_str, "pid[,pid...]",
3747                    "only consider symbols in these pids"),
3748         OPT_STRING(0, "tid", &symbol_conf.tid_list_str, "tid[,tid...]",
3749                    "only consider symbols in these tids"),
3750         OPT_UINTEGER(0, "max-stack", &scripting_max_stack,
3751                      "Set the maximum stack depth when parsing the callchain, "
3752                      "anything beyond the specified depth will be ignored. "
3753                      "Default: kernel.perf_event_max_stack or " __stringify(PERF_MAX_STACK_DEPTH)),
3754         OPT_BOOLEAN(0, "reltime", &reltime, "Show time stamps relative to start"),
3755         OPT_BOOLEAN(0, "deltatime", &deltatime, "Show time stamps relative to previous event"),
3756         OPT_BOOLEAN('I', "show-info", &show_full_info,
3757                     "display extended information from perf.data file"),
3758         OPT_BOOLEAN('\0', "show-kernel-path", &symbol_conf.show_kernel_path,
3759                     "Show the path of [kernel.kallsyms]"),
3760         OPT_BOOLEAN('\0', "show-task-events", &script.show_task_events,
3761                     "Show the fork/comm/exit events"),
3762         OPT_BOOLEAN('\0', "show-mmap-events", &script.show_mmap_events,
3763                     "Show the mmap events"),
3764         OPT_BOOLEAN('\0', "show-switch-events", &script.show_switch_events,
3765                     "Show context switch events (if recorded)"),
3766         OPT_BOOLEAN('\0', "show-namespace-events", &script.show_namespace_events,
3767                     "Show namespace events (if recorded)"),
3768         OPT_BOOLEAN('\0', "show-cgroup-events", &script.show_cgroup_events,
3769                     "Show cgroup events (if recorded)"),
3770         OPT_BOOLEAN('\0', "show-lost-events", &script.show_lost_events,
3771                     "Show lost events (if recorded)"),
3772         OPT_BOOLEAN('\0', "show-round-events", &script.show_round_events,
3773                     "Show round events (if recorded)"),
3774         OPT_BOOLEAN('\0', "show-bpf-events", &script.show_bpf_events,
3775                     "Show bpf related events (if recorded)"),
3776         OPT_BOOLEAN('\0', "show-text-poke-events", &script.show_text_poke_events,
3777                     "Show text poke related events (if recorded)"),
3778         OPT_BOOLEAN('\0', "per-event-dump", &script.per_event_dump,
3779                     "Dump trace output to files named by the monitored events"),
3780         OPT_BOOLEAN('f', "force", &symbol_conf.force, "don't complain, do it"),
3781         OPT_INTEGER(0, "max-blocks", &max_blocks,
3782                     "Maximum number of code blocks to dump with brstackinsn"),
3783         OPT_BOOLEAN(0, "ns", &symbol_conf.nanosecs,
3784                     "Use 9 decimal places when displaying time"),
3785         OPT_CALLBACK_OPTARG(0, "itrace", &itrace_synth_opts, NULL, "opts",
3786                             "Instruction Tracing options\n" ITRACE_HELP,
3787                             itrace_parse_synth_opts),
3788         OPT_BOOLEAN(0, "full-source-path", &srcline_full_filename,
3789                         "Show full source file name path for source lines"),
3790         OPT_BOOLEAN(0, "demangle", &symbol_conf.demangle,
3791                         "Enable symbol demangling"),
3792         OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf.demangle_kernel,
3793                         "Enable kernel symbol demangling"),
3794         OPT_STRING(0, "time", &script.time_str, "str",
3795                    "Time span of interest (start,stop)"),
3796         OPT_BOOLEAN(0, "inline", &symbol_conf.inline_name,
3797                     "Show inline function"),
3798         OPT_STRING(0, "guestmount", &symbol_conf.guestmount, "directory",
3799                    "guest mount directory under which every guest os"
3800                    " instance has a subdir"),
3801         OPT_STRING(0, "guestvmlinux", &symbol_conf.default_guest_vmlinux_name,
3802                    "file", "file saving guest os vmlinux"),
3803         OPT_STRING(0, "guestkallsyms", &symbol_conf.default_guest_kallsyms,
3804                    "file", "file saving guest os /proc/kallsyms"),
3805         OPT_STRING(0, "guestmodules", &symbol_conf.default_guest_modules,
3806                    "file", "file saving guest os /proc/modules"),
3807         OPT_BOOLEAN('\0', "stitch-lbr", &script.stitch_lbr,
3808                     "Enable LBR callgraph stitching approach"),
3809         OPTS_EVSWITCH(&script.evswitch),
3810         OPT_END()
3811         };
3812         const char * const script_subcommands[] = { "record", "report", NULL };
3813         const char *script_usage[] = {
3814                 "perf script [<options>]",
3815                 "perf script [<options>] record <script> [<record-options>] <command>",
3816                 "perf script [<options>] report <script> [script-args]",
3817                 "perf script [<options>] <script> [<record-options>] <command>",
3818                 "perf script [<options>] <top-script> [script-args]",
3819                 NULL
3820         };
3821
3822         perf_set_singlethreaded();
3823
3824         setup_scripting();
3825
3826         argc = parse_options_subcommand(argc, argv, options, script_subcommands, script_usage,
3827                              PARSE_OPT_STOP_AT_NON_OPTION);
3828
3829         if (symbol_conf.guestmount ||
3830             symbol_conf.default_guest_vmlinux_name ||
3831             symbol_conf.default_guest_kallsyms ||
3832             symbol_conf.default_guest_modules) {
3833                 /*
3834                  * Enable guest sample processing.
3835                  */
3836                 perf_guest = true;
3837         }
3838
3839         data.path  = input_name;
3840         data.force = symbol_conf.force;
3841
3842         if (symbol__validate_sym_arguments())
3843                 return -1;
3844
3845         if (argc > 1 && !strncmp(argv[0], "rec", strlen("rec"))) {
3846                 rec_script_path = get_script_path(argv[1], RECORD_SUFFIX);
3847                 if (!rec_script_path)
3848                         return cmd_record(argc, argv);
3849         }
3850
3851         if (argc > 1 && !strncmp(argv[0], "rep", strlen("rep"))) {
3852                 rep_script_path = get_script_path(argv[1], REPORT_SUFFIX);
3853                 if (!rep_script_path) {
3854                         fprintf(stderr,
3855                                 "Please specify a valid report script"
3856                                 "(see 'perf script -l' for listing)\n");
3857                         return -1;
3858                 }
3859         }
3860
3861         if (reltime && deltatime) {
3862                 fprintf(stderr,
3863                         "reltime and deltatime - the two don't get along well. "
3864                         "Please limit to --reltime or --deltatime.\n");
3865                 return -1;
3866         }
3867
3868         if ((itrace_synth_opts.callchain || itrace_synth_opts.add_callchain) &&
3869             itrace_synth_opts.callchain_sz > scripting_max_stack)
3870                 scripting_max_stack = itrace_synth_opts.callchain_sz;
3871
3872         /* make sure PERF_EXEC_PATH is set for scripts */
3873         set_argv_exec_path(get_argv_exec_path());
3874
3875         if (argc && !script_name && !rec_script_path && !rep_script_path) {
3876                 int live_pipe[2];
3877                 int rep_args;
3878                 pid_t pid;
3879
3880                 rec_script_path = get_script_path(argv[0], RECORD_SUFFIX);
3881                 rep_script_path = get_script_path(argv[0], REPORT_SUFFIX);
3882
3883                 if (!rec_script_path && !rep_script_path) {
3884                         script_name = find_script(argv[0]);
3885                         if (script_name) {
3886                                 argc -= 1;
3887                                 argv += 1;
3888                                 goto script_found;
3889                         }
3890                         usage_with_options_msg(script_usage, options,
3891                                 "Couldn't find script `%s'\n\n See perf"
3892                                 " script -l for available scripts.\n", argv[0]);
3893                 }
3894
3895                 if (is_top_script(argv[0])) {
3896                         rep_args = argc - 1;
3897                 } else {
3898                         int rec_args;
3899
3900                         rep_args = has_required_arg(rep_script_path);
3901                         rec_args = (argc - 1) - rep_args;
3902                         if (rec_args < 0) {
3903                                 usage_with_options_msg(script_usage, options,
3904                                         "`%s' script requires options."
3905                                         "\n\n See perf script -l for available "
3906                                         "scripts and options.\n", argv[0]);
3907                         }
3908                 }
3909
3910                 if (pipe(live_pipe) < 0) {
3911                         perror("failed to create pipe");
3912                         return -1;
3913                 }
3914
3915                 pid = fork();
3916                 if (pid < 0) {
3917                         perror("failed to fork");
3918                         return -1;
3919                 }
3920
3921                 if (!pid) {
3922                         j = 0;
3923
3924                         dup2(live_pipe[1], 1);
3925                         close(live_pipe[0]);
3926
3927                         if (is_top_script(argv[0])) {
3928                                 system_wide = true;
3929                         } else if (!system_wide) {
3930                                 if (have_cmd(argc - rep_args, &argv[rep_args]) != 0) {
3931                                         err = -1;
3932                                         goto out;
3933                                 }
3934                         }
3935
3936                         __argv = malloc((argc + 6) * sizeof(const char *));
3937                         if (!__argv) {
3938                                 pr_err("malloc failed\n");
3939                                 err = -ENOMEM;
3940                                 goto out;
3941                         }
3942
3943                         __argv[j++] = "/bin/sh";
3944                         __argv[j++] = rec_script_path;
3945                         if (system_wide)
3946                                 __argv[j++] = "-a";
3947                         __argv[j++] = "-q";
3948                         __argv[j++] = "-o";
3949                         __argv[j++] = "-";
3950                         for (i = rep_args + 1; i < argc; i++)
3951                                 __argv[j++] = argv[i];
3952                         __argv[j++] = NULL;
3953
3954                         execvp("/bin/sh", (char **)__argv);
3955                         free(__argv);
3956                         exit(-1);
3957                 }
3958
3959                 dup2(live_pipe[0], 0);
3960                 close(live_pipe[1]);
3961
3962                 __argv = malloc((argc + 4) * sizeof(const char *));
3963                 if (!__argv) {
3964                         pr_err("malloc failed\n");
3965                         err = -ENOMEM;
3966                         goto out;
3967                 }
3968
3969                 j = 0;
3970                 __argv[j++] = "/bin/sh";
3971                 __argv[j++] = rep_script_path;
3972                 for (i = 1; i < rep_args + 1; i++)
3973                         __argv[j++] = argv[i];
3974                 __argv[j++] = "-i";
3975                 __argv[j++] = "-";
3976                 __argv[j++] = NULL;
3977
3978                 execvp("/bin/sh", (char **)__argv);
3979                 free(__argv);
3980                 exit(-1);
3981         }
3982 script_found:
3983         if (rec_script_path)
3984                 script_path = rec_script_path;
3985         if (rep_script_path)
3986                 script_path = rep_script_path;
3987
3988         if (script_path) {
3989                 j = 0;
3990
3991                 if (!rec_script_path)
3992                         system_wide = false;
3993                 else if (!system_wide) {
3994                         if (have_cmd(argc - 1, &argv[1]) != 0) {
3995                                 err = -1;
3996                                 goto out;
3997                         }
3998                 }
3999
4000                 __argv = malloc((argc + 2) * sizeof(const char *));
4001                 if (!__argv) {
4002                         pr_err("malloc failed\n");
4003                         err = -ENOMEM;
4004                         goto out;
4005                 }
4006
4007                 __argv[j++] = "/bin/sh";
4008                 __argv[j++] = script_path;
4009                 if (system_wide)
4010                         __argv[j++] = "-a";
4011                 for (i = 2; i < argc; i++)
4012                         __argv[j++] = argv[i];
4013                 __argv[j++] = NULL;
4014
4015                 execvp("/bin/sh", (char **)__argv);
4016                 free(__argv);
4017                 exit(-1);
4018         }
4019
4020         if (dlfilter_file) {
4021                 dlfilter = dlfilter__new(dlfilter_file, dlargc, dlargv);
4022                 if (!dlfilter)
4023                         return -1;
4024         }
4025
4026         if (!script_name) {
4027                 setup_pager();
4028                 use_browser = 0;
4029         }
4030
4031         session = perf_session__new(&data, &script.tool);
4032         if (IS_ERR(session))
4033                 return PTR_ERR(session);
4034
4035         if (header || header_only) {
4036                 script.tool.show_feat_hdr = SHOW_FEAT_HEADER;
4037                 perf_session__fprintf_info(session, stdout, show_full_info);
4038                 if (header_only)
4039                         goto out_delete;
4040         }
4041         if (show_full_info)
4042                 script.tool.show_feat_hdr = SHOW_FEAT_HEADER_FULL_INFO;
4043
4044         if (symbol__init(&session->header.env) < 0)
4045                 goto out_delete;
4046
4047         uname(&uts);
4048         if (data.is_pipe) { /* Assume pipe_mode indicates native_arch */
4049                 native_arch = true;
4050         } else if (session->header.env.arch) {
4051                 if (!strcmp(uts.machine, session->header.env.arch))
4052                         native_arch = true;
4053                 else if (!strcmp(uts.machine, "x86_64") &&
4054                          !strcmp(session->header.env.arch, "i386"))
4055                         native_arch = true;
4056         }
4057
4058         script.session = session;
4059         script__setup_sample_type(&script);
4060
4061         if ((output[PERF_TYPE_HARDWARE].fields & PERF_OUTPUT_CALLINDENT) ||
4062             symbol_conf.graph_function)
4063                 itrace_synth_opts.thread_stack = true;
4064
4065         session->itrace_synth_opts = &itrace_synth_opts;
4066
4067         if (cpu_list) {
4068                 err = perf_session__cpu_bitmap(session, cpu_list, cpu_bitmap);
4069                 if (err < 0)
4070                         goto out_delete;
4071                 itrace_synth_opts.cpu_bitmap = cpu_bitmap;
4072         }
4073
4074         if (!no_callchain)
4075                 symbol_conf.use_callchain = true;
4076         else
4077                 symbol_conf.use_callchain = false;
4078
4079         if (session->tevent.pevent &&
4080             tep_set_function_resolver(session->tevent.pevent,
4081                                       machine__resolve_kernel_addr,
4082                                       &session->machines.host) < 0) {
4083                 pr_err("%s: failed to set libtraceevent function resolver\n", __func__);
4084                 err = -1;
4085                 goto out_delete;
4086         }
4087
4088         if (generate_script_lang) {
4089                 struct stat perf_stat;
4090                 int input;
4091
4092                 if (output_set_by_user()) {
4093                         fprintf(stderr,
4094                                 "custom fields not supported for generated scripts");
4095                         err = -EINVAL;
4096                         goto out_delete;
4097                 }
4098
4099                 input = open(data.path, O_RDONLY);      /* input_name */
4100                 if (input < 0) {
4101                         err = -errno;
4102                         perror("failed to open file");
4103                         goto out_delete;
4104                 }
4105
4106                 err = fstat(input, &perf_stat);
4107                 if (err < 0) {
4108                         perror("failed to stat file");
4109                         goto out_delete;
4110                 }
4111
4112                 if (!perf_stat.st_size) {
4113                         fprintf(stderr, "zero-sized file, nothing to do!\n");
4114                         goto out_delete;
4115                 }
4116
4117                 scripting_ops = script_spec__lookup(generate_script_lang);
4118                 if (!scripting_ops) {
4119                         fprintf(stderr, "invalid language specifier");
4120                         err = -ENOENT;
4121                         goto out_delete;
4122                 }
4123
4124                 err = scripting_ops->generate_script(session->tevent.pevent,
4125                                                      "perf-script");
4126                 goto out_delete;
4127         }
4128
4129         err = dlfilter__start(dlfilter, session);
4130         if (err)
4131                 goto out_delete;
4132
4133         if (script_name) {
4134                 err = scripting_ops->start_script(script_name, argc, argv, session);
4135                 if (err)
4136                         goto out_delete;
4137                 pr_debug("perf script started with script %s\n\n", script_name);
4138                 script_started = true;
4139         }
4140
4141
4142         err = perf_session__check_output_opt(session);
4143         if (err < 0)
4144                 goto out_delete;
4145
4146         if (script.time_str) {
4147                 err = perf_time__parse_for_ranges_reltime(script.time_str, session,
4148                                                   &script.ptime_range,
4149                                                   &script.range_size,
4150                                                   &script.range_num,
4151                                                   reltime);
4152                 if (err < 0)
4153                         goto out_delete;
4154
4155                 itrace_synth_opts__set_time_range(&itrace_synth_opts,
4156                                                   script.ptime_range,
4157                                                   script.range_num);
4158         }
4159
4160         err = evswitch__init(&script.evswitch, session->evlist, stderr);
4161         if (err)
4162                 goto out_delete;
4163
4164         if (zstd_init(&(session->zstd_data), 0) < 0)
4165                 pr_warning("Decompression initialization failed. Reported data may be incomplete.\n");
4166
4167         err = __cmd_script(&script);
4168
4169         flush_scripting();
4170
4171 out_delete:
4172         if (script.ptime_range) {
4173                 itrace_synth_opts__clear_time_range(&itrace_synth_opts);
4174                 zfree(&script.ptime_range);
4175         }
4176
4177         zstd_fini(&(session->zstd_data));
4178         evlist__free_stats(session->evlist);
4179         perf_session__delete(session);
4180         perf_script__exit(&script);
4181
4182         if (script_started)
4183                 cleanup_scripting();
4184         dlfilter__cleanup(dlfilter);
4185         free_dlarg();
4186 out:
4187         return err;
4188 }