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