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