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 "util/exec_cmd.h"
   7 #include "util/header.h"
   8 #include "util/parse-options.h"
   9 #include "util/session.h"
  10 #include "util/symbol.h"
  11 #include "util/thread.h"
  12 #include "util/trace-event.h"
  13 #include "util/util.h"
  14 #include "util/evlist.h"
  15 #include "util/evsel.h"
  16
  17 static char const               *script_name;
  18 static char const               *generate_script_lang;
  19 static bool                     debug_mode;
  20 static u64                      last_timestamp;
  21 static u64                      nr_unordered;
  22 extern const struct option      record_options[];
  23 static bool                     no_callchain;
  24
  25 enum perf_output_field {
  26         PERF_OUTPUT_COMM            = 1U << 0,
  27         PERF_OUTPUT_TID             = 1U << 1,
  28         PERF_OUTPUT_PID             = 1U << 2,
  29         PERF_OUTPUT_TIME            = 1U << 3,
  30         PERF_OUTPUT_CPU             = 1U << 4,
  31         PERF_OUTPUT_EVNAME          = 1U << 5,
  32         PERF_OUTPUT_TRACE           = 1U << 6,
  33         PERF_OUTPUT_IP              = 1U << 7,
  34         PERF_OUTPUT_SYM             = 1U << 8,
  35         PERF_OUTPUT_DSO             = 1U << 9,
  36         PERF_OUTPUT_ADDR            = 1U << 10,
  37 };
  38
  39 struct output_option {
  40         const char *str;
  41         enum perf_output_field field;
  42 } all_output_options[] = {
  43         {.str = "comm",  .field = PERF_OUTPUT_COMM},
  44         {.str = "tid",   .field = PERF_OUTPUT_TID},
  45         {.str = "pid",   .field = PERF_OUTPUT_PID},
  46         {.str = "time",  .field = PERF_OUTPUT_TIME},
  47         {.str = "cpu",   .field = PERF_OUTPUT_CPU},
  48         {.str = "event", .field = PERF_OUTPUT_EVNAME},
  49         {.str = "trace", .field = PERF_OUTPUT_TRACE},
  50         {.str = "ip",    .field = PERF_OUTPUT_IP},
  51         {.str = "sym",   .field = PERF_OUTPUT_SYM},
  52         {.str = "dso",   .field = PERF_OUTPUT_DSO},
  53         {.str = "addr",  .field = PERF_OUTPUT_ADDR},
  54 };
  55
  56 /* default set to maintain compatibility with current format */
  57 static struct {
  58         bool user_set;
  59         bool wildcard_set;
  60         u64 fields;
  61         u64 invalid_fields;
  62 } output[PERF_TYPE_MAX] = {
  63
  64         [PERF_TYPE_HARDWARE] = {
  65                 .user_set = false,
  66
  67                 .fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
  68                               PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
  69                               PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
  70                                   PERF_OUTPUT_SYM | PERF_OUTPUT_DSO,
  71
  72                 .invalid_fields = PERF_OUTPUT_TRACE,
  73         },
  74
  75         [PERF_TYPE_SOFTWARE] = {
  76                 .user_set = false,
  77
  78                 .fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
  79                               PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
  80                               PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
  81                                   PERF_OUTPUT_SYM | PERF_OUTPUT_DSO,
  82
  83                 .invalid_fields = PERF_OUTPUT_TRACE,
  84         },
  85
  86         [PERF_TYPE_TRACEPOINT] = {
  87                 .user_set = false,
  88
  89                 .fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
  90                                   PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
  91                                   PERF_OUTPUT_EVNAME | PERF_OUTPUT_TRACE,
  92         },
  93
  94         [PERF_TYPE_RAW] = {
  95                 .user_set = false,
  96
  97                 .fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
  98                               PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
  99                               PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
 100                                   PERF_OUTPUT_SYM | PERF_OUTPUT_DSO,
 101
 102                 .invalid_fields = PERF_OUTPUT_TRACE,
 103         },
 104 };
 105
 106 static bool output_set_by_user(void)
 107 {
 108         int j;
 109         for (j = 0; j < PERF_TYPE_MAX; ++j) {
 110                 if (output[j].user_set)
 111                         return true;
 112         }
 113         return false;
 114 }
 115
 116 static const char *output_field2str(enum perf_output_field field)
 117 {
 118         int i, imax = ARRAY_SIZE(all_output_options);
 119         const char *str = "";
 120
 121         for (i = 0; i < imax; ++i) {
 122                 if (all_output_options[i].field == field) {
 123                         str = all_output_options[i].str;
 124                         break;
 125                 }
 126         }
 127         return str;
 128 }
 129
 130 #define PRINT_FIELD(x)  (output[attr->type].fields & PERF_OUTPUT_##x)
 131
 132 static int perf_event_attr__check_stype(struct perf_event_attr *attr,
 133                                   u64 sample_type, const char *sample_msg,
 134                                   enum perf_output_field field)
 135 {
 136         int type = attr->type;
 137         const char *evname;
 138
 139         if (attr->sample_type & sample_type)
 140                 return 0;
 141
 142         if (output[type].user_set) {
 143                 evname = __event_name(attr->type, attr->config);
 144                 pr_err("Samples for '%s' event do not have %s attribute set. "
 145                        "Cannot print '%s' field.\n",
 146                        evname, sample_msg, output_field2str(field));
 147                 return -1;
 148         }
 149
 150         /* user did not ask for it explicitly so remove from the default list */
 151         output[type].fields &= ~field;
 152         evname = __event_name(attr->type, attr->config);
 153         pr_debug("Samples for '%s' event do not have %s attribute set. "
 154                  "Skipping '%s' field.\n",
 155                  evname, sample_msg, output_field2str(field));
 156
 157         return 0;
 158 }
 159
 160 static int perf_evsel__check_attr(struct perf_evsel *evsel,
 161                                   struct perf_session *session)
 162 {
 163         struct perf_event_attr *attr = &evsel->attr;
 164
 165         if (PRINT_FIELD(TRACE) &&
 166                 !perf_session__has_traces(session, "record -R"))
 167                 return -EINVAL;
 168
 169         if (PRINT_FIELD(IP)) {
 170                 if (perf_event_attr__check_stype(attr, PERF_SAMPLE_IP, "IP",
 171                                            PERF_OUTPUT_IP))
 172                         return -EINVAL;
 173
 174                 if (!no_callchain &&
 175                     !(attr->sample_type & PERF_SAMPLE_CALLCHAIN))
 176                         symbol_conf.use_callchain = false;
 177         }
 178
 179         if (PRINT_FIELD(ADDR) &&
 180                 perf_event_attr__check_stype(attr, PERF_SAMPLE_ADDR, "ADDR",
 181                                        PERF_OUTPUT_ADDR))
 182                 return -EINVAL;
 183
 184         if (PRINT_FIELD(SYM) && !PRINT_FIELD(IP) && !PRINT_FIELD(ADDR)) {
 185                 pr_err("Display of symbols requested but neither sample IP nor "
 186                            "sample address\nis selected. Hence, no addresses to convert "
 187                        "to symbols.\n");
 188                 return -EINVAL;
 189         }
 190         if (PRINT_FIELD(DSO) && !PRINT_FIELD(IP) && !PRINT_FIELD(ADDR)) {
 191                 pr_err("Display of DSO requested but neither sample IP nor "
 192                            "sample address\nis selected. Hence, no addresses to convert "
 193                        "to DSO.\n");
 194                 return -EINVAL;
 195         }
 196
 197         if ((PRINT_FIELD(PID) || PRINT_FIELD(TID)) &&
 198                 perf_event_attr__check_stype(attr, PERF_SAMPLE_TID, "TID",
 199                                        PERF_OUTPUT_TID|PERF_OUTPUT_PID))
 200                 return -EINVAL;
 201
 202         if (PRINT_FIELD(TIME) &&
 203                 perf_event_attr__check_stype(attr, PERF_SAMPLE_TIME, "TIME",
 204                                        PERF_OUTPUT_TIME))
 205                 return -EINVAL;
 206
 207         if (PRINT_FIELD(CPU) &&
 208                 perf_event_attr__check_stype(attr, PERF_SAMPLE_CPU, "CPU",
 209                                        PERF_OUTPUT_CPU))
 210                 return -EINVAL;
 211
 212         return 0;
 213 }
 214
 215 /*
 216  * verify all user requested events exist and the samples
 217  * have the expected data
 218  */
 219 static int perf_session__check_output_opt(struct perf_session *session)
 220 {
 221         int j;
 222         struct perf_evsel *evsel;
 223
 224         for (j = 0; j < PERF_TYPE_MAX; ++j) {
 225                 evsel = perf_session__find_first_evtype(session, j);
 226
 227                 /*
 228                  * even if fields is set to 0 (ie., show nothing) event must
 229                  * exist if user explicitly includes it on the command line
 230                  */
 231                 if (!evsel && output[j].user_set && !output[j].wildcard_set) {
 232                         pr_err("%s events do not exist. "
 233                                "Remove corresponding -f option to proceed.\n",
 234                                event_type(j));
 235                         return -1;
 236                 }
 237
 238                 if (evsel && output[j].fields &&
 239                         perf_evsel__check_attr(evsel, session))
 240                         return -1;
 241         }
 242
 243         return 0;
 244 }
 245
 246 static void print_sample_start(struct perf_sample *sample,
 247                                struct thread *thread,
 248                                struct perf_event_attr *attr)
 249 {
 250         int type;
 251         struct event *event;
 252         const char *evname = NULL;
 253         unsigned long secs;
 254         unsigned long usecs;
 255         unsigned long long nsecs;
 256
 257         if (PRINT_FIELD(COMM)) {
 258                 if (latency_format)
 259                         printf("%8.8s ", thread->comm);
 260                 else if (PRINT_FIELD(IP) && symbol_conf.use_callchain)
 261                         printf("%s ", thread->comm);
 262                 else
 263                         printf("%16s ", thread->comm);
 264         }
 265
 266         if (PRINT_FIELD(PID) && PRINT_FIELD(TID))
 267                 printf("%5d/%-5d ", sample->pid, sample->tid);
 268         else if (PRINT_FIELD(PID))
 269                 printf("%5d ", sample->pid);
 270         else if (PRINT_FIELD(TID))
 271                 printf("%5d ", sample->tid);
 272
 273         if (PRINT_FIELD(CPU)) {
 274                 if (latency_format)
 275                         printf("%3d ", sample->cpu);
 276                 else
 277                         printf("[%03d] ", sample->cpu);
 278         }
 279
 280         if (PRINT_FIELD(TIME)) {
 281                 nsecs = sample->time;
 282                 secs = nsecs / NSECS_PER_SEC;
 283                 nsecs -= secs * NSECS_PER_SEC;
 284                 usecs = nsecs / NSECS_PER_USEC;
 285                 printf("%5lu.%06lu: ", secs, usecs);
 286         }
 287
 288         if (PRINT_FIELD(EVNAME)) {
 289                 if (attr->type == PERF_TYPE_TRACEPOINT) {
 290                         type = trace_parse_common_type(sample->raw_data);
 291                         event = trace_find_event(type);
 292                         if (event)
 293                                 evname = event->name;
 294                 } else
 295                         evname = __event_name(attr->type, attr->config);
 296
 297                 printf("%s: ", evname ? evname : "(unknown)");
 298         }
 299 }
 300
 301 static bool sample_addr_correlates_sym(struct perf_event_attr *attr)
 302 {
 303         if ((attr->type == PERF_TYPE_SOFTWARE) &&
 304             ((attr->config == PERF_COUNT_SW_PAGE_FAULTS) ||
 305              (attr->config == PERF_COUNT_SW_PAGE_FAULTS_MIN) ||
 306              (attr->config == PERF_COUNT_SW_PAGE_FAULTS_MAJ)))
 307                 return true;
 308
 309         return false;
 310 }
 311
 312 static void print_sample_addr(union perf_event *event,
 313                           struct perf_sample *sample,
 314                           struct perf_session *session,
 315                           struct thread *thread,
 316                           struct perf_event_attr *attr)
 317 {
 318         struct addr_location al;
 319         u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
 320         const char *symname, *dsoname;
 321
 322         printf("%16" PRIx64, sample->addr);
 323
 324         if (!sample_addr_correlates_sym(attr))
 325                 return;
 326
 327         thread__find_addr_map(thread, session, cpumode, MAP__FUNCTION,
 328                               event->ip.pid, sample->addr, &al);
 329         if (!al.map)
 330                 thread__find_addr_map(thread, session, cpumode, MAP__VARIABLE,
 331                                       event->ip.pid, sample->addr, &al);
 332
 333         al.cpu = sample->cpu;
 334         al.sym = NULL;
 335
 336         if (al.map)
 337                 al.sym = map__find_symbol(al.map, al.addr, NULL);
 338
 339         if (PRINT_FIELD(SYM)) {
 340                 if (al.sym && al.sym->name)
 341                         symname = al.sym->name;
 342                 else
 343                         symname = "";
 344
 345                 printf(" %16s", symname);
 346         }
 347
 348         if (PRINT_FIELD(DSO)) {
 349                 if (al.map && al.map->dso && al.map->dso->name)
 350                         dsoname = al.map->dso->name;
 351                 else
 352                         dsoname = "";
 353
 354                 printf(" (%s)", dsoname);
 355         }
 356 }
 357
 358 static void process_event(union perf_event *event __unused,
 359                           struct perf_sample *sample,
 360                           struct perf_evsel *evsel,
 361                           struct perf_session *session,
 362                           struct thread *thread)
 363 {
 364         struct perf_event_attr *attr = &evsel->attr;
 365
 366         if (output[attr->type].fields == 0)
 367                 return;
 368
 369         print_sample_start(sample, thread, attr);
 370
 371         if (PRINT_FIELD(TRACE))
 372                 print_trace_event(sample->cpu, sample->raw_data,
 373                                   sample->raw_size);
 374
 375         if (PRINT_FIELD(ADDR))
 376                 print_sample_addr(event, sample, session, thread, attr);
 377
 378         if (PRINT_FIELD(IP)) {
 379                 if (!symbol_conf.use_callchain)
 380                         printf(" ");
 381                 else
 382                         printf("\n");
 383                 perf_session__print_ip(event, sample, session,
 384                                               PRINT_FIELD(SYM), PRINT_FIELD(DSO));
 385         }
 386
 387         printf("\n");
 388 }
 389
 390 static int default_start_script(const char *script __unused,
 391                                 int argc __unused,
 392                                 const char **argv __unused)
 393 {
 394         return 0;
 395 }
 396
 397 static int default_stop_script(void)
 398 {
 399         return 0;
 400 }
 401
 402 static int default_generate_script(const char *outfile __unused)
 403 {
 404         return 0;
 405 }
 406
 407 static struct scripting_ops default_scripting_ops = {
 408         .start_script           = default_start_script,
 409         .stop_script            = default_stop_script,
 410         .process_event          = process_event,
 411         .generate_script        = default_generate_script,
 412 };
 413
 414 static struct scripting_ops     *scripting_ops;
 415
 416 static void setup_scripting(void)
 417 {
 418         setup_perl_scripting();
 419         setup_python_scripting();
 420
 421         scripting_ops = &default_scripting_ops;
 422 }
 423
 424 static int cleanup_scripting(void)
 425 {
 426         pr_debug("\nperf script stopped\n");
 427
 428         return scripting_ops->stop_script();
 429 }
 430
 431 static char const               *input_name = "perf.data";
 432
 433 static int process_sample_event(union perf_event *event,
 434                                 struct perf_sample *sample,
 435                                 struct perf_evsel *evsel,
 436                                 struct perf_session *session)
 437 {
 438         struct thread *thread = perf_session__findnew(session, event->ip.pid);
 439
 440         if (thread == NULL) {
 441                 pr_debug("problem processing %d event, skipping it.\n",
 442                          event->header.type);
 443                 return -1;
 444         }
 445
 446         if (debug_mode) {
 447                 if (sample->time < last_timestamp) {
 448                         pr_err("Samples misordered, previous: %" PRIu64
 449                                 " this: %" PRIu64 "\n", last_timestamp,
 450                                 sample->time);
 451                         nr_unordered++;
 452                 }
 453                 last_timestamp = sample->time;
 454                 return 0;
 455         }
 456         scripting_ops->process_event(event, sample, evsel, session, thread);
 457
 458         session->hists.stats.total_period += sample->period;
 459         return 0;
 460 }
 461
 462 static struct perf_event_ops event_ops = {
 463         .sample          = process_sample_event,
 464         .mmap            = perf_event__process_mmap,
 465         .comm            = perf_event__process_comm,
 466         .exit            = perf_event__process_task,
 467         .fork            = perf_event__process_task,
 468         .attr            = perf_event__process_attr,
 469         .event_type      = perf_event__process_event_type,
 470         .tracing_data    = perf_event__process_tracing_data,
 471         .build_id        = perf_event__process_build_id,
 472         .ordered_samples = true,
 473         .ordering_requires_timestamps = true,
 474 };
 475
 476 extern volatile int session_done;
 477
 478 static void sig_handler(int sig __unused)
 479 {
 480         session_done = 1;
 481 }
 482
 483 static int __cmd_script(struct perf_session *session)
 484 {
 485         int ret;
 486
 487         signal(SIGINT, sig_handler);
 488
 489         ret = perf_session__process_events(session, &event_ops);
 490
 491         if (debug_mode)
 492                 pr_err("Misordered timestamps: %" PRIu64 "\n", nr_unordered);
 493
 494         return ret;
 495 }
 496
 497 struct script_spec {
 498         struct list_head        node;
 499         struct scripting_ops    *ops;
 500         char                    spec[0];
 501 };
 502
 503 static LIST_HEAD(script_specs);
 504
 505 static struct script_spec *script_spec__new(const char *spec,
 506                                             struct scripting_ops *ops)
 507 {
 508         struct script_spec *s = malloc(sizeof(*s) + strlen(spec) + 1);
 509
 510         if (s != NULL) {
 511                 strcpy(s->spec, spec);
 512                 s->ops = ops;
 513         }
 514
 515         return s;
 516 }
 517
 518 static void script_spec__delete(struct script_spec *s)
 519 {
 520         free(s->spec);
 521         free(s);
 522 }
 523
 524 static void script_spec__add(struct script_spec *s)
 525 {
 526         list_add_tail(&s->node, &script_specs);
 527 }
 528
 529 static struct script_spec *script_spec__find(const char *spec)
 530 {
 531         struct script_spec *s;
 532
 533         list_for_each_entry(s, &script_specs, node)
 534                 if (strcasecmp(s->spec, spec) == 0)
 535                         return s;
 536         return NULL;
 537 }
 538
 539 static struct script_spec *script_spec__findnew(const char *spec,
 540                                                 struct scripting_ops *ops)
 541 {
 542         struct script_spec *s = script_spec__find(spec);
 543
 544         if (s)
 545                 return s;
 546
 547         s = script_spec__new(spec, ops);
 548         if (!s)
 549                 goto out_delete_spec;
 550
 551         script_spec__add(s);
 552
 553         return s;
 554
 555 out_delete_spec:
 556         script_spec__delete(s);
 557
 558         return NULL;
 559 }
 560
 561 int script_spec_register(const char *spec, struct scripting_ops *ops)
 562 {
 563         struct script_spec *s;
 564
 565         s = script_spec__find(spec);
 566         if (s)
 567                 return -1;
 568
 569         s = script_spec__findnew(spec, ops);
 570         if (!s)
 571                 return -1;
 572
 573         return 0;
 574 }
 575
 576 static struct scripting_ops *script_spec__lookup(const char *spec)
 577 {
 578         struct script_spec *s = script_spec__find(spec);
 579         if (!s)
 580                 return NULL;
 581
 582         return s->ops;
 583 }
 584
 585 static void list_available_languages(void)
 586 {
 587         struct script_spec *s;
 588
 589         fprintf(stderr, "\n");
 590         fprintf(stderr, "Scripting language extensions (used in "
 591                 "perf script -s [spec:]script.[spec]):\n\n");
 592
 593         list_for_each_entry(s, &script_specs, node)
 594                 fprintf(stderr, "  %-42s [%s]\n", s->spec, s->ops->name);
 595
 596         fprintf(stderr, "\n");
 597 }
 598
 599 static int parse_scriptname(const struct option *opt __used,
 600                             const char *str, int unset __used)
 601 {
 602         char spec[PATH_MAX];
 603         const char *script, *ext;
 604         int len;
 605
 606         if (strcmp(str, "lang") == 0) {
 607                 list_available_languages();
 608                 exit(0);
 609         }
 610
 611         script = strchr(str, ':');
 612         if (script) {
 613                 len = script - str;
 614                 if (len >= PATH_MAX) {
 615                         fprintf(stderr, "invalid language specifier");
 616                         return -1;
 617                 }
 618                 strncpy(spec, str, len);
 619                 spec[len] = '\0';
 620                 scripting_ops = script_spec__lookup(spec);
 621                 if (!scripting_ops) {
 622                         fprintf(stderr, "invalid language specifier");
 623                         return -1;
 624                 }
 625                 script++;
 626         } else {
 627                 script = str;
 628                 ext = strrchr(script, '.');
 629                 if (!ext) {
 630                         fprintf(stderr, "invalid script extension");
 631                         return -1;
 632                 }
 633                 scripting_ops = script_spec__lookup(++ext);
 634                 if (!scripting_ops) {
 635                         fprintf(stderr, "invalid script extension");
 636                         return -1;
 637                 }
 638         }
 639
 640         script_name = strdup(script);
 641
 642         return 0;
 643 }
 644
 645 static int parse_output_fields(const struct option *opt __used,
 646                             const char *arg, int unset __used)
 647 {
 648         char *tok;
 649         int i, imax = sizeof(all_output_options) / sizeof(struct output_option);
 650         int j;
 651         int rc = 0;
 652         char *str = strdup(arg);
 653         int type = -1;
 654
 655         if (!str)
 656                 return -ENOMEM;
 657
 658         /* first word can state for which event type the user is specifying
 659          * the fields. If no type exists, the specified fields apply to all
 660          * event types found in the file minus the invalid fields for a type.
 661          */
 662         tok = strchr(str, ':');
 663         if (tok) {
 664                 *tok = '\0';
 665                 tok++;
 666                 if (!strcmp(str, "hw"))
 667                         type = PERF_TYPE_HARDWARE;
 668                 else if (!strcmp(str, "sw"))
 669                         type = PERF_TYPE_SOFTWARE;
 670                 else if (!strcmp(str, "trace"))
 671                         type = PERF_TYPE_TRACEPOINT;
 672                 else if (!strcmp(str, "raw"))
 673                         type = PERF_TYPE_RAW;
 674                 else {
 675                         fprintf(stderr, "Invalid event type in field string.\n");
 676                         return -EINVAL;
 677                 }
 678
 679                 if (output[type].user_set)
 680                         pr_warning("Overriding previous field request for %s events.\n",
 681                                    event_type(type));
 682
 683                 output[type].fields = 0;
 684                 output[type].user_set = true;
 685                 output[type].wildcard_set = false;
 686
 687         } else {
 688                 tok = str;
 689                 if (strlen(str) == 0) {
 690                         fprintf(stderr,
 691                                 "Cannot set fields to 'none' for all event types.\n");
 692                         rc = -EINVAL;
 693                         goto out;
 694                 }
 695
 696                 if (output_set_by_user())
 697                         pr_warning("Overriding previous field request for all events.\n");
 698
 699                 for (j = 0; j < PERF_TYPE_MAX; ++j) {
 700                         output[j].fields = 0;
 701                         output[j].user_set = true;
 702                         output[j].wildcard_set = true;
 703                 }
 704         }
 705
 706         tok = strtok(tok, ",");
 707         while (tok) {
 708                 for (i = 0; i < imax; ++i) {
 709                         if (strcmp(tok, all_output_options[i].str) == 0)
 710                                 break;
 711                 }
 712                 if (i == imax) {
 713                         fprintf(stderr, "Invalid field requested.\n");
 714                         rc = -EINVAL;
 715                         goto out;
 716                 }
 717
 718                 if (type == -1) {
 719                         /* add user option to all events types for
 720                          * which it is valid
 721                          */
 722                         for (j = 0; j < PERF_TYPE_MAX; ++j) {
 723                                 if (output[j].invalid_fields & all_output_options[i].field) {
 724                                         pr_warning("\'%s\' not valid for %s events. Ignoring.\n",
 725                                                    all_output_options[i].str, event_type(j));
 726                                 } else
 727                                         output[j].fields |= all_output_options[i].field;
 728                         }
 729                 } else {
 730                         if (output[type].invalid_fields & all_output_options[i].field) {
 731                                 fprintf(stderr, "\'%s\' not valid for %s events.\n",
 732                                          all_output_options[i].str, event_type(type));
 733
 734                                 rc = -EINVAL;
 735                                 goto out;
 736                         }
 737                         output[type].fields |= all_output_options[i].field;
 738                 }
 739
 740                 tok = strtok(NULL, ",");
 741         }
 742
 743         if (type >= 0) {
 744                 if (output[type].fields == 0) {
 745                         pr_debug("No fields requested for %s type. "
 746                                  "Events will not be displayed.\n", event_type(type));
 747                 }
 748         }
 749
 750 out:
 751         free(str);
 752         return rc;
 753 }
 754
 755 /* Helper function for filesystems that return a dent->d_type DT_UNKNOWN */
 756 static int is_directory(const char *base_path, const struct dirent *dent)
 757 {
 758         char path[PATH_MAX];
 759         struct stat st;
 760
 761         sprintf(path, "%s/%s", base_path, dent->d_name);
 762         if (stat(path, &st))
 763                 return 0;
 764
 765         return S_ISDIR(st.st_mode);
 766 }
 767
 768 #define for_each_lang(scripts_path, scripts_dir, lang_dirent, lang_next)\
 769         while (!readdir_r(scripts_dir, &lang_dirent, &lang_next) &&     \
 770                lang_next)                                               \
 771                 if ((lang_dirent.d_type == DT_DIR ||                    \
 772                      (lang_dirent.d_type == DT_UNKNOWN &&               \
 773                       is_directory(scripts_path, &lang_dirent))) &&     \
 774                     (strcmp(lang_dirent.d_name, ".")) &&                \
 775                     (strcmp(lang_dirent.d_name, "..")))
 776
 777 #define for_each_script(lang_path, lang_dir, script_dirent, script_next)\
 778         while (!readdir_r(lang_dir, &script_dirent, &script_next) &&    \
 779                script_next)                                             \
 780                 if (script_dirent.d_type != DT_DIR &&                   \
 781                     (script_dirent.d_type != DT_UNKNOWN ||              \
 782                      !is_directory(lang_path, &script_dirent)))
 783
 784
 785 #define RECORD_SUFFIX                   "-record"
 786 #define REPORT_SUFFIX                   "-report"
 787
 788 struct script_desc {
 789         struct list_head        node;
 790         char                    *name;
 791         char                    *half_liner;
 792         char                    *args;
 793 };
 794
 795 static LIST_HEAD(script_descs);
 796
 797 static struct script_desc *script_desc__new(const char *name)
 798 {
 799         struct script_desc *s = zalloc(sizeof(*s));
 800
 801         if (s != NULL && name)
 802                 s->name = strdup(name);
 803
 804         return s;
 805 }
 806
 807 static void script_desc__delete(struct script_desc *s)
 808 {
 809         free(s->name);
 810         free(s->half_liner);
 811         free(s->args);
 812         free(s);
 813 }
 814
 815 static void script_desc__add(struct script_desc *s)
 816 {
 817         list_add_tail(&s->node, &script_descs);
 818 }
 819
 820 static struct script_desc *script_desc__find(const char *name)
 821 {
 822         struct script_desc *s;
 823
 824         list_for_each_entry(s, &script_descs, node)
 825                 if (strcasecmp(s->name, name) == 0)
 826                         return s;
 827         return NULL;
 828 }
 829
 830 static struct script_desc *script_desc__findnew(const char *name)
 831 {
 832         struct script_desc *s = script_desc__find(name);
 833
 834         if (s)
 835                 return s;
 836
 837         s = script_desc__new(name);
 838         if (!s)
 839                 goto out_delete_desc;
 840
 841         script_desc__add(s);
 842
 843         return s;
 844
 845 out_delete_desc:
 846         script_desc__delete(s);
 847
 848         return NULL;
 849 }
 850
 851 static const char *ends_with(const char *str, const char *suffix)
 852 {
 853         size_t suffix_len = strlen(suffix);
 854         const char *p = str;
 855
 856         if (strlen(str) > suffix_len) {
 857                 p = str + strlen(str) - suffix_len;
 858                 if (!strncmp(p, suffix, suffix_len))
 859                         return p;
 860         }
 861
 862         return NULL;
 863 }
 864
 865 static char *ltrim(char *str)
 866 {
 867         int len = strlen(str);
 868
 869         while (len && isspace(*str)) {
 870                 len--;
 871                 str++;
 872         }
 873
 874         return str;
 875 }
 876
 877 static int read_script_info(struct script_desc *desc, const char *filename)
 878 {
 879         char line[BUFSIZ], *p;
 880         FILE *fp;
 881
 882         fp = fopen(filename, "r");
 883         if (!fp)
 884                 return -1;
 885
 886         while (fgets(line, sizeof(line), fp)) {
 887                 p = ltrim(line);
 888                 if (strlen(p) == 0)
 889                         continue;
 890                 if (*p != '#')
 891                         continue;
 892                 p++;
 893                 if (strlen(p) && *p == '!')
 894                         continue;
 895
 896                 p = ltrim(p);
 897                 if (strlen(p) && p[strlen(p) - 1] == '\n')
 898                         p[strlen(p) - 1] = '\0';
 899
 900                 if (!strncmp(p, "description:", strlen("description:"))) {
 901                         p += strlen("description:");
 902                         desc->half_liner = strdup(ltrim(p));
 903                         continue;
 904                 }
 905
 906                 if (!strncmp(p, "args:", strlen("args:"))) {
 907                         p += strlen("args:");
 908                         desc->args = strdup(ltrim(p));
 909                         continue;
 910                 }
 911         }
 912
 913         fclose(fp);
 914
 915         return 0;
 916 }
 917
 918 static int list_available_scripts(const struct option *opt __used,
 919                                   const char *s __used, int unset __used)
 920 {
 921         struct dirent *script_next, *lang_next, script_dirent, lang_dirent;
 922         char scripts_path[MAXPATHLEN];
 923         DIR *scripts_dir, *lang_dir;
 924         char script_path[MAXPATHLEN];
 925         char lang_path[MAXPATHLEN];
 926         struct script_desc *desc;
 927         char first_half[BUFSIZ];
 928         char *script_root;
 929         char *str;
 930
 931         snprintf(scripts_path, MAXPATHLEN, "%s/scripts", perf_exec_path());
 932
 933         scripts_dir = opendir(scripts_path);
 934         if (!scripts_dir)
 935                 return -1;
 936
 937         for_each_lang(scripts_path, scripts_dir, lang_dirent, lang_next) {
 938                 snprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path,
 939                          lang_dirent.d_name);
 940                 lang_dir = opendir(lang_path);
 941                 if (!lang_dir)
 942                         continue;
 943
 944                 for_each_script(lang_path, lang_dir, script_dirent, script_next) {
 945                         script_root = strdup(script_dirent.d_name);
 946                         str = (char *)ends_with(script_root, REPORT_SUFFIX);
 947                         if (str) {
 948                                 *str = '\0';
 949                                 desc = script_desc__findnew(script_root);
 950                                 snprintf(script_path, MAXPATHLEN, "%s/%s",
 951                                          lang_path, script_dirent.d_name);
 952                                 read_script_info(desc, script_path);
 953                         }
 954                         free(script_root);
 955                 }
 956         }
 957
 958         fprintf(stdout, "List of available trace scripts:\n");
 959         list_for_each_entry(desc, &script_descs, node) {
 960                 sprintf(first_half, "%s %s", desc->name,
 961                         desc->args ? desc->args : "");
 962                 fprintf(stdout, "  %-36s %s\n", first_half,
 963                         desc->half_liner ? desc->half_liner : "");
 964         }
 965
 966         exit(0);
 967 }
 968
 969 static char *get_script_path(const char *script_root, const char *suffix)
 970 {
 971         struct dirent *script_next, *lang_next, script_dirent, lang_dirent;
 972         char scripts_path[MAXPATHLEN];
 973         char script_path[MAXPATHLEN];
 974         DIR *scripts_dir, *lang_dir;
 975         char lang_path[MAXPATHLEN];
 976         char *str, *__script_root;
 977         char *path = NULL;
 978
 979         snprintf(scripts_path, MAXPATHLEN, "%s/scripts", perf_exec_path());
 980
 981         scripts_dir = opendir(scripts_path);
 982         if (!scripts_dir)
 983                 return NULL;
 984
 985         for_each_lang(scripts_path, scripts_dir, lang_dirent, lang_next) {
 986                 snprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path,
 987                          lang_dirent.d_name);
 988                 lang_dir = opendir(lang_path);
 989                 if (!lang_dir)
 990                         continue;
 991
 992                 for_each_script(lang_path, lang_dir, script_dirent, script_next) {
 993                         __script_root = strdup(script_dirent.d_name);
 994                         str = (char *)ends_with(__script_root, suffix);
 995                         if (str) {
 996                                 *str = '\0';
 997                                 if (strcmp(__script_root, script_root))
 998                                         continue;
 999                                 snprintf(script_path, MAXPATHLEN, "%s/%s",
1000                                          lang_path, script_dirent.d_name);
1001                                 path = strdup(script_path);
1002                                 free(__script_root);
1003                                 break;
1004                         }
1005                         free(__script_root);
1006                 }
1007         }
1008
1009         return path;
1010 }
1011
1012 static bool is_top_script(const char *script_path)
1013 {
1014         return ends_with(script_path, "top") == NULL ? false : true;
1015 }
1016
1017 static int has_required_arg(char *script_path)
1018 {
1019         struct script_desc *desc;
1020         int n_args = 0;
1021         char *p;
1022
1023         desc = script_desc__new(NULL);
1024
1025         if (read_script_info(desc, script_path))
1026                 goto out;
1027
1028         if (!desc->args)
1029                 goto out;
1030
1031         for (p = desc->args; *p; p++)
1032                 if (*p == '<')
1033                         n_args++;
1034 out:
1035         script_desc__delete(desc);
1036
1037         return n_args;
1038 }
1039
1040 static const char * const script_usage[] = {
1041         "perf script [<options>]",
1042         "perf script [<options>] record <script> [<record-options>] <command>",
1043         "perf script [<options>] report <script> [script-args]",
1044         "perf script [<options>] <script> [<record-options>] <command>",
1045         "perf script [<options>] <top-script> [script-args]",
1046         NULL
1047 };
1048
1049 static const struct option options[] = {
1050         OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
1051                     "dump raw trace in ASCII"),
1052         OPT_INCR('v', "verbose", &verbose,
1053                     "be more verbose (show symbol address, etc)"),
1054         OPT_BOOLEAN('L', "Latency", &latency_format,
1055                     "show latency attributes (irqs/preemption disabled, etc)"),
1056         OPT_CALLBACK_NOOPT('l', "list", NULL, NULL, "list available scripts",
1057                            list_available_scripts),
1058         OPT_CALLBACK('s', "script", NULL, "name",
1059                      "script file name (lang:script name, script name, or *)",
1060                      parse_scriptname),
1061         OPT_STRING('g', "gen-script", &generate_script_lang, "lang",
1062                    "generate perf-script.xx script in specified language"),
1063         OPT_STRING('i', "input", &input_name, "file",
1064                     "input file name"),
1065         OPT_BOOLEAN('d', "debug-mode", &debug_mode,
1066                    "do various checks like samples ordering and lost events"),
1067         OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
1068                    "file", "vmlinux pathname"),
1069         OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name,
1070                    "file", "kallsyms pathname"),
1071         OPT_BOOLEAN('G', "hide-call-graph", &no_callchain,
1072                     "When printing symbols do not display call chain"),
1073         OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
1074                     "Look for files with symbols relative to this directory"),
1075         OPT_CALLBACK('f', "fields", NULL, "str",
1076                      "comma separated output fields prepend with 'type:'. Valid types: hw,sw,trace,raw. Fields: comm,tid,pid,time,cpu,event,trace,ip,sym,dso,addr",
1077                      parse_output_fields),
1078
1079         OPT_END()
1080 };
1081
1082 static bool have_cmd(int argc, const char **argv)
1083 {
1084         char **__argv = malloc(sizeof(const char *) * argc);
1085
1086         if (!__argv)
1087                 die("malloc");
1088         memcpy(__argv, argv, sizeof(const char *) * argc);
1089         argc = parse_options(argc, (const char **)__argv, record_options,
1090                              NULL, PARSE_OPT_STOP_AT_NON_OPTION);
1091         free(__argv);
1092
1093         return argc != 0;
1094 }
1095
1096 int cmd_script(int argc, const char **argv, const char *prefix __used)
1097 {
1098         char *rec_script_path = NULL;
1099         char *rep_script_path = NULL;
1100         struct perf_session *session;
1101         char *script_path = NULL;
1102         const char **__argv;
1103         bool system_wide;
1104         int i, j, err;
1105
1106         setup_scripting();
1107
1108         argc = parse_options(argc, argv, options, script_usage,
1109                              PARSE_OPT_STOP_AT_NON_OPTION);
1110
1111         if (argc > 1 && !strncmp(argv[0], "rec", strlen("rec"))) {
1112                 rec_script_path = get_script_path(argv[1], RECORD_SUFFIX);
1113                 if (!rec_script_path)
1114                         return cmd_record(argc, argv, NULL);
1115         }
1116
1117         if (argc > 1 && !strncmp(argv[0], "rep", strlen("rep"))) {
1118                 rep_script_path = get_script_path(argv[1], REPORT_SUFFIX);
1119                 if (!rep_script_path) {
1120                         fprintf(stderr,
1121                                 "Please specify a valid report script"
1122                                 "(see 'perf script -l' for listing)\n");
1123                         return -1;
1124                 }
1125         }
1126
1127         /* make sure PERF_EXEC_PATH is set for scripts */
1128         perf_set_argv_exec_path(perf_exec_path());
1129
1130         if (argc && !script_name && !rec_script_path && !rep_script_path) {
1131                 int live_pipe[2];
1132                 int rep_args;
1133                 pid_t pid;
1134
1135                 rec_script_path = get_script_path(argv[0], RECORD_SUFFIX);
1136                 rep_script_path = get_script_path(argv[0], REPORT_SUFFIX);
1137
1138                 if (!rec_script_path && !rep_script_path) {
1139                         fprintf(stderr, " Couldn't find script %s\n\n See perf"
1140                                 " script -l for available scripts.\n", argv[0]);
1141                         usage_with_options(script_usage, options);
1142                 }
1143
1144                 if (is_top_script(argv[0])) {
1145                         rep_args = argc - 1;
1146                 } else {
1147                         int rec_args;
1148
1149                         rep_args = has_required_arg(rep_script_path);
1150                         rec_args = (argc - 1) - rep_args;
1151                         if (rec_args < 0) {
1152                                 fprintf(stderr, " %s script requires options."
1153                                         "\n\n See perf script -l for available "
1154                                         "scripts and options.\n", argv[0]);
1155                                 usage_with_options(script_usage, options);
1156                         }
1157                 }
1158
1159                 if (pipe(live_pipe) < 0) {
1160                         perror("failed to create pipe");
1161                         exit(-1);
1162                 }
1163
1164                 pid = fork();
1165                 if (pid < 0) {
1166                         perror("failed to fork");
1167                         exit(-1);
1168                 }
1169
1170                 if (!pid) {
1171                         system_wide = true;
1172                         j = 0;
1173
1174                         dup2(live_pipe[1], 1);
1175                         close(live_pipe[0]);
1176
1177                         if (!is_top_script(argv[0]))
1178                                 system_wide = !have_cmd(argc - rep_args,
1179                                                         &argv[rep_args]);
1180
1181                         __argv = malloc((argc + 6) * sizeof(const char *));
1182                         if (!__argv)
1183                                 die("malloc");
1184
1185                         __argv[j++] = "/bin/sh";
1186                         __argv[j++] = rec_script_path;
1187                         if (system_wide)
1188                                 __argv[j++] = "-a";
1189                         __argv[j++] = "-q";
1190                         __argv[j++] = "-o";
1191                         __argv[j++] = "-";
1192                         for (i = rep_args + 1; i < argc; i++)
1193                                 __argv[j++] = argv[i];
1194                         __argv[j++] = NULL;
1195
1196                         execvp("/bin/sh", (char **)__argv);
1197                         free(__argv);
1198                         exit(-1);
1199                 }
1200
1201                 dup2(live_pipe[0], 0);
1202                 close(live_pipe[1]);
1203
1204                 __argv = malloc((argc + 4) * sizeof(const char *));
1205                 if (!__argv)
1206                         die("malloc");
1207                 j = 0;
1208                 __argv[j++] = "/bin/sh";
1209                 __argv[j++] = rep_script_path;
1210                 for (i = 1; i < rep_args + 1; i++)
1211                         __argv[j++] = argv[i];
1212                 __argv[j++] = "-i";
1213                 __argv[j++] = "-";
1214                 __argv[j++] = NULL;
1215
1216                 execvp("/bin/sh", (char **)__argv);
1217                 free(__argv);
1218                 exit(-1);
1219         }
1220
1221         if (rec_script_path)
1222                 script_path = rec_script_path;
1223         if (rep_script_path)
1224                 script_path = rep_script_path;
1225
1226         if (script_path) {
1227                 system_wide = false;
1228                 j = 0;
1229
1230                 if (rec_script_path)
1231                         system_wide = !have_cmd(argc - 1, &argv[1]);
1232
1233                 __argv = malloc((argc + 2) * sizeof(const char *));
1234                 if (!__argv)
1235                         die("malloc");
1236                 __argv[j++] = "/bin/sh";
1237                 __argv[j++] = script_path;
1238                 if (system_wide)
1239                         __argv[j++] = "-a";
1240                 for (i = 2; i < argc; i++)
1241                         __argv[j++] = argv[i];
1242                 __argv[j++] = NULL;
1243
1244                 execvp("/bin/sh", (char **)__argv);
1245                 free(__argv);
1246                 exit(-1);
1247         }
1248
1249         if (symbol__init() < 0)
1250                 return -1;
1251         if (!script_name)
1252                 setup_pager();
1253
1254         session = perf_session__new(input_name, O_RDONLY, 0, false, &event_ops);
1255         if (session == NULL)
1256                 return -ENOMEM;
1257
1258         if (!no_callchain)
1259                 symbol_conf.use_callchain = true;
1260         else
1261                 symbol_conf.use_callchain = false;
1262
1263         if (generate_script_lang) {
1264                 struct stat perf_stat;
1265                 int input;
1266
1267                 if (output_set_by_user()) {
1268                         fprintf(stderr,
1269                                 "custom fields not supported for generated scripts");
1270                         return -1;
1271                 }
1272
1273                 input = open(input_name, O_RDONLY);
1274                 if (input < 0) {
1275                         perror("failed to open file");
1276                         exit(-1);
1277                 }
1278
1279                 err = fstat(input, &perf_stat);
1280                 if (err < 0) {
1281                         perror("failed to stat file");
1282                         exit(-1);
1283                 }
1284
1285                 if (!perf_stat.st_size) {
1286                         fprintf(stderr, "zero-sized file, nothing to do!\n");
1287                         exit(0);
1288                 }
1289
1290                 scripting_ops = script_spec__lookup(generate_script_lang);
1291                 if (!scripting_ops) {
1292                         fprintf(stderr, "invalid language specifier");
1293                         return -1;
1294                 }
1295
1296                 err = scripting_ops->generate_script("perf-script");
1297                 goto out;
1298         }
1299
1300         if (script_name) {
1301                 err = scripting_ops->start_script(script_name, argc, argv);
1302                 if (err)
1303                         goto out;
1304                 pr_debug("perf script started with script %s\n\n", script_name);
1305         }
1306
1307
1308         err = perf_session__check_output_opt(session);
1309         if (err < 0)
1310                 goto out;
1311
1312         err = __cmd_script(session);
1313
1314         perf_session__delete(session);
1315         cleanup_scripting();
1316 out:
1317         return err;
1318 }