tools/perf/builtin-script.c

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