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                    allocated;
1493         bool                    per_event_dump;
1494         struct cpu_map          *cpus;
1495         struct thread_map       *threads;
1496         int                     name_width;
1497         const char              *time_str;
1498         struct perf_time_interval *ptime_range;
1499         int                     range_size;
1500         int                     range_num;
1501 };
1502
1503 static int perf_evlist__max_name_len(struct perf_evlist *evlist)
1504 {
1505         struct perf_evsel *evsel;
1506         int max = 0;
1507
1508         evlist__for_each_entry(evlist, evsel) {
1509                 int len = strlen(perf_evsel__name(evsel));
1510
1511                 max = MAX(len, max);
1512         }
1513
1514         return max;
1515 }
1516
1517 static int data_src__fprintf(u64 data_src, FILE *fp)
1518 {
1519         struct mem_info mi = { .data_src.val = data_src };
1520         char decode[100];
1521         char out[100];
1522         static int maxlen;
1523         int len;
1524
1525         perf_script__meminfo_scnprintf(decode, 100, &mi);
1526
1527         len = scnprintf(out, 100, "%16" PRIx64 " %s", data_src, decode);
1528         if (maxlen < len)
1529                 maxlen = len;
1530
1531         return fprintf(fp, "%-*s", maxlen, out);
1532 }
1533
1534 struct metric_ctx {
1535         struct perf_sample      *sample;
1536         struct thread           *thread;
1537         struct perf_evsel       *evsel;
1538         FILE                    *fp;
1539 };
1540
1541 static void script_print_metric(void *ctx, const char *color,
1542                                 const char *fmt,
1543                                 const char *unit, double val)
1544 {
1545         struct metric_ctx *mctx = ctx;
1546
1547         if (!fmt)
1548                 return;
1549         perf_sample__fprintf_start(mctx->sample, mctx->thread, mctx->evsel,
1550                                    PERF_RECORD_SAMPLE, mctx->fp);
1551         fputs("\tmetric: ", mctx->fp);
1552         if (color)
1553                 color_fprintf(mctx->fp, color, fmt, val);
1554         else
1555                 printf(fmt, val);
1556         fprintf(mctx->fp, " %s\n", unit);
1557 }
1558
1559 static void script_new_line(void *ctx)
1560 {
1561         struct metric_ctx *mctx = ctx;
1562
1563         perf_sample__fprintf_start(mctx->sample, mctx->thread, mctx->evsel,
1564                                    PERF_RECORD_SAMPLE, mctx->fp);
1565         fputs("\tmetric: ", mctx->fp);
1566 }
1567
1568 static void perf_sample__fprint_metric(struct perf_script *script,
1569                                        struct thread *thread,
1570                                        struct perf_evsel *evsel,
1571                                        struct perf_sample *sample,
1572                                        FILE *fp)
1573 {
1574         struct perf_stat_output_ctx ctx = {
1575                 .print_metric = script_print_metric,
1576                 .new_line = script_new_line,
1577                 .ctx = &(struct metric_ctx) {
1578                                 .sample = sample,
1579                                 .thread = thread,
1580                                 .evsel  = evsel,
1581                                 .fp     = fp,
1582                          },
1583                 .force_header = false,
1584         };
1585         struct perf_evsel *ev2;
1586         static bool init;
1587         u64 val;
1588
1589         if (!init) {
1590                 perf_stat__init_shadow_stats();
1591                 init = true;
1592         }
1593         if (!evsel->stats)
1594                 perf_evlist__alloc_stats(script->session->evlist, false);
1595         if (evsel_script(evsel->leader)->gnum++ == 0)
1596                 perf_stat__reset_shadow_stats();
1597         val = sample->period * evsel->scale;
1598         perf_stat__update_shadow_stats(evsel,
1599                                        val,
1600                                        sample->cpu,
1601                                        &rt_stat);
1602         evsel_script(evsel)->val = val;
1603         if (evsel_script(evsel->leader)->gnum == evsel->leader->nr_members) {
1604                 for_each_group_member (ev2, evsel->leader) {
1605                         perf_stat__print_shadow_stats(ev2,
1606                                                       evsel_script(ev2)->val,
1607                                                       sample->cpu,
1608                                                       &ctx,
1609                                                       NULL,
1610                                                       &rt_stat);
1611                 }
1612                 evsel_script(evsel->leader)->gnum = 0;
1613         }
1614 }
1615
1616 static void process_event(struct perf_script *script,
1617                           struct perf_sample *sample, struct perf_evsel *evsel,
1618                           struct addr_location *al,
1619                           struct machine *machine)
1620 {
1621         struct thread *thread = al->thread;
1622         struct perf_event_attr *attr = &evsel->attr;
1623         unsigned int type = output_type(attr->type);
1624         struct perf_evsel_script *es = evsel->priv;
1625         FILE *fp = es->fp;
1626
1627         if (output[type].fields == 0)
1628                 return;
1629
1630         ++es->samples;
1631
1632         perf_sample__fprintf_start(sample, thread, evsel,
1633                                    PERF_RECORD_SAMPLE, fp);
1634
1635         if (PRINT_FIELD(PERIOD))
1636                 fprintf(fp, "%10" PRIu64 " ", sample->period);
1637
1638         if (PRINT_FIELD(EVNAME)) {
1639                 const char *evname = perf_evsel__name(evsel);
1640
1641                 if (!script->name_width)
1642                         script->name_width = perf_evlist__max_name_len(script->session->evlist);
1643
1644                 fprintf(fp, "%*s: ", script->name_width, evname ?: "[unknown]");
1645         }
1646
1647         if (print_flags)
1648                 perf_sample__fprintf_flags(sample->flags, fp);
1649
1650         if (is_bts_event(attr)) {
1651                 perf_sample__fprintf_bts(sample, evsel, thread, al, machine, fp);
1652                 return;
1653         }
1654
1655         if (PRINT_FIELD(TRACE)) {
1656                 event_format__fprintf(evsel->tp_format, sample->cpu,
1657                                       sample->raw_data, sample->raw_size, fp);
1658         }
1659
1660         if (attr->type == PERF_TYPE_SYNTH && PRINT_FIELD(SYNTH))
1661                 perf_sample__fprintf_synth(sample, evsel, fp);
1662
1663         if (PRINT_FIELD(ADDR))
1664                 perf_sample__fprintf_addr(sample, thread, attr, fp);
1665
1666         if (PRINT_FIELD(DATA_SRC))
1667                 data_src__fprintf(sample->data_src, fp);
1668
1669         if (PRINT_FIELD(WEIGHT))
1670                 fprintf(fp, "%16" PRIu64, sample->weight);
1671
1672         if (PRINT_FIELD(IP)) {
1673                 struct callchain_cursor *cursor = NULL;
1674
1675                 if (symbol_conf.use_callchain && sample->callchain &&
1676                     thread__resolve_callchain(al->thread, &callchain_cursor, evsel,
1677                                               sample, NULL, NULL, scripting_max_stack) == 0)
1678                         cursor = &callchain_cursor;
1679
1680                 fputc(cursor ? '\n' : ' ', fp);
1681                 sample__fprintf_sym(sample, al, 0, output[type].print_ip_opts, cursor, fp);
1682         }
1683
1684         if (PRINT_FIELD(IREGS))
1685                 perf_sample__fprintf_iregs(sample, attr, fp);
1686
1687         if (PRINT_FIELD(UREGS))
1688                 perf_sample__fprintf_uregs(sample, attr, fp);
1689
1690         if (PRINT_FIELD(BRSTACK))
1691                 perf_sample__fprintf_brstack(sample, thread, attr, fp);
1692         else if (PRINT_FIELD(BRSTACKSYM))
1693                 perf_sample__fprintf_brstacksym(sample, thread, attr, fp);
1694         else if (PRINT_FIELD(BRSTACKOFF))
1695                 perf_sample__fprintf_brstackoff(sample, thread, attr, fp);
1696
1697         if (perf_evsel__is_bpf_output(evsel) && PRINT_FIELD(BPF_OUTPUT))
1698                 perf_sample__fprintf_bpf_output(sample, fp);
1699         perf_sample__fprintf_insn(sample, attr, thread, machine, fp);
1700
1701         if (PRINT_FIELD(PHYS_ADDR))
1702                 fprintf(fp, "%16" PRIx64, sample->phys_addr);
1703         fprintf(fp, "\n");
1704
1705         if (PRINT_FIELD(METRIC))
1706                 perf_sample__fprint_metric(script, thread, evsel, sample, fp);
1707 }
1708
1709 static struct scripting_ops     *scripting_ops;
1710
1711 static void __process_stat(struct perf_evsel *counter, u64 tstamp)
1712 {
1713         int nthreads = thread_map__nr(counter->threads);
1714         int ncpus = perf_evsel__nr_cpus(counter);
1715         int cpu, thread;
1716         static int header_printed;
1717
1718         if (counter->system_wide)
1719                 nthreads = 1;
1720
1721         if (!header_printed) {
1722                 printf("%3s %8s %15s %15s %15s %15s %s\n",
1723                        "CPU", "THREAD", "VAL", "ENA", "RUN", "TIME", "EVENT");
1724                 header_printed = 1;
1725         }
1726
1727         for (thread = 0; thread < nthreads; thread++) {
1728                 for (cpu = 0; cpu < ncpus; cpu++) {
1729                         struct perf_counts_values *counts;
1730
1731                         counts = perf_counts(counter->counts, cpu, thread);
1732
1733                         printf("%3d %8d %15" PRIu64 " %15" PRIu64 " %15" PRIu64 " %15" PRIu64 " %s\n",
1734                                 counter->cpus->map[cpu],
1735                                 thread_map__pid(counter->threads, thread),
1736                                 counts->val,
1737                                 counts->ena,
1738                                 counts->run,
1739                                 tstamp,
1740                                 perf_evsel__name(counter));
1741                 }
1742         }
1743 }
1744
1745 static void process_stat(struct perf_evsel *counter, u64 tstamp)
1746 {
1747         if (scripting_ops && scripting_ops->process_stat)
1748                 scripting_ops->process_stat(&stat_config, counter, tstamp);
1749         else
1750                 __process_stat(counter, tstamp);
1751 }
1752
1753 static void process_stat_interval(u64 tstamp)
1754 {
1755         if (scripting_ops && scripting_ops->process_stat_interval)
1756                 scripting_ops->process_stat_interval(tstamp);
1757 }
1758
1759 static void setup_scripting(void)
1760 {
1761         setup_perl_scripting();
1762         setup_python_scripting();
1763 }
1764
1765 static int flush_scripting(void)
1766 {
1767         return scripting_ops ? scripting_ops->flush_script() : 0;
1768 }
1769
1770 static int cleanup_scripting(void)
1771 {
1772         pr_debug("\nperf script stopped\n");
1773
1774         return scripting_ops ? scripting_ops->stop_script() : 0;
1775 }
1776
1777 static int process_sample_event(struct perf_tool *tool,
1778                                 union perf_event *event,
1779                                 struct perf_sample *sample,
1780                                 struct perf_evsel *evsel,
1781                                 struct machine *machine)
1782 {
1783         struct perf_script *scr = container_of(tool, struct perf_script, tool);
1784         struct addr_location al;
1785
1786         if (perf_time__ranges_skip_sample(scr->ptime_range, scr->range_num,
1787                                           sample->time)) {
1788                 return 0;
1789         }
1790
1791         if (debug_mode) {
1792                 if (sample->time < last_timestamp) {
1793                         pr_err("Samples misordered, previous: %" PRIu64
1794                                 " this: %" PRIu64 "\n", last_timestamp,
1795                                 sample->time);
1796                         nr_unordered++;
1797                 }
1798                 last_timestamp = sample->time;
1799                 return 0;
1800         }
1801
1802         if (machine__resolve(machine, &al, sample) < 0) {
1803                 pr_err("problem processing %d event, skipping it.\n",
1804                        event->header.type);
1805                 return -1;
1806         }
1807
1808         if (al.filtered)
1809                 goto out_put;
1810
1811         if (cpu_list && !test_bit(sample->cpu, cpu_bitmap))
1812                 goto out_put;
1813
1814         if (scripting_ops)
1815                 scripting_ops->process_event(event, sample, evsel, &al);
1816         else
1817                 process_event(scr, sample, evsel, &al, machine);
1818
1819 out_put:
1820         addr_location__put(&al);
1821         return 0;
1822 }
1823
1824 static int process_attr(struct perf_tool *tool, union perf_event *event,
1825                         struct perf_evlist **pevlist)
1826 {
1827         struct perf_script *scr = container_of(tool, struct perf_script, tool);
1828         struct perf_evlist *evlist;
1829         struct perf_evsel *evsel, *pos;
1830         int err;
1831
1832         err = perf_event__process_attr(tool, event, pevlist);
1833         if (err)
1834                 return err;
1835
1836         evlist = *pevlist;
1837         evsel = perf_evlist__last(*pevlist);
1838
1839         if (evsel->attr.type >= PERF_TYPE_MAX &&
1840             evsel->attr.type != PERF_TYPE_SYNTH)
1841                 return 0;
1842
1843         evlist__for_each_entry(evlist, pos) {
1844                 if (pos->attr.type == evsel->attr.type && pos != evsel)
1845                         return 0;
1846         }
1847
1848         set_print_ip_opts(&evsel->attr);
1849
1850         if (evsel->attr.sample_type)
1851                 err = perf_evsel__check_attr(evsel, scr->session);
1852
1853         return err;
1854 }
1855
1856 static int process_comm_event(struct perf_tool *tool,
1857                               union perf_event *event,
1858                               struct perf_sample *sample,
1859                               struct machine *machine)
1860 {
1861         struct thread *thread;
1862         struct perf_script *script = container_of(tool, struct perf_script, tool);
1863         struct perf_session *session = script->session;
1864         struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
1865         int ret = -1;
1866
1867         thread = machine__findnew_thread(machine, event->comm.pid, event->comm.tid);
1868         if (thread == NULL) {
1869                 pr_debug("problem processing COMM event, skipping it.\n");
1870                 return -1;
1871         }
1872
1873         if (perf_event__process_comm(tool, event, sample, machine) < 0)
1874                 goto out;
1875
1876         if (!evsel->attr.sample_id_all) {
1877                 sample->cpu = 0;
1878                 sample->time = 0;
1879                 sample->tid = event->comm.tid;
1880                 sample->pid = event->comm.pid;
1881         }
1882         perf_sample__fprintf_start(sample, thread, evsel,
1883                                    PERF_RECORD_COMM, stdout);
1884         perf_event__fprintf(event, stdout);
1885         ret = 0;
1886 out:
1887         thread__put(thread);
1888         return ret;
1889 }
1890
1891 static int process_namespaces_event(struct perf_tool *tool,
1892                                     union perf_event *event,
1893                                     struct perf_sample *sample,
1894                                     struct machine *machine)
1895 {
1896         struct thread *thread;
1897         struct perf_script *script = container_of(tool, struct perf_script, tool);
1898         struct perf_session *session = script->session;
1899         struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
1900         int ret = -1;
1901
1902         thread = machine__findnew_thread(machine, event->namespaces.pid,
1903                                          event->namespaces.tid);
1904         if (thread == NULL) {
1905                 pr_debug("problem processing NAMESPACES event, skipping it.\n");
1906                 return -1;
1907         }
1908
1909         if (perf_event__process_namespaces(tool, event, sample, machine) < 0)
1910                 goto out;
1911
1912         if (!evsel->attr.sample_id_all) {
1913                 sample->cpu = 0;
1914                 sample->time = 0;
1915                 sample->tid = event->namespaces.tid;
1916                 sample->pid = event->namespaces.pid;
1917         }
1918         perf_sample__fprintf_start(sample, thread, evsel,
1919                                    PERF_RECORD_NAMESPACES, stdout);
1920         perf_event__fprintf(event, stdout);
1921         ret = 0;
1922 out:
1923         thread__put(thread);
1924         return ret;
1925 }
1926
1927 static int process_fork_event(struct perf_tool *tool,
1928                               union perf_event *event,
1929                               struct perf_sample *sample,
1930                               struct machine *machine)
1931 {
1932         struct thread *thread;
1933         struct perf_script *script = container_of(tool, struct perf_script, tool);
1934         struct perf_session *session = script->session;
1935         struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
1936
1937         if (perf_event__process_fork(tool, event, sample, machine) < 0)
1938                 return -1;
1939
1940         thread = machine__findnew_thread(machine, event->fork.pid, event->fork.tid);
1941         if (thread == NULL) {
1942                 pr_debug("problem processing FORK event, skipping it.\n");
1943                 return -1;
1944         }
1945
1946         if (!evsel->attr.sample_id_all) {
1947                 sample->cpu = 0;
1948                 sample->time = event->fork.time;
1949                 sample->tid = event->fork.tid;
1950                 sample->pid = event->fork.pid;
1951         }
1952         perf_sample__fprintf_start(sample, thread, evsel,
1953                                    PERF_RECORD_FORK, stdout);
1954         perf_event__fprintf(event, stdout);
1955         thread__put(thread);
1956
1957         return 0;
1958 }
1959 static int process_exit_event(struct perf_tool *tool,
1960                               union perf_event *event,
1961                               struct perf_sample *sample,
1962                               struct machine *machine)
1963 {
1964         int err = 0;
1965         struct thread *thread;
1966         struct perf_script *script = container_of(tool, struct perf_script, tool);
1967         struct perf_session *session = script->session;
1968         struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
1969
1970         thread = machine__findnew_thread(machine, event->fork.pid, event->fork.tid);
1971         if (thread == NULL) {
1972                 pr_debug("problem processing EXIT event, skipping it.\n");
1973                 return -1;
1974         }
1975
1976         if (!evsel->attr.sample_id_all) {
1977                 sample->cpu = 0;
1978                 sample->time = 0;
1979                 sample->tid = event->fork.tid;
1980                 sample->pid = event->fork.pid;
1981         }
1982         perf_sample__fprintf_start(sample, thread, evsel,
1983                                    PERF_RECORD_EXIT, stdout);
1984         perf_event__fprintf(event, stdout);
1985
1986         if (perf_event__process_exit(tool, event, sample, machine) < 0)
1987                 err = -1;
1988
1989         thread__put(thread);
1990         return err;
1991 }
1992
1993 static int process_mmap_event(struct perf_tool *tool,
1994                               union perf_event *event,
1995                               struct perf_sample *sample,
1996                               struct machine *machine)
1997 {
1998         struct thread *thread;
1999         struct perf_script *script = container_of(tool, struct perf_script, tool);
2000         struct perf_session *session = script->session;
2001         struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
2002
2003         if (perf_event__process_mmap(tool, event, sample, machine) < 0)
2004                 return -1;
2005
2006         thread = machine__findnew_thread(machine, event->mmap.pid, event->mmap.tid);
2007         if (thread == NULL) {
2008                 pr_debug("problem processing MMAP event, skipping it.\n");
2009                 return -1;
2010         }
2011
2012         if (!evsel->attr.sample_id_all) {
2013                 sample->cpu = 0;
2014                 sample->time = 0;
2015                 sample->tid = event->mmap.tid;
2016                 sample->pid = event->mmap.pid;
2017         }
2018         perf_sample__fprintf_start(sample, thread, evsel,
2019                                    PERF_RECORD_MMAP, stdout);
2020         perf_event__fprintf(event, stdout);
2021         thread__put(thread);
2022         return 0;
2023 }
2024
2025 static int process_mmap2_event(struct perf_tool *tool,
2026                               union perf_event *event,
2027                               struct perf_sample *sample,
2028                               struct machine *machine)
2029 {
2030         struct thread *thread;
2031         struct perf_script *script = container_of(tool, struct perf_script, tool);
2032         struct perf_session *session = script->session;
2033         struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
2034
2035         if (perf_event__process_mmap2(tool, event, sample, machine) < 0)
2036                 return -1;
2037
2038         thread = machine__findnew_thread(machine, event->mmap2.pid, event->mmap2.tid);
2039         if (thread == NULL) {
2040                 pr_debug("problem processing MMAP2 event, skipping it.\n");
2041                 return -1;
2042         }
2043
2044         if (!evsel->attr.sample_id_all) {
2045                 sample->cpu = 0;
2046                 sample->time = 0;
2047                 sample->tid = event->mmap2.tid;
2048                 sample->pid = event->mmap2.pid;
2049         }
2050         perf_sample__fprintf_start(sample, thread, evsel,
2051                                    PERF_RECORD_MMAP2, stdout);
2052         perf_event__fprintf(event, stdout);
2053         thread__put(thread);
2054         return 0;
2055 }
2056
2057 static int process_switch_event(struct perf_tool *tool,
2058                                 union perf_event *event,
2059                                 struct perf_sample *sample,
2060                                 struct machine *machine)
2061 {
2062         struct thread *thread;
2063         struct perf_script *script = container_of(tool, struct perf_script, tool);
2064         struct perf_session *session = script->session;
2065         struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
2066
2067         if (perf_event__process_switch(tool, event, sample, machine) < 0)
2068                 return -1;
2069
2070         thread = machine__findnew_thread(machine, sample->pid,
2071                                          sample->tid);
2072         if (thread == NULL) {
2073                 pr_debug("problem processing SWITCH event, skipping it.\n");
2074                 return -1;
2075         }
2076
2077         perf_sample__fprintf_start(sample, thread, evsel,
2078                                    PERF_RECORD_SWITCH, stdout);
2079         perf_event__fprintf(event, stdout);
2080         thread__put(thread);
2081         return 0;
2082 }
2083
2084 static int
2085 process_lost_event(struct perf_tool *tool,
2086                    union perf_event *event,
2087                    struct perf_sample *sample,
2088                    struct machine *machine)
2089 {
2090         struct perf_script *script = container_of(tool, struct perf_script, tool);
2091         struct perf_session *session = script->session;
2092         struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
2093         struct thread *thread;
2094
2095         thread = machine__findnew_thread(machine, sample->pid,
2096                                          sample->tid);
2097         if (thread == NULL)
2098                 return -1;
2099
2100         perf_sample__fprintf_start(sample, thread, evsel,
2101                                    PERF_RECORD_LOST, stdout);
2102         perf_event__fprintf(event, stdout);
2103         thread__put(thread);
2104         return 0;
2105 }
2106
2107 static void sig_handler(int sig __maybe_unused)
2108 {
2109         session_done = 1;
2110 }
2111
2112 static void perf_script__fclose_per_event_dump(struct perf_script *script)
2113 {
2114         struct perf_evlist *evlist = script->session->evlist;
2115         struct perf_evsel *evsel;
2116
2117         evlist__for_each_entry(evlist, evsel) {
2118                 if (!evsel->priv)
2119                         break;
2120                 perf_evsel_script__delete(evsel->priv);
2121                 evsel->priv = NULL;
2122         }
2123 }
2124
2125 static int perf_script__fopen_per_event_dump(struct perf_script *script)
2126 {
2127         struct perf_evsel *evsel;
2128
2129         evlist__for_each_entry(script->session->evlist, evsel) {
2130                 /*
2131                  * Already setup? I.e. we may be called twice in cases like
2132                  * Intel PT, one for the intel_pt// and dummy events, then
2133                  * for the evsels syntheized from the auxtrace info.
2134                  *
2135                  * Ses perf_script__process_auxtrace_info.
2136                  */
2137                 if (evsel->priv != NULL)
2138                         continue;
2139
2140                 evsel->priv = perf_evsel_script__new(evsel, script->session->data);
2141                 if (evsel->priv == NULL)
2142                         goto out_err_fclose;
2143         }
2144
2145         return 0;
2146
2147 out_err_fclose:
2148         perf_script__fclose_per_event_dump(script);
2149         return -1;
2150 }
2151
2152 static int perf_script__setup_per_event_dump(struct perf_script *script)
2153 {
2154         struct perf_evsel *evsel;
2155         static struct perf_evsel_script es_stdout;
2156
2157         if (script->per_event_dump)
2158                 return perf_script__fopen_per_event_dump(script);
2159
2160         es_stdout.fp = stdout;
2161
2162         evlist__for_each_entry(script->session->evlist, evsel)
2163                 evsel->priv = &es_stdout;
2164
2165         return 0;
2166 }
2167
2168 static void perf_script__exit_per_event_dump_stats(struct perf_script *script)
2169 {
2170         struct perf_evsel *evsel;
2171
2172         evlist__for_each_entry(script->session->evlist, evsel) {
2173                 struct perf_evsel_script *es = evsel->priv;
2174
2175                 perf_evsel_script__fprintf(es, stdout);
2176                 perf_evsel_script__delete(es);
2177                 evsel->priv = NULL;
2178         }
2179 }
2180
2181 static int __cmd_script(struct perf_script *script)
2182 {
2183         int ret;
2184
2185         signal(SIGINT, sig_handler);
2186
2187         /* override event processing functions */
2188         if (script->show_task_events) {
2189                 script->tool.comm = process_comm_event;
2190                 script->tool.fork = process_fork_event;
2191                 script->tool.exit = process_exit_event;
2192         }
2193         if (script->show_mmap_events) {
2194                 script->tool.mmap = process_mmap_event;
2195                 script->tool.mmap2 = process_mmap2_event;
2196         }
2197         if (script->show_switch_events)
2198                 script->tool.context_switch = process_switch_event;
2199         if (script->show_namespace_events)
2200                 script->tool.namespaces = process_namespaces_event;
2201         if (script->show_lost_events)
2202                 script->tool.lost = process_lost_event;
2203
2204         if (perf_script__setup_per_event_dump(script)) {
2205                 pr_err("Couldn't create the per event dump files\n");
2206                 return -1;
2207         }
2208
2209         ret = perf_session__process_events(script->session);
2210
2211         if (script->per_event_dump)
2212                 perf_script__exit_per_event_dump_stats(script);
2213
2214         if (debug_mode)
2215                 pr_err("Misordered timestamps: %" PRIu64 "\n", nr_unordered);
2216
2217         return ret;
2218 }
2219
2220 struct script_spec {
2221         struct list_head        node;
2222         struct scripting_ops    *ops;
2223         char                    spec[0];
2224 };
2225
2226 static LIST_HEAD(script_specs);
2227
2228 static struct script_spec *script_spec__new(const char *spec,
2229                                             struct scripting_ops *ops)
2230 {
2231         struct script_spec *s = malloc(sizeof(*s) + strlen(spec) + 1);
2232
2233         if (s != NULL) {
2234                 strcpy(s->spec, spec);
2235                 s->ops = ops;
2236         }
2237
2238         return s;
2239 }
2240
2241 static void script_spec__add(struct script_spec *s)
2242 {
2243         list_add_tail(&s->node, &script_specs);
2244 }
2245
2246 static struct script_spec *script_spec__find(const char *spec)
2247 {
2248         struct script_spec *s;
2249
2250         list_for_each_entry(s, &script_specs, node)
2251                 if (strcasecmp(s->spec, spec) == 0)
2252                         return s;
2253         return NULL;
2254 }
2255
2256 int script_spec_register(const char *spec, struct scripting_ops *ops)
2257 {
2258         struct script_spec *s;
2259
2260         s = script_spec__find(spec);
2261         if (s)
2262                 return -1;
2263
2264         s = script_spec__new(spec, ops);
2265         if (!s)
2266                 return -1;
2267         else
2268                 script_spec__add(s);
2269
2270         return 0;
2271 }
2272
2273 static struct scripting_ops *script_spec__lookup(const char *spec)
2274 {
2275         struct script_spec *s = script_spec__find(spec);
2276         if (!s)
2277                 return NULL;
2278
2279         return s->ops;
2280 }
2281
2282 static void list_available_languages(void)
2283 {
2284         struct script_spec *s;
2285
2286         fprintf(stderr, "\n");
2287         fprintf(stderr, "Scripting language extensions (used in "
2288                 "perf script -s [spec:]script.[spec]):\n\n");
2289
2290         list_for_each_entry(s, &script_specs, node)
2291                 fprintf(stderr, "  %-42s [%s]\n", s->spec, s->ops->name);
2292
2293         fprintf(stderr, "\n");
2294 }
2295
2296 static int parse_scriptname(const struct option *opt __maybe_unused,
2297                             const char *str, int unset __maybe_unused)
2298 {
2299         char spec[PATH_MAX];
2300         const char *script, *ext;
2301         int len;
2302
2303         if (strcmp(str, "lang") == 0) {
2304                 list_available_languages();
2305                 exit(0);
2306         }
2307
2308         script = strchr(str, ':');
2309         if (script) {
2310                 len = script - str;
2311                 if (len >= PATH_MAX) {
2312                         fprintf(stderr, "invalid language specifier");
2313                         return -1;
2314                 }
2315                 strncpy(spec, str, len);
2316                 spec[len] = '\0';
2317                 scripting_ops = script_spec__lookup(spec);
2318                 if (!scripting_ops) {
2319                         fprintf(stderr, "invalid language specifier");
2320                         return -1;
2321                 }
2322                 script++;
2323         } else {
2324                 script = str;
2325                 ext = strrchr(script, '.');
2326                 if (!ext) {
2327                         fprintf(stderr, "invalid script extension");
2328                         return -1;
2329                 }
2330                 scripting_ops = script_spec__lookup(++ext);
2331                 if (!scripting_ops) {
2332                         fprintf(stderr, "invalid script extension");
2333                         return -1;
2334                 }
2335         }
2336
2337         script_name = strdup(script);
2338
2339         return 0;
2340 }
2341
2342 static int parse_output_fields(const struct option *opt __maybe_unused,
2343                             const char *arg, int unset __maybe_unused)
2344 {
2345         char *tok, *strtok_saveptr = NULL;
2346         int i, imax = ARRAY_SIZE(all_output_options);
2347         int j;
2348         int rc = 0;
2349         char *str = strdup(arg);
2350         int type = -1;
2351         enum { DEFAULT, SET, ADD, REMOVE } change = DEFAULT;
2352
2353         if (!str)
2354                 return -ENOMEM;
2355
2356         /* first word can state for which event type the user is specifying
2357          * the fields. If no type exists, the specified fields apply to all
2358          * event types found in the file minus the invalid fields for a type.
2359          */
2360         tok = strchr(str, ':');
2361         if (tok) {
2362                 *tok = '\0';
2363                 tok++;
2364                 if (!strcmp(str, "hw"))
2365                         type = PERF_TYPE_HARDWARE;
2366                 else if (!strcmp(str, "sw"))
2367                         type = PERF_TYPE_SOFTWARE;
2368                 else if (!strcmp(str, "trace"))
2369                         type = PERF_TYPE_TRACEPOINT;
2370                 else if (!strcmp(str, "raw"))
2371                         type = PERF_TYPE_RAW;
2372                 else if (!strcmp(str, "break"))
2373                         type = PERF_TYPE_BREAKPOINT;
2374                 else if (!strcmp(str, "synth"))
2375                         type = OUTPUT_TYPE_SYNTH;
2376                 else {
2377                         fprintf(stderr, "Invalid event type in field string.\n");
2378                         rc = -EINVAL;
2379                         goto out;
2380                 }
2381
2382                 if (output[type].user_set)
2383                         pr_warning("Overriding previous field request for %s events.\n",
2384                                    event_type(type));
2385
2386                 output[type].fields = 0;
2387                 output[type].user_set = true;
2388                 output[type].wildcard_set = false;
2389
2390         } else {
2391                 tok = str;
2392                 if (strlen(str) == 0) {
2393                         fprintf(stderr,
2394                                 "Cannot set fields to 'none' for all event types.\n");
2395                         rc = -EINVAL;
2396                         goto out;
2397                 }
2398
2399                 /* Don't override defaults for +- */
2400                 if (strchr(str, '+') || strchr(str, '-'))
2401                         goto parse;
2402
2403                 if (output_set_by_user())
2404                         pr_warning("Overriding previous field request for all events.\n");
2405
2406                 for (j = 0; j < OUTPUT_TYPE_MAX; ++j) {
2407                         output[j].fields = 0;
2408                         output[j].user_set = true;
2409                         output[j].wildcard_set = true;
2410                 }
2411         }
2412
2413 parse:
2414         for (tok = strtok_r(tok, ",", &strtok_saveptr); tok; tok = strtok_r(NULL, ",", &strtok_saveptr)) {
2415                 if (*tok == '+') {
2416                         if (change == SET)
2417                                 goto out_badmix;
2418                         change = ADD;
2419                         tok++;
2420                 } else if (*tok == '-') {
2421                         if (change == SET)
2422                                 goto out_badmix;
2423                         change = REMOVE;
2424                         tok++;
2425                 } else {
2426                         if (change != SET && change != DEFAULT)
2427                                 goto out_badmix;
2428                         change = SET;
2429                 }
2430
2431                 for (i = 0; i < imax; ++i) {
2432                         if (strcmp(tok, all_output_options[i].str) == 0)
2433                                 break;
2434                 }
2435                 if (i == imax && strcmp(tok, "flags") == 0) {
2436                         print_flags = change == REMOVE ? false : true;
2437                         continue;
2438                 }
2439                 if (i == imax) {
2440                         fprintf(stderr, "Invalid field requested.\n");
2441                         rc = -EINVAL;
2442                         goto out;
2443                 }
2444
2445                 if (type == -1) {
2446                         /* add user option to all events types for
2447                          * which it is valid
2448                          */
2449                         for (j = 0; j < OUTPUT_TYPE_MAX; ++j) {
2450                                 if (output[j].invalid_fields & all_output_options[i].field) {
2451                                         pr_warning("\'%s\' not valid for %s events. Ignoring.\n",
2452                                                    all_output_options[i].str, event_type(j));
2453                                 } else {
2454                                         if (change == REMOVE)
2455                                                 output[j].fields &= ~all_output_options[i].field;
2456                                         else
2457                                                 output[j].fields |= all_output_options[i].field;
2458                                 }
2459                         }
2460                 } else {
2461                         if (output[type].invalid_fields & all_output_options[i].field) {
2462                                 fprintf(stderr, "\'%s\' not valid for %s events.\n",
2463                                          all_output_options[i].str, event_type(type));
2464
2465                                 rc = -EINVAL;
2466                                 goto out;
2467                         }
2468                         output[type].fields |= all_output_options[i].field;
2469                 }
2470         }
2471
2472         if (type >= 0) {
2473                 if (output[type].fields == 0) {
2474                         pr_debug("No fields requested for %s type. "
2475                                  "Events will not be displayed.\n", event_type(type));
2476                 }
2477         }
2478         goto out;
2479
2480 out_badmix:
2481         fprintf(stderr, "Cannot mix +-field with overridden fields\n");
2482         rc = -EINVAL;
2483 out:
2484         free(str);
2485         return rc;
2486 }
2487
2488 #define for_each_lang(scripts_path, scripts_dir, lang_dirent)           \
2489         while ((lang_dirent = readdir(scripts_dir)) != NULL)            \
2490                 if ((lang_dirent->d_type == DT_DIR ||                   \
2491                      (lang_dirent->d_type == DT_UNKNOWN &&              \
2492                       is_directory(scripts_path, lang_dirent))) &&      \
2493                     (strcmp(lang_dirent->d_name, ".")) &&               \
2494                     (strcmp(lang_dirent->d_name, "..")))
2495
2496 #define for_each_script(lang_path, lang_dir, script_dirent)             \
2497         while ((script_dirent = readdir(lang_dir)) != NULL)             \
2498                 if (script_dirent->d_type != DT_DIR &&                  \
2499                     (script_dirent->d_type != DT_UNKNOWN ||             \
2500                      !is_directory(lang_path, script_dirent)))
2501
2502
2503 #define RECORD_SUFFIX                   "-record"
2504 #define REPORT_SUFFIX                   "-report"
2505
2506 struct script_desc {
2507         struct list_head        node;
2508         char                    *name;
2509         char                    *half_liner;
2510         char                    *args;
2511 };
2512
2513 static LIST_HEAD(script_descs);
2514
2515 static struct script_desc *script_desc__new(const char *name)
2516 {
2517         struct script_desc *s = zalloc(sizeof(*s));
2518
2519         if (s != NULL && name)
2520                 s->name = strdup(name);
2521
2522         return s;
2523 }
2524
2525 static void script_desc__delete(struct script_desc *s)
2526 {
2527         zfree(&s->name);
2528         zfree(&s->half_liner);
2529         zfree(&s->args);
2530         free(s);
2531 }
2532
2533 static void script_desc__add(struct script_desc *s)
2534 {
2535         list_add_tail(&s->node, &script_descs);
2536 }
2537
2538 static struct script_desc *script_desc__find(const char *name)
2539 {
2540         struct script_desc *s;
2541
2542         list_for_each_entry(s, &script_descs, node)
2543                 if (strcasecmp(s->name, name) == 0)
2544                         return s;
2545         return NULL;
2546 }
2547
2548 static struct script_desc *script_desc__findnew(const char *name)
2549 {
2550         struct script_desc *s = script_desc__find(name);
2551
2552         if (s)
2553                 return s;
2554
2555         s = script_desc__new(name);
2556         if (!s)
2557                 return NULL;
2558
2559         script_desc__add(s);
2560
2561         return s;
2562 }
2563
2564 static const char *ends_with(const char *str, const char *suffix)
2565 {
2566         size_t suffix_len = strlen(suffix);
2567         const char *p = str;
2568
2569         if (strlen(str) > suffix_len) {
2570                 p = str + strlen(str) - suffix_len;
2571                 if (!strncmp(p, suffix, suffix_len))
2572                         return p;
2573         }
2574
2575         return NULL;
2576 }
2577
2578 static int read_script_info(struct script_desc *desc, const char *filename)
2579 {
2580         char line[BUFSIZ], *p;
2581         FILE *fp;
2582
2583         fp = fopen(filename, "r");
2584         if (!fp)
2585                 return -1;
2586
2587         while (fgets(line, sizeof(line), fp)) {
2588                 p = ltrim(line);
2589                 if (strlen(p) == 0)
2590                         continue;
2591                 if (*p != '#')
2592                         continue;
2593                 p++;
2594                 if (strlen(p) && *p == '!')
2595                         continue;
2596
2597                 p = ltrim(p);
2598                 if (strlen(p) && p[strlen(p) - 1] == '\n')
2599                         p[strlen(p) - 1] = '\0';
2600
2601                 if (!strncmp(p, "description:", strlen("description:"))) {
2602                         p += strlen("description:");
2603                         desc->half_liner = strdup(ltrim(p));
2604                         continue;
2605                 }
2606
2607                 if (!strncmp(p, "args:", strlen("args:"))) {
2608                         p += strlen("args:");
2609                         desc->args = strdup(ltrim(p));
2610                         continue;
2611                 }
2612         }
2613
2614         fclose(fp);
2615
2616         return 0;
2617 }
2618
2619 static char *get_script_root(struct dirent *script_dirent, const char *suffix)
2620 {
2621         char *script_root, *str;
2622
2623         script_root = strdup(script_dirent->d_name);
2624         if (!script_root)
2625                 return NULL;
2626
2627         str = (char *)ends_with(script_root, suffix);
2628         if (!str) {
2629                 free(script_root);
2630                 return NULL;
2631         }
2632
2633         *str = '\0';
2634         return script_root;
2635 }
2636
2637 static int list_available_scripts(const struct option *opt __maybe_unused,
2638                                   const char *s __maybe_unused,
2639                                   int unset __maybe_unused)
2640 {
2641         struct dirent *script_dirent, *lang_dirent;
2642         char scripts_path[MAXPATHLEN];
2643         DIR *scripts_dir, *lang_dir;
2644         char script_path[MAXPATHLEN];
2645         char lang_path[MAXPATHLEN];
2646         struct script_desc *desc;
2647         char first_half[BUFSIZ];
2648         char *script_root;
2649
2650         snprintf(scripts_path, MAXPATHLEN, "%s/scripts", get_argv_exec_path());
2651
2652         scripts_dir = opendir(scripts_path);
2653         if (!scripts_dir) {
2654                 fprintf(stdout,
2655                         "open(%s) failed.\n"
2656                         "Check \"PERF_EXEC_PATH\" env to set scripts dir.\n",
2657                         scripts_path);
2658                 exit(-1);
2659         }
2660
2661         for_each_lang(scripts_path, scripts_dir, lang_dirent) {
2662                 snprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path,
2663                          lang_dirent->d_name);
2664                 lang_dir = opendir(lang_path);
2665                 if (!lang_dir)
2666                         continue;
2667
2668                 for_each_script(lang_path, lang_dir, script_dirent) {
2669                         script_root = get_script_root(script_dirent, REPORT_SUFFIX);
2670                         if (script_root) {
2671                                 desc = script_desc__findnew(script_root);
2672                                 snprintf(script_path, MAXPATHLEN, "%s/%s",
2673                                          lang_path, script_dirent->d_name);
2674                                 read_script_info(desc, script_path);
2675                                 free(script_root);
2676                         }
2677                 }
2678         }
2679
2680         fprintf(stdout, "List of available trace scripts:\n");
2681         list_for_each_entry(desc, &script_descs, node) {
2682                 sprintf(first_half, "%s %s", desc->name,
2683                         desc->args ? desc->args : "");
2684                 fprintf(stdout, "  %-36s %s\n", first_half,
2685                         desc->half_liner ? desc->half_liner : "");
2686         }
2687
2688         exit(0);
2689 }
2690
2691 /*
2692  * Some scripts specify the required events in their "xxx-record" file,
2693  * this function will check if the events in perf.data match those
2694  * mentioned in the "xxx-record".
2695  *
2696  * Fixme: All existing "xxx-record" are all in good formats "-e event ",
2697  * which is covered well now. And new parsing code should be added to
2698  * cover the future complexing formats like event groups etc.
2699  */
2700 static int check_ev_match(char *dir_name, char *scriptname,
2701                         struct perf_session *session)
2702 {
2703         char filename[MAXPATHLEN], evname[128];
2704         char line[BUFSIZ], *p;
2705         struct perf_evsel *pos;
2706         int match, len;
2707         FILE *fp;
2708
2709         sprintf(filename, "%s/bin/%s-record", dir_name, scriptname);
2710
2711         fp = fopen(filename, "r");
2712         if (!fp)
2713                 return -1;
2714
2715         while (fgets(line, sizeof(line), fp)) {
2716                 p = ltrim(line);
2717                 if (*p == '#')
2718                         continue;
2719
2720                 while (strlen(p)) {
2721                         p = strstr(p, "-e");
2722                         if (!p)
2723                                 break;
2724
2725                         p += 2;
2726                         p = ltrim(p);
2727                         len = strcspn(p, " \t");
2728                         if (!len)
2729                                 break;
2730
2731                         snprintf(evname, len + 1, "%s", p);
2732
2733                         match = 0;
2734                         evlist__for_each_entry(session->evlist, pos) {
2735                                 if (!strcmp(perf_evsel__name(pos), evname)) {
2736                                         match = 1;
2737                                         break;
2738                                 }
2739                         }
2740
2741                         if (!match) {
2742                                 fclose(fp);
2743                                 return -1;
2744                         }
2745                 }
2746         }
2747
2748         fclose(fp);
2749         return 0;
2750 }
2751
2752 /*
2753  * Return -1 if none is found, otherwise the actual scripts number.
2754  *
2755  * Currently the only user of this function is the script browser, which
2756  * will list all statically runnable scripts, select one, execute it and
2757  * show the output in a perf browser.
2758  */
2759 int find_scripts(char **scripts_array, char **scripts_path_array)
2760 {
2761         struct dirent *script_dirent, *lang_dirent;
2762         char scripts_path[MAXPATHLEN], lang_path[MAXPATHLEN];
2763         DIR *scripts_dir, *lang_dir;
2764         struct perf_session *session;
2765         struct perf_data data = {
2766                 .file      = {
2767                         .path = input_name,
2768                 },
2769                 .mode      = PERF_DATA_MODE_READ,
2770         };
2771         char *temp;
2772         int i = 0;
2773
2774         session = perf_session__new(&data, false, NULL);
2775         if (!session)
2776                 return -1;
2777
2778         snprintf(scripts_path, MAXPATHLEN, "%s/scripts", get_argv_exec_path());
2779
2780         scripts_dir = opendir(scripts_path);
2781         if (!scripts_dir) {
2782                 perf_session__delete(session);
2783                 return -1;
2784         }
2785
2786         for_each_lang(scripts_path, scripts_dir, lang_dirent) {
2787                 snprintf(lang_path, MAXPATHLEN, "%s/%s", scripts_path,
2788                          lang_dirent->d_name);
2789 #ifdef NO_LIBPERL
2790                 if (strstr(lang_path, "perl"))
2791                         continue;
2792 #endif
2793 #ifdef NO_LIBPYTHON
2794                 if (strstr(lang_path, "python"))
2795                         continue;
2796 #endif
2797
2798                 lang_dir = opendir(lang_path);
2799                 if (!lang_dir)
2800                         continue;
2801
2802                 for_each_script(lang_path, lang_dir, script_dirent) {
2803                         /* Skip those real time scripts: xxxtop.p[yl] */
2804                         if (strstr(script_dirent->d_name, "top."))
2805                                 continue;
2806                         sprintf(scripts_path_array[i], "%s/%s", lang_path,
2807                                 script_dirent->d_name);
2808                         temp = strchr(script_dirent->d_name, '.');
2809                         snprintf(scripts_array[i],
2810                                 (temp - script_dirent->d_name) + 1,
2811                                 "%s", script_dirent->d_name);
2812
2813                         if (check_ev_match(lang_path,
2814                                         scripts_array[i], session))
2815                                 continue;
2816
2817                         i++;
2818                 }
2819                 closedir(lang_dir);
2820         }
2821
2822         closedir(scripts_dir);
2823         perf_session__delete(session);
2824         return i;
2825 }
2826
2827 static char *get_script_path(const char *script_root, const char *suffix)
2828 {
2829         struct dirent *script_dirent, *lang_dirent;
2830         char scripts_path[MAXPATHLEN];
2831         char script_path[MAXPATHLEN];
2832         DIR *scripts_dir, *lang_dir;
2833         char lang_path[MAXPATHLEN];
2834         char *__script_root;
2835
2836         snprintf(scripts_path, MAXPATHLEN, "%s/scripts", get_argv_exec_path());
2837
2838         scripts_dir = opendir(scripts_path);
2839         if (!scripts_dir)
2840                 return NULL;
2841
2842         for_each_lang(scripts_path, scripts_dir, lang_dirent) {
2843                 snprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path,
2844                          lang_dirent->d_name);
2845                 lang_dir = opendir(lang_path);
2846                 if (!lang_dir)
2847                         continue;
2848
2849                 for_each_script(lang_path, lang_dir, script_dirent) {
2850                         __script_root = get_script_root(script_dirent, suffix);
2851                         if (__script_root && !strcmp(script_root, __script_root)) {
2852                                 free(__script_root);
2853                                 closedir(lang_dir);
2854                                 closedir(scripts_dir);
2855                                 snprintf(script_path, MAXPATHLEN, "%s/%s",
2856                                          lang_path, script_dirent->d_name);
2857                                 return strdup(script_path);
2858                         }
2859                         free(__script_root);
2860                 }
2861                 closedir(lang_dir);
2862         }
2863         closedir(scripts_dir);
2864
2865         return NULL;
2866 }
2867
2868 static bool is_top_script(const char *script_path)
2869 {
2870         return ends_with(script_path, "top") == NULL ? false : true;
2871 }
2872
2873 static int has_required_arg(char *script_path)
2874 {
2875         struct script_desc *desc;
2876         int n_args = 0;
2877         char *p;
2878
2879         desc = script_desc__new(NULL);
2880
2881         if (read_script_info(desc, script_path))
2882                 goto out;
2883
2884         if (!desc->args)
2885                 goto out;
2886
2887         for (p = desc->args; *p; p++)
2888                 if (*p == '<')
2889                         n_args++;
2890 out:
2891         script_desc__delete(desc);
2892
2893         return n_args;
2894 }
2895
2896 static int have_cmd(int argc, const char **argv)
2897 {
2898         char **__argv = malloc(sizeof(const char *) * argc);
2899
2900         if (!__argv) {
2901                 pr_err("malloc failed\n");
2902                 return -1;
2903         }
2904
2905         memcpy(__argv, argv, sizeof(const char *) * argc);
2906         argc = parse_options(argc, (const char **)__argv, record_options,
2907                              NULL, PARSE_OPT_STOP_AT_NON_OPTION);
2908         free(__argv);
2909
2910         system_wide = (argc == 0);
2911
2912         return 0;
2913 }
2914
2915 static void script__setup_sample_type(struct perf_script *script)
2916 {
2917         struct perf_session *session = script->session;
2918         u64 sample_type = perf_evlist__combined_sample_type(session->evlist);
2919
2920         if (symbol_conf.use_callchain || symbol_conf.cumulate_callchain) {
2921                 if ((sample_type & PERF_SAMPLE_REGS_USER) &&
2922                     (sample_type & PERF_SAMPLE_STACK_USER)) {
2923                         callchain_param.record_mode = CALLCHAIN_DWARF;
2924                         dwarf_callchain_users = true;
2925                 } else if (sample_type & PERF_SAMPLE_BRANCH_STACK)
2926                         callchain_param.record_mode = CALLCHAIN_LBR;
2927                 else
2928                         callchain_param.record_mode = CALLCHAIN_FP;
2929         }
2930 }
2931
2932 static int process_stat_round_event(struct perf_tool *tool __maybe_unused,
2933                                     union perf_event *event,
2934                                     struct perf_session *session)
2935 {
2936         struct stat_round_event *round = &event->stat_round;
2937         struct perf_evsel *counter;
2938
2939         evlist__for_each_entry(session->evlist, counter) {
2940                 perf_stat_process_counter(&stat_config, counter);
2941                 process_stat(counter, round->time);
2942         }
2943
2944         process_stat_interval(round->time);
2945         return 0;
2946 }
2947
2948 static int process_stat_config_event(struct perf_tool *tool __maybe_unused,
2949                                      union perf_event *event,
2950                                      struct perf_session *session __maybe_unused)
2951 {
2952         perf_event__read_stat_config(&stat_config, &event->stat_config);
2953         return 0;
2954 }
2955
2956 static int set_maps(struct perf_script *script)
2957 {
2958         struct perf_evlist *evlist = script->session->evlist;
2959
2960         if (!script->cpus || !script->threads)
2961                 return 0;
2962
2963         if (WARN_ONCE(script->allocated, "stats double allocation\n"))
2964                 return -EINVAL;
2965
2966         perf_evlist__set_maps(evlist, script->cpus, script->threads);
2967
2968         if (perf_evlist__alloc_stats(evlist, true))
2969                 return -ENOMEM;
2970
2971         script->allocated = true;
2972         return 0;
2973 }
2974
2975 static
2976 int process_thread_map_event(struct perf_tool *tool,
2977                              union perf_event *event,
2978                              struct perf_session *session __maybe_unused)
2979 {
2980         struct perf_script *script = container_of(tool, struct perf_script, tool);
2981
2982         if (script->threads) {
2983                 pr_warning("Extra thread map event, ignoring.\n");
2984                 return 0;
2985         }
2986
2987         script->threads = thread_map__new_event(&event->thread_map);
2988         if (!script->threads)
2989                 return -ENOMEM;
2990
2991         return set_maps(script);
2992 }
2993
2994 static
2995 int process_cpu_map_event(struct perf_tool *tool __maybe_unused,
2996                           union perf_event *event,
2997                           struct perf_session *session __maybe_unused)
2998 {
2999         struct perf_script *script = container_of(tool, struct perf_script, tool);
3000
3001         if (script->cpus) {
3002                 pr_warning("Extra cpu map event, ignoring.\n");
3003                 return 0;
3004         }
3005
3006         script->cpus = cpu_map__new_data(&event->cpu_map.data);
3007         if (!script->cpus)
3008                 return -ENOMEM;
3009
3010         return set_maps(script);
3011 }
3012
3013 #ifdef HAVE_AUXTRACE_SUPPORT
3014 static int perf_script__process_auxtrace_info(struct perf_tool *tool,
3015                                               union perf_event *event,
3016                                               struct perf_session *session)
3017 {
3018         int ret = perf_event__process_auxtrace_info(tool, event, session);
3019
3020         if (ret == 0) {
3021                 struct perf_script *script = container_of(tool, struct perf_script, tool);
3022
3023                 ret = perf_script__setup_per_event_dump(script);
3024         }
3025
3026         return ret;
3027 }
3028 #else
3029 #define perf_script__process_auxtrace_info 0
3030 #endif
3031
3032 int cmd_script(int argc, const char **argv)
3033 {
3034         bool show_full_info = false;
3035         bool header = false;
3036         bool header_only = false;
3037         bool script_started = false;
3038         char *rec_script_path = NULL;
3039         char *rep_script_path = NULL;
3040         struct perf_session *session;
3041         struct itrace_synth_opts itrace_synth_opts = { .set = false, };
3042         char *script_path = NULL;
3043         const char **__argv;
3044         int i, j, err = 0;
3045         struct perf_script script = {
3046                 .tool = {
3047                         .sample          = process_sample_event,
3048                         .mmap            = perf_event__process_mmap,
3049                         .mmap2           = perf_event__process_mmap2,
3050                         .comm            = perf_event__process_comm,
3051                         .namespaces      = perf_event__process_namespaces,
3052                         .exit            = perf_event__process_exit,
3053                         .fork            = perf_event__process_fork,
3054                         .attr            = process_attr,
3055                         .event_update   = perf_event__process_event_update,
3056                         .tracing_data    = perf_event__process_tracing_data,
3057                         .feature         = perf_event__process_feature,
3058                         .build_id        = perf_event__process_build_id,
3059                         .id_index        = perf_event__process_id_index,
3060                         .auxtrace_info   = perf_script__process_auxtrace_info,
3061                         .auxtrace        = perf_event__process_auxtrace,
3062                         .auxtrace_error  = perf_event__process_auxtrace_error,
3063                         .stat            = perf_event__process_stat_event,
3064                         .stat_round      = process_stat_round_event,
3065                         .stat_config     = process_stat_config_event,
3066                         .thread_map      = process_thread_map_event,
3067                         .cpu_map         = process_cpu_map_event,
3068                         .ordered_events  = true,
3069                         .ordering_requires_timestamps = true,
3070                 },
3071         };
3072         struct perf_data data = {
3073                 .mode = PERF_DATA_MODE_READ,
3074         };
3075         const struct option options[] = {
3076         OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
3077                     "dump raw trace in ASCII"),
3078         OPT_INCR('v', "verbose", &verbose,
3079                  "be more verbose (show symbol address, etc)"),
3080         OPT_BOOLEAN('L', "Latency", &latency_format,
3081                     "show latency attributes (irqs/preemption disabled, etc)"),
3082         OPT_CALLBACK_NOOPT('l', "list", NULL, NULL, "list available scripts",
3083                            list_available_scripts),
3084         OPT_CALLBACK('s', "script", NULL, "name",
3085                      "script file name (lang:script name, script name, or *)",
3086                      parse_scriptname),
3087         OPT_STRING('g', "gen-script", &generate_script_lang, "lang",
3088                    "generate perf-script.xx script in specified language"),
3089         OPT_STRING('i', "input", &input_name, "file", "input file name"),
3090         OPT_BOOLEAN('d', "debug-mode", &debug_mode,
3091                    "do various checks like samples ordering and lost events"),
3092         OPT_BOOLEAN(0, "header", &header, "Show data header."),
3093         OPT_BOOLEAN(0, "header-only", &header_only, "Show only data header."),
3094         OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
3095                    "file", "vmlinux pathname"),
3096         OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name,
3097                    "file", "kallsyms pathname"),
3098         OPT_BOOLEAN('G', "hide-call-graph", &no_callchain,
3099                     "When printing symbols do not display call chain"),
3100         OPT_CALLBACK(0, "symfs", NULL, "directory",
3101                      "Look for files with symbols relative to this directory",
3102                      symbol__config_symfs),
3103         OPT_CALLBACK('F', "fields", NULL, "str",
3104                      "comma separated output fields prepend with 'type:'. "
3105                      "+field to add and -field to remove."
3106                      "Valid types: hw,sw,trace,raw,synth. "
3107                      "Fields: comm,tid,pid,time,cpu,event,trace,ip,sym,dso,"
3108                      "addr,symoff,period,iregs,uregs,brstack,brstacksym,flags,"
3109                      "bpf-output,callindent,insn,insnlen,brstackinsn,synth,phys_addr",
3110                      parse_output_fields),
3111         OPT_BOOLEAN('a', "all-cpus", &system_wide,
3112                     "system-wide collection from all CPUs"),
3113         OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
3114                    "only consider these symbols"),
3115         OPT_STRING(0, "stop-bt", &symbol_conf.bt_stop_list_str, "symbol[,symbol...]",
3116                    "Stop display of callgraph at these symbols"),
3117         OPT_STRING('C', "cpu", &cpu_list, "cpu", "list of cpus to profile"),
3118         OPT_STRING('c', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
3119                    "only display events for these comms"),
3120         OPT_STRING(0, "pid", &symbol_conf.pid_list_str, "pid[,pid...]",
3121                    "only consider symbols in these pids"),
3122         OPT_STRING(0, "tid", &symbol_conf.tid_list_str, "tid[,tid...]",
3123                    "only consider symbols in these tids"),
3124         OPT_UINTEGER(0, "max-stack", &scripting_max_stack,
3125                      "Set the maximum stack depth when parsing the callchain, "
3126                      "anything beyond the specified depth will be ignored. "
3127                      "Default: kernel.perf_event_max_stack or " __stringify(PERF_MAX_STACK_DEPTH)),
3128         OPT_BOOLEAN('I', "show-info", &show_full_info,
3129                     "display extended information from perf.data file"),
3130         OPT_BOOLEAN('\0', "show-kernel-path", &symbol_conf.show_kernel_path,
3131                     "Show the path of [kernel.kallsyms]"),
3132         OPT_BOOLEAN('\0', "show-task-events", &script.show_task_events,
3133                     "Show the fork/comm/exit events"),
3134         OPT_BOOLEAN('\0', "show-mmap-events", &script.show_mmap_events,
3135                     "Show the mmap events"),
3136         OPT_BOOLEAN('\0', "show-switch-events", &script.show_switch_events,
3137                     "Show context switch events (if recorded)"),
3138         OPT_BOOLEAN('\0', "show-namespace-events", &script.show_namespace_events,
3139                     "Show namespace events (if recorded)"),
3140         OPT_BOOLEAN('\0', "show-lost-events", &script.show_lost_events,
3141                     "Show lost events (if recorded)"),
3142         OPT_BOOLEAN('\0', "per-event-dump", &script.per_event_dump,
3143                     "Dump trace output to files named by the monitored events"),
3144         OPT_BOOLEAN('f', "force", &symbol_conf.force, "don't complain, do it"),
3145         OPT_INTEGER(0, "max-blocks", &max_blocks,
3146                     "Maximum number of code blocks to dump with brstackinsn"),
3147         OPT_BOOLEAN(0, "ns", &nanosecs,
3148                     "Use 9 decimal places when displaying time"),
3149         OPT_CALLBACK_OPTARG(0, "itrace", &itrace_synth_opts, NULL, "opts",
3150                             "Instruction Tracing options",
3151                             itrace_parse_synth_opts),
3152         OPT_BOOLEAN(0, "full-source-path", &srcline_full_filename,
3153                         "Show full source file name path for source lines"),
3154         OPT_BOOLEAN(0, "demangle", &symbol_conf.demangle,
3155                         "Enable symbol demangling"),
3156         OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf.demangle_kernel,
3157                         "Enable kernel symbol demangling"),
3158         OPT_STRING(0, "time", &script.time_str, "str",
3159                    "Time span of interest (start,stop)"),
3160         OPT_BOOLEAN(0, "inline", &symbol_conf.inline_name,
3161                     "Show inline function"),
3162         OPT_END()
3163         };
3164         const char * const script_subcommands[] = { "record", "report", NULL };
3165         const char *script_usage[] = {
3166                 "perf script [<options>]",
3167                 "perf script [<options>] record <script> [<record-options>] <command>",
3168                 "perf script [<options>] report <script> [script-args]",
3169                 "perf script [<options>] <script> [<record-options>] <command>",
3170                 "perf script [<options>] <top-script> [script-args]",
3171                 NULL
3172         };
3173
3174         perf_set_singlethreaded();
3175
3176         setup_scripting();
3177
3178         argc = parse_options_subcommand(argc, argv, options, script_subcommands, script_usage,
3179                              PARSE_OPT_STOP_AT_NON_OPTION);
3180
3181         data.file.path = input_name;
3182         data.force     = symbol_conf.force;
3183
3184         if (argc > 1 && !strncmp(argv[0], "rec", strlen("rec"))) {
3185                 rec_script_path = get_script_path(argv[1], RECORD_SUFFIX);
3186                 if (!rec_script_path)
3187                         return cmd_record(argc, argv);
3188         }
3189
3190         if (argc > 1 && !strncmp(argv[0], "rep", strlen("rep"))) {
3191                 rep_script_path = get_script_path(argv[1], REPORT_SUFFIX);
3192                 if (!rep_script_path) {
3193                         fprintf(stderr,
3194                                 "Please specify a valid report script"
3195                                 "(see 'perf script -l' for listing)\n");
3196                         return -1;
3197                 }
3198         }
3199
3200         if (itrace_synth_opts.callchain &&
3201             itrace_synth_opts.callchain_sz > scripting_max_stack)
3202                 scripting_max_stack = itrace_synth_opts.callchain_sz;
3203
3204         /* make sure PERF_EXEC_PATH is set for scripts */
3205         set_argv_exec_path(get_argv_exec_path());
3206
3207         if (argc && !script_name && !rec_script_path && !rep_script_path) {
3208                 int live_pipe[2];
3209                 int rep_args;
3210                 pid_t pid;
3211
3212                 rec_script_path = get_script_path(argv[0], RECORD_SUFFIX);
3213                 rep_script_path = get_script_path(argv[0], REPORT_SUFFIX);
3214
3215                 if (!rec_script_path && !rep_script_path) {
3216                         usage_with_options_msg(script_usage, options,
3217                                 "Couldn't find script `%s'\n\n See perf"
3218                                 " script -l for available scripts.\n", argv[0]);
3219                 }
3220
3221                 if (is_top_script(argv[0])) {
3222                         rep_args = argc - 1;
3223                 } else {
3224                         int rec_args;
3225
3226                         rep_args = has_required_arg(rep_script_path);
3227                         rec_args = (argc - 1) - rep_args;
3228                         if (rec_args < 0) {
3229                                 usage_with_options_msg(script_usage, options,
3230                                         "`%s' script requires options."
3231                                         "\n\n See perf script -l for available "
3232                                         "scripts and options.\n", argv[0]);
3233                         }
3234                 }
3235
3236                 if (pipe(live_pipe) < 0) {
3237                         perror("failed to create pipe");
3238                         return -1;
3239                 }
3240
3241                 pid = fork();
3242                 if (pid < 0) {
3243                         perror("failed to fork");
3244                         return -1;
3245                 }
3246
3247                 if (!pid) {
3248                         j = 0;
3249
3250                         dup2(live_pipe[1], 1);
3251                         close(live_pipe[0]);
3252
3253                         if (is_top_script(argv[0])) {
3254                                 system_wide = true;
3255                         } else if (!system_wide) {
3256                                 if (have_cmd(argc - rep_args, &argv[rep_args]) != 0) {
3257                                         err = -1;
3258                                         goto out;
3259                                 }
3260                         }
3261
3262                         __argv = malloc((argc + 6) * sizeof(const char *));
3263                         if (!__argv) {
3264                                 pr_err("malloc failed\n");
3265                                 err = -ENOMEM;
3266                                 goto out;
3267                         }
3268
3269                         __argv[j++] = "/bin/sh";
3270                         __argv[j++] = rec_script_path;
3271                         if (system_wide)
3272                                 __argv[j++] = "-a";
3273                         __argv[j++] = "-q";
3274                         __argv[j++] = "-o";
3275                         __argv[j++] = "-";
3276                         for (i = rep_args + 1; i < argc; i++)
3277                                 __argv[j++] = argv[i];
3278                         __argv[j++] = NULL;
3279
3280                         execvp("/bin/sh", (char **)__argv);
3281                         free(__argv);
3282                         exit(-1);
3283                 }
3284
3285                 dup2(live_pipe[0], 0);
3286                 close(live_pipe[1]);
3287
3288                 __argv = malloc((argc + 4) * sizeof(const char *));
3289                 if (!__argv) {
3290                         pr_err("malloc failed\n");
3291                         err = -ENOMEM;
3292                         goto out;
3293                 }
3294
3295                 j = 0;
3296                 __argv[j++] = "/bin/sh";
3297                 __argv[j++] = rep_script_path;
3298                 for (i = 1; i < rep_args + 1; i++)
3299                         __argv[j++] = argv[i];
3300                 __argv[j++] = "-i";
3301                 __argv[j++] = "-";
3302                 __argv[j++] = NULL;
3303
3304                 execvp("/bin/sh", (char **)__argv);
3305                 free(__argv);
3306                 exit(-1);
3307         }
3308
3309         if (rec_script_path)
3310                 script_path = rec_script_path;
3311         if (rep_script_path)
3312                 script_path = rep_script_path;
3313
3314         if (script_path) {
3315                 j = 0;
3316
3317                 if (!rec_script_path)
3318                         system_wide = false;
3319                 else if (!system_wide) {
3320                         if (have_cmd(argc - 1, &argv[1]) != 0) {
3321                                 err = -1;
3322                                 goto out;
3323                         }
3324                 }
3325
3326                 __argv = malloc((argc + 2) * sizeof(const char *));
3327                 if (!__argv) {
3328                         pr_err("malloc failed\n");
3329                         err = -ENOMEM;
3330                         goto out;
3331                 }
3332
3333                 __argv[j++] = "/bin/sh";
3334                 __argv[j++] = script_path;
3335                 if (system_wide)
3336                         __argv[j++] = "-a";
3337                 for (i = 2; i < argc; i++)
3338                         __argv[j++] = argv[i];
3339                 __argv[j++] = NULL;
3340
3341                 execvp("/bin/sh", (char **)__argv);
3342                 free(__argv);
3343                 exit(-1);
3344         }
3345
3346         if (!script_name)
3347                 setup_pager();
3348
3349         session = perf_session__new(&data, false, &script.tool);
3350         if (session == NULL)
3351                 return -1;
3352
3353         if (header || header_only) {
3354                 script.tool.show_feat_hdr = SHOW_FEAT_HEADER;
3355                 perf_session__fprintf_info(session, stdout, show_full_info);
3356                 if (header_only)
3357                         goto out_delete;
3358         }
3359         if (show_full_info)
3360                 script.tool.show_feat_hdr = SHOW_FEAT_HEADER_FULL_INFO;
3361
3362         if (symbol__init(&session->header.env) < 0)
3363                 goto out_delete;
3364
3365         script.session = session;
3366         script__setup_sample_type(&script);
3367
3368         if (output[PERF_TYPE_HARDWARE].fields & PERF_OUTPUT_CALLINDENT)
3369                 itrace_synth_opts.thread_stack = true;
3370
3371         session->itrace_synth_opts = &itrace_synth_opts;
3372
3373         if (cpu_list) {
3374                 err = perf_session__cpu_bitmap(session, cpu_list, cpu_bitmap);
3375                 if (err < 0)
3376                         goto out_delete;
3377                 itrace_synth_opts.cpu_bitmap = cpu_bitmap;
3378         }
3379
3380         if (!no_callchain)
3381                 symbol_conf.use_callchain = true;
3382         else
3383                 symbol_conf.use_callchain = false;
3384
3385         if (session->tevent.pevent &&
3386             pevent_set_function_resolver(session->tevent.pevent,
3387                                          machine__resolve_kernel_addr,
3388                                          &session->machines.host) < 0) {
3389                 pr_err("%s: failed to set libtraceevent function resolver\n", __func__);
3390                 err = -1;
3391                 goto out_delete;
3392         }
3393
3394         if (generate_script_lang) {
3395                 struct stat perf_stat;
3396                 int input;
3397
3398                 if (output_set_by_user()) {
3399                         fprintf(stderr,
3400                                 "custom fields not supported for generated scripts");
3401                         err = -EINVAL;
3402                         goto out_delete;
3403                 }
3404
3405                 input = open(data.file.path, O_RDONLY); /* input_name */
3406                 if (input < 0) {
3407                         err = -errno;
3408                         perror("failed to open file");
3409                         goto out_delete;
3410                 }
3411
3412                 err = fstat(input, &perf_stat);
3413                 if (err < 0) {
3414                         perror("failed to stat file");
3415                         goto out_delete;
3416                 }
3417
3418                 if (!perf_stat.st_size) {
3419                         fprintf(stderr, "zero-sized file, nothing to do!\n");
3420                         goto out_delete;
3421                 }
3422
3423                 scripting_ops = script_spec__lookup(generate_script_lang);
3424                 if (!scripting_ops) {
3425                         fprintf(stderr, "invalid language specifier");
3426                         err = -ENOENT;
3427                         goto out_delete;
3428                 }
3429
3430                 err = scripting_ops->generate_script(session->tevent.pevent,
3431                                                      "perf-script");
3432                 goto out_delete;
3433         }
3434
3435         if (script_name) {
3436                 err = scripting_ops->start_script(script_name, argc, argv);
3437                 if (err)
3438                         goto out_delete;
3439                 pr_debug("perf script started with script %s\n\n", script_name);
3440                 script_started = true;
3441         }
3442
3443
3444         err = perf_session__check_output_opt(session);
3445         if (err < 0)
3446                 goto out_delete;
3447
3448         script.ptime_range = perf_time__range_alloc(script.time_str,
3449                                                     &script.range_size);
3450         if (!script.ptime_range) {
3451                 err = -ENOMEM;
3452                 goto out_delete;
3453         }
3454
3455         /* needs to be parsed after looking up reference time */
3456         if (perf_time__parse_str(script.ptime_range, script.time_str) != 0) {
3457                 if (session->evlist->first_sample_time == 0 &&
3458                     session->evlist->last_sample_time == 0) {
3459                         pr_err("HINT: no first/last sample time found in perf data.\n"
3460                                "Please use latest perf binary to execute 'perf record'\n"
3461                                "(if '--buildid-all' is enabled, please set '--timestamp-boundary').\n");
3462                         err = -EINVAL;
3463                         goto out_delete;
3464                 }
3465
3466                 script.range_num = perf_time__percent_parse_str(
3467                                         script.ptime_range, script.range_size,
3468                                         script.time_str,
3469                                         session->evlist->first_sample_time,
3470                                         session->evlist->last_sample_time);
3471
3472                 if (script.range_num < 0) {
3473                         pr_err("Invalid time string\n");
3474                         err = -EINVAL;
3475                         goto out_delete;
3476                 }
3477         } else {
3478                 script.range_num = 1;
3479         }
3480
3481         err = __cmd_script(&script);
3482
3483         flush_scripting();
3484
3485 out_delete:
3486         zfree(&script.ptime_range);
3487
3488         perf_evlist__free_stats(session->evlist);
3489         perf_session__delete(session);
3490
3491         if (script_started)
3492                 cleanup_scripting();
3493 out:
3494         return err;
3495 }