tools/perf/builtin-script.c

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