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