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