tools/perf/util/parse-events.c

   1 #include <linux/hw_breakpoint.h>
   2 #include "util.h"
   3 #include "../perf.h"
   4 #include "evlist.h"
   5 #include "evsel.h"
   6 #include "parse-options.h"
   7 #include "parse-events.h"
   8 #include "exec_cmd.h"
   9 #include "linux/string.h"
  10 #include "symbol.h"
  11 #include "cache.h"
  12 #include "header.h"
  13 #include "debug.h"
  14 #include <api/fs/debugfs.h>
  15 #include "parse-events-bison.h"
  16 #define YY_EXTRA_TYPE int
  17 #include "parse-events-flex.h"
  18 #include "pmu.h"
  19 #include "thread_map.h"
  20
  21 #define MAX_NAME_LEN 100
  22
  23 struct event_symbol {
  24         const char      *symbol;
  25         const char      *alias;
  26 };
  27
  28 #ifdef PARSER_DEBUG
  29 extern int parse_events_debug;
  30 #endif
  31 int parse_events_parse(void *data, void *scanner);
  32
  33 static struct event_symbol event_symbols_hw[PERF_COUNT_HW_MAX] = {
  34         [PERF_COUNT_HW_CPU_CYCLES] = {
  35                 .symbol = "cpu-cycles",
  36                 .alias  = "cycles",
  37         },
  38         [PERF_COUNT_HW_INSTRUCTIONS] = {
  39                 .symbol = "instructions",
  40                 .alias  = "",
  41         },
  42         [PERF_COUNT_HW_CACHE_REFERENCES] = {
  43                 .symbol = "cache-references",
  44                 .alias  = "",
  45         },
  46         [PERF_COUNT_HW_CACHE_MISSES] = {
  47                 .symbol = "cache-misses",
  48                 .alias  = "",
  49         },
  50         [PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = {
  51                 .symbol = "branch-instructions",
  52                 .alias  = "branches",
  53         },
  54         [PERF_COUNT_HW_BRANCH_MISSES] = {
  55                 .symbol = "branch-misses",
  56                 .alias  = "",
  57         },
  58         [PERF_COUNT_HW_BUS_CYCLES] = {
  59                 .symbol = "bus-cycles",
  60                 .alias  = "",
  61         },
  62         [PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = {
  63                 .symbol = "stalled-cycles-frontend",
  64                 .alias  = "idle-cycles-frontend",
  65         },
  66         [PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = {
  67                 .symbol = "stalled-cycles-backend",
  68                 .alias  = "idle-cycles-backend",
  69         },
  70         [PERF_COUNT_HW_REF_CPU_CYCLES] = {
  71                 .symbol = "ref-cycles",
  72                 .alias  = "",
  73         },
  74 };
  75
  76 static struct event_symbol event_symbols_sw[PERF_COUNT_SW_MAX] = {
  77         [PERF_COUNT_SW_CPU_CLOCK] = {
  78                 .symbol = "cpu-clock",
  79                 .alias  = "",
  80         },
  81         [PERF_COUNT_SW_TASK_CLOCK] = {
  82                 .symbol = "task-clock",
  83                 .alias  = "",
  84         },
  85         [PERF_COUNT_SW_PAGE_FAULTS] = {
  86                 .symbol = "page-faults",
  87                 .alias  = "faults",
  88         },
  89         [PERF_COUNT_SW_CONTEXT_SWITCHES] = {
  90                 .symbol = "context-switches",
  91                 .alias  = "cs",
  92         },
  93         [PERF_COUNT_SW_CPU_MIGRATIONS] = {
  94                 .symbol = "cpu-migrations",
  95                 .alias  = "migrations",
  96         },
  97         [PERF_COUNT_SW_PAGE_FAULTS_MIN] = {
  98                 .symbol = "minor-faults",
  99                 .alias  = "",
 100         },
 101         [PERF_COUNT_SW_PAGE_FAULTS_MAJ] = {
 102                 .symbol = "major-faults",
 103                 .alias  = "",
 104         },
 105         [PERF_COUNT_SW_ALIGNMENT_FAULTS] = {
 106                 .symbol = "alignment-faults",
 107                 .alias  = "",
 108         },
 109         [PERF_COUNT_SW_EMULATION_FAULTS] = {
 110                 .symbol = "emulation-faults",
 111                 .alias  = "",
 112         },
 113         [PERF_COUNT_SW_DUMMY] = {
 114                 .symbol = "dummy",
 115                 .alias  = "",
 116         },
 117 };
 118
 119 #define __PERF_EVENT_FIELD(config, name) \
 120         ((config & PERF_EVENT_##name##_MASK) >> PERF_EVENT_##name##_SHIFT)
 121
 122 #define PERF_EVENT_RAW(config)          __PERF_EVENT_FIELD(config, RAW)
 123 #define PERF_EVENT_CONFIG(config)       __PERF_EVENT_FIELD(config, CONFIG)
 124 #define PERF_EVENT_TYPE(config)         __PERF_EVENT_FIELD(config, TYPE)
 125 #define PERF_EVENT_ID(config)           __PERF_EVENT_FIELD(config, EVENT)
 126
 127 #define for_each_subsystem(sys_dir, sys_dirent, sys_next)              \
 128         while (!readdir_r(sys_dir, &sys_dirent, &sys_next) && sys_next)        \
 129         if (sys_dirent.d_type == DT_DIR &&                                     \
 130            (strcmp(sys_dirent.d_name, ".")) &&                                 \
 131            (strcmp(sys_dirent.d_name, "..")))
 132
 133 static int tp_event_has_id(struct dirent *sys_dir, struct dirent *evt_dir)
 134 {
 135         char evt_path[MAXPATHLEN];
 136         int fd;
 137
 138         snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", tracing_events_path,
 139                         sys_dir->d_name, evt_dir->d_name);
 140         fd = open(evt_path, O_RDONLY);
 141         if (fd < 0)
 142                 return -EINVAL;
 143         close(fd);
 144
 145         return 0;
 146 }
 147
 148 #define for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next)              \
 149         while (!readdir_r(evt_dir, &evt_dirent, &evt_next) && evt_next)        \
 150         if (evt_dirent.d_type == DT_DIR &&                                     \
 151            (strcmp(evt_dirent.d_name, ".")) &&                                 \
 152            (strcmp(evt_dirent.d_name, "..")) &&                                \
 153            (!tp_event_has_id(&sys_dirent, &evt_dirent)))
 154
 155 #define MAX_EVENT_LENGTH 512
 156
 157
 158 struct tracepoint_path *tracepoint_id_to_path(u64 config)
 159 {
 160         struct tracepoint_path *path = NULL;
 161         DIR *sys_dir, *evt_dir;
 162         struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
 163         char id_buf[24];
 164         int fd;
 165         u64 id;
 166         char evt_path[MAXPATHLEN];
 167         char dir_path[MAXPATHLEN];
 168
 169         if (debugfs_valid_mountpoint(tracing_events_path))
 170                 return NULL;
 171
 172         sys_dir = opendir(tracing_events_path);
 173         if (!sys_dir)
 174                 return NULL;
 175
 176         for_each_subsystem(sys_dir, sys_dirent, sys_next) {
 177
 178                 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
 179                          sys_dirent.d_name);
 180                 evt_dir = opendir(dir_path);
 181                 if (!evt_dir)
 182                         continue;
 183
 184                 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) {
 185
 186                         snprintf(evt_path, MAXPATHLEN, "%s/%s/id", dir_path,
 187                                  evt_dirent.d_name);
 188                         fd = open(evt_path, O_RDONLY);
 189                         if (fd < 0)
 190                                 continue;
 191                         if (read(fd, id_buf, sizeof(id_buf)) < 0) {
 192                                 close(fd);
 193                                 continue;
 194                         }
 195                         close(fd);
 196                         id = atoll(id_buf);
 197                         if (id == config) {
 198                                 closedir(evt_dir);
 199                                 closedir(sys_dir);
 200                                 path = zalloc(sizeof(*path));
 201                                 path->system = malloc(MAX_EVENT_LENGTH);
 202                                 if (!path->system) {
 203                                         free(path);
 204                                         return NULL;
 205                                 }
 206                                 path->name = malloc(MAX_EVENT_LENGTH);
 207                                 if (!path->name) {
 208                                         zfree(&path->system);
 209                                         free(path);
 210                                         return NULL;
 211                                 }
 212                                 strncpy(path->system, sys_dirent.d_name,
 213                                         MAX_EVENT_LENGTH);
 214                                 strncpy(path->name, evt_dirent.d_name,
 215                                         MAX_EVENT_LENGTH);
 216                                 return path;
 217                         }
 218                 }
 219                 closedir(evt_dir);
 220         }
 221
 222         closedir(sys_dir);
 223         return NULL;
 224 }
 225
 226 struct tracepoint_path *tracepoint_name_to_path(const char *name)
 227 {
 228         struct tracepoint_path *path = zalloc(sizeof(*path));
 229         char *str = strchr(name, ':');
 230
 231         if (path == NULL || str == NULL) {
 232                 free(path);
 233                 return NULL;
 234         }
 235
 236         path->system = strndup(name, str - name);
 237         path->name = strdup(str+1);
 238
 239         if (path->system == NULL || path->name == NULL) {
 240                 zfree(&path->system);
 241                 zfree(&path->name);
 242                 free(path);
 243                 path = NULL;
 244         }
 245
 246         return path;
 247 }
 248
 249 const char *event_type(int type)
 250 {
 251         switch (type) {
 252         case PERF_TYPE_HARDWARE:
 253                 return "hardware";
 254
 255         case PERF_TYPE_SOFTWARE:
 256                 return "software";
 257
 258         case PERF_TYPE_TRACEPOINT:
 259                 return "tracepoint";
 260
 261         case PERF_TYPE_HW_CACHE:
 262                 return "hardware-cache";
 263
 264         default:
 265                 break;
 266         }
 267
 268         return "unknown";
 269 }
 270
 271
 272
 273 static struct perf_evsel *
 274 __add_event(struct list_head *list, int *idx,
 275             struct perf_event_attr *attr,
 276             char *name, struct cpu_map *cpus)
 277 {
 278         struct perf_evsel *evsel;
 279
 280         event_attr_init(attr);
 281
 282         evsel = perf_evsel__new_idx(attr, (*idx)++);
 283         if (!evsel)
 284                 return NULL;
 285
 286         evsel->cpus = cpus;
 287         if (name)
 288                 evsel->name = strdup(name);
 289         list_add_tail(&evsel->node, list);
 290         return evsel;
 291 }
 292
 293 static int add_event(struct list_head *list, int *idx,
 294                      struct perf_event_attr *attr, char *name)
 295 {
 296         return __add_event(list, idx, attr, name, NULL) ? 0 : -ENOMEM;
 297 }
 298
 299 static int parse_aliases(char *str, const char *names[][PERF_EVSEL__MAX_ALIASES], int size)
 300 {
 301         int i, j;
 302         int n, longest = -1;
 303
 304         for (i = 0; i < size; i++) {
 305                 for (j = 0; j < PERF_EVSEL__MAX_ALIASES && names[i][j]; j++) {
 306                         n = strlen(names[i][j]);
 307                         if (n > longest && !strncasecmp(str, names[i][j], n))
 308                                 longest = n;
 309                 }
 310                 if (longest > 0)
 311                         return i;
 312         }
 313
 314         return -1;
 315 }
 316
 317 int parse_events_add_cache(struct list_head *list, int *idx,
 318                            char *type, char *op_result1, char *op_result2)
 319 {
 320         struct perf_event_attr attr;
 321         char name[MAX_NAME_LEN];
 322         int cache_type = -1, cache_op = -1, cache_result = -1;
 323         char *op_result[2] = { op_result1, op_result2 };
 324         int i, n;
 325
 326         /*
 327          * No fallback - if we cannot get a clear cache type
 328          * then bail out:
 329          */
 330         cache_type = parse_aliases(type, perf_evsel__hw_cache,
 331                                    PERF_COUNT_HW_CACHE_MAX);
 332         if (cache_type == -1)
 333                 return -EINVAL;
 334
 335         n = snprintf(name, MAX_NAME_LEN, "%s", type);
 336
 337         for (i = 0; (i < 2) && (op_result[i]); i++) {
 338                 char *str = op_result[i];
 339
 340                 n += snprintf(name + n, MAX_NAME_LEN - n, "-%s", str);
 341
 342                 if (cache_op == -1) {
 343                         cache_op = parse_aliases(str, perf_evsel__hw_cache_op,
 344                                                  PERF_COUNT_HW_CACHE_OP_MAX);
 345                         if (cache_op >= 0) {
 346                                 if (!perf_evsel__is_cache_op_valid(cache_type, cache_op))
 347                                         return -EINVAL;
 348                                 continue;
 349                         }
 350                 }
 351
 352                 if (cache_result == -1) {
 353                         cache_result = parse_aliases(str, perf_evsel__hw_cache_result,
 354                                                      PERF_COUNT_HW_CACHE_RESULT_MAX);
 355                         if (cache_result >= 0)
 356                                 continue;
 357                 }
 358         }
 359
 360         /*
 361          * Fall back to reads:
 362          */
 363         if (cache_op == -1)
 364                 cache_op = PERF_COUNT_HW_CACHE_OP_READ;
 365
 366         /*
 367          * Fall back to accesses:
 368          */
 369         if (cache_result == -1)
 370                 cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS;
 371
 372         memset(&attr, 0, sizeof(attr));
 373         attr.config = cache_type | (cache_op << 8) | (cache_result << 16);
 374         attr.type = PERF_TYPE_HW_CACHE;
 375         return add_event(list, idx, &attr, name);
 376 }
 377
 378 static int add_tracepoint(struct list_head *list, int *idx,
 379                           char *sys_name, char *evt_name)
 380 {
 381         struct perf_evsel *evsel;
 382
 383         evsel = perf_evsel__newtp_idx(sys_name, evt_name, (*idx)++);
 384         if (!evsel)
 385                 return -ENOMEM;
 386
 387         list_add_tail(&evsel->node, list);
 388
 389         return 0;
 390 }
 391
 392 static int add_tracepoint_multi_event(struct list_head *list, int *idx,
 393                                       char *sys_name, char *evt_name)
 394 {
 395         char evt_path[MAXPATHLEN];
 396         struct dirent *evt_ent;
 397         DIR *evt_dir;
 398         int ret = 0;
 399
 400         snprintf(evt_path, MAXPATHLEN, "%s/%s", tracing_events_path, sys_name);
 401         evt_dir = opendir(evt_path);
 402         if (!evt_dir) {
 403                 perror("Can't open event dir");
 404                 return -1;
 405         }
 406
 407         while (!ret && (evt_ent = readdir(evt_dir))) {
 408                 if (!strcmp(evt_ent->d_name, ".")
 409                     || !strcmp(evt_ent->d_name, "..")
 410                     || !strcmp(evt_ent->d_name, "enable")
 411                     || !strcmp(evt_ent->d_name, "filter"))
 412                         continue;
 413
 414                 if (!strglobmatch(evt_ent->d_name, evt_name))
 415                         continue;
 416
 417                 ret = add_tracepoint(list, idx, sys_name, evt_ent->d_name);
 418         }
 419
 420         closedir(evt_dir);
 421         return ret;
 422 }
 423
 424 static int add_tracepoint_event(struct list_head *list, int *idx,
 425                                 char *sys_name, char *evt_name)
 426 {
 427         return strpbrk(evt_name, "*?") ?
 428                add_tracepoint_multi_event(list, idx, sys_name, evt_name) :
 429                add_tracepoint(list, idx, sys_name, evt_name);
 430 }
 431
 432 static int add_tracepoint_multi_sys(struct list_head *list, int *idx,
 433                                     char *sys_name, char *evt_name)
 434 {
 435         struct dirent *events_ent;
 436         DIR *events_dir;
 437         int ret = 0;
 438
 439         events_dir = opendir(tracing_events_path);
 440         if (!events_dir) {
 441                 perror("Can't open event dir");
 442                 return -1;
 443         }
 444
 445         while (!ret && (events_ent = readdir(events_dir))) {
 446                 if (!strcmp(events_ent->d_name, ".")
 447                     || !strcmp(events_ent->d_name, "..")
 448                     || !strcmp(events_ent->d_name, "enable")
 449                     || !strcmp(events_ent->d_name, "header_event")
 450                     || !strcmp(events_ent->d_name, "header_page"))
 451                         continue;
 452
 453                 if (!strglobmatch(events_ent->d_name, sys_name))
 454                         continue;
 455
 456                 ret = add_tracepoint_event(list, idx, events_ent->d_name,
 457                                            evt_name);
 458         }
 459
 460         closedir(events_dir);
 461         return ret;
 462 }
 463
 464 int parse_events_add_tracepoint(struct list_head *list, int *idx,
 465                                 char *sys, char *event)
 466 {
 467         int ret;
 468
 469         ret = debugfs_valid_mountpoint(tracing_events_path);
 470         if (ret)
 471                 return ret;
 472
 473         if (strpbrk(sys, "*?"))
 474                 return add_tracepoint_multi_sys(list, idx, sys, event);
 475         else
 476                 return add_tracepoint_event(list, idx, sys, event);
 477 }
 478
 479 static int
 480 parse_breakpoint_type(const char *type, struct perf_event_attr *attr)
 481 {
 482         int i;
 483
 484         for (i = 0; i < 3; i++) {
 485                 if (!type || !type[i])
 486                         break;
 487
 488 #define CHECK_SET_TYPE(bit)             \
 489 do {                                    \
 490         if (attr->bp_type & bit)        \
 491                 return -EINVAL;         \
 492         else                            \
 493                 attr->bp_type |= bit;   \
 494 } while (0)
 495
 496                 switch (type[i]) {
 497                 case 'r':
 498                         CHECK_SET_TYPE(HW_BREAKPOINT_R);
 499                         break;
 500                 case 'w':
 501                         CHECK_SET_TYPE(HW_BREAKPOINT_W);
 502                         break;
 503                 case 'x':
 504                         CHECK_SET_TYPE(HW_BREAKPOINT_X);
 505                         break;
 506                 default:
 507                         return -EINVAL;
 508                 }
 509         }
 510
 511 #undef CHECK_SET_TYPE
 512
 513         if (!attr->bp_type) /* Default */
 514                 attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W;
 515
 516         return 0;
 517 }
 518
 519 int parse_events_add_breakpoint(struct list_head *list, int *idx,
 520                                 void *ptr, char *type)
 521 {
 522         struct perf_event_attr attr;
 523
 524         memset(&attr, 0, sizeof(attr));
 525         attr.bp_addr = (unsigned long) ptr;
 526
 527         if (parse_breakpoint_type(type, &attr))
 528                 return -EINVAL;
 529
 530         /*
 531          * We should find a nice way to override the access length
 532          * Provide some defaults for now
 533          */
 534         if (attr.bp_type == HW_BREAKPOINT_X)
 535                 attr.bp_len = sizeof(long);
 536         else
 537                 attr.bp_len = HW_BREAKPOINT_LEN_4;
 538
 539         attr.type = PERF_TYPE_BREAKPOINT;
 540         attr.sample_period = 1;
 541
 542         return add_event(list, idx, &attr, NULL);
 543 }
 544
 545 static int config_term(struct perf_event_attr *attr,
 546                        struct parse_events_term *term)
 547 {
 548 #define CHECK_TYPE_VAL(type)                                    \
 549 do {                                                            \
 550         if (PARSE_EVENTS__TERM_TYPE_ ## type != term->type_val) \
 551                 return -EINVAL;                                 \
 552 } while (0)
 553
 554         switch (term->type_term) {
 555         case PARSE_EVENTS__TERM_TYPE_CONFIG:
 556                 CHECK_TYPE_VAL(NUM);
 557                 attr->config = term->val.num;
 558                 break;
 559         case PARSE_EVENTS__TERM_TYPE_CONFIG1:
 560                 CHECK_TYPE_VAL(NUM);
 561                 attr->config1 = term->val.num;
 562                 break;
 563         case PARSE_EVENTS__TERM_TYPE_CONFIG2:
 564                 CHECK_TYPE_VAL(NUM);
 565                 attr->config2 = term->val.num;
 566                 break;
 567         case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
 568                 CHECK_TYPE_VAL(NUM);
 569                 attr->sample_period = term->val.num;
 570                 break;
 571         case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
 572                 /*
 573                  * TODO uncomment when the field is available
 574                  * attr->branch_sample_type = term->val.num;
 575                  */
 576                 break;
 577         case PARSE_EVENTS__TERM_TYPE_NAME:
 578                 CHECK_TYPE_VAL(STR);
 579                 break;
 580         default:
 581                 return -EINVAL;
 582         }
 583
 584         return 0;
 585 #undef CHECK_TYPE_VAL
 586 }
 587
 588 static int config_attr(struct perf_event_attr *attr,
 589                        struct list_head *head, int fail)
 590 {
 591         struct parse_events_term *term;
 592
 593         list_for_each_entry(term, head, list)
 594                 if (config_term(attr, term) && fail)
 595                         return -EINVAL;
 596
 597         return 0;
 598 }
 599
 600 int parse_events_add_numeric(struct list_head *list, int *idx,
 601                              u32 type, u64 config,
 602                              struct list_head *head_config)
 603 {
 604         struct perf_event_attr attr;
 605
 606         memset(&attr, 0, sizeof(attr));
 607         attr.type = type;
 608         attr.config = config;
 609
 610         if (head_config &&
 611             config_attr(&attr, head_config, 1))
 612                 return -EINVAL;
 613
 614         return add_event(list, idx, &attr, NULL);
 615 }
 616
 617 static int parse_events__is_name_term(struct parse_events_term *term)
 618 {
 619         return term->type_term == PARSE_EVENTS__TERM_TYPE_NAME;
 620 }
 621
 622 static char *pmu_event_name(struct list_head *head_terms)
 623 {
 624         struct parse_events_term *term;
 625
 626         list_for_each_entry(term, head_terms, list)
 627                 if (parse_events__is_name_term(term))
 628                         return term->val.str;
 629
 630         return NULL;
 631 }
 632
 633 int parse_events_add_pmu(struct list_head *list, int *idx,
 634                          char *name, struct list_head *head_config)
 635 {
 636         struct perf_event_attr attr;
 637         struct perf_pmu_info info;
 638         struct perf_pmu *pmu;
 639         struct perf_evsel *evsel;
 640
 641         pmu = perf_pmu__find(name);
 642         if (!pmu)
 643                 return -EINVAL;
 644
 645         if (pmu->default_config) {
 646                 memcpy(&attr, pmu->default_config,
 647                        sizeof(struct perf_event_attr));
 648         } else {
 649                 memset(&attr, 0, sizeof(attr));
 650         }
 651
 652         if (!head_config) {
 653                 attr.type = pmu->type;
 654                 evsel = __add_event(list, idx, &attr, NULL, pmu->cpus);
 655                 return evsel ? 0 : -ENOMEM;
 656         }
 657
 658         if (perf_pmu__check_alias(pmu, head_config, &info))
 659                 return -EINVAL;
 660
 661         /*
 662          * Configure hardcoded terms first, no need to check
 663          * return value when called with fail == 0 ;)
 664          */
 665         config_attr(&attr, head_config, 0);
 666
 667         if (perf_pmu__config(pmu, &attr, head_config))
 668                 return -EINVAL;
 669
 670         evsel = __add_event(list, idx, &attr, pmu_event_name(head_config),
 671                             pmu->cpus);
 672         if (evsel) {
 673                 evsel->unit = info.unit;
 674                 evsel->scale = info.scale;
 675         }
 676
 677         return evsel ? 0 : -ENOMEM;
 678 }
 679
 680 int parse_events__modifier_group(struct list_head *list,
 681                                  char *event_mod)
 682 {
 683         return parse_events__modifier_event(list, event_mod, true);
 684 }
 685
 686 void parse_events__set_leader(char *name, struct list_head *list)
 687 {
 688         struct perf_evsel *leader;
 689
 690         __perf_evlist__set_leader(list);
 691         leader = list_entry(list->next, struct perf_evsel, node);
 692         leader->group_name = name ? strdup(name) : NULL;
 693 }
 694
 695 /* list_event is assumed to point to malloc'ed memory */
 696 void parse_events_update_lists(struct list_head *list_event,
 697                                struct list_head *list_all)
 698 {
 699         /*
 700          * Called for single event definition. Update the
 701          * 'all event' list, and reinit the 'single event'
 702          * list, for next event definition.
 703          */
 704         list_splice_tail(list_event, list_all);
 705         free(list_event);
 706 }
 707
 708 struct event_modifier {
 709         int eu;
 710         int ek;
 711         int eh;
 712         int eH;
 713         int eG;
 714         int precise;
 715         int exclude_GH;
 716         int sample_read;
 717         int pinned;
 718 };
 719
 720 static int get_event_modifier(struct event_modifier *mod, char *str,
 721                                struct perf_evsel *evsel)
 722 {
 723         int eu = evsel ? evsel->attr.exclude_user : 0;
 724         int ek = evsel ? evsel->attr.exclude_kernel : 0;
 725         int eh = evsel ? evsel->attr.exclude_hv : 0;
 726         int eH = evsel ? evsel->attr.exclude_host : 0;
 727         int eG = evsel ? evsel->attr.exclude_guest : 0;
 728         int precise = evsel ? evsel->attr.precise_ip : 0;
 729         int sample_read = 0;
 730         int pinned = evsel ? evsel->attr.pinned : 0;
 731
 732         int exclude = eu | ek | eh;
 733         int exclude_GH = evsel ? evsel->exclude_GH : 0;
 734
 735         memset(mod, 0, sizeof(*mod));
 736
 737         while (*str) {
 738                 if (*str == 'u') {
 739                         if (!exclude)
 740                                 exclude = eu = ek = eh = 1;
 741                         eu = 0;
 742                 } else if (*str == 'k') {
 743                         if (!exclude)
 744                                 exclude = eu = ek = eh = 1;
 745                         ek = 0;
 746                 } else if (*str == 'h') {
 747                         if (!exclude)
 748                                 exclude = eu = ek = eh = 1;
 749                         eh = 0;
 750                 } else if (*str == 'G') {
 751                         if (!exclude_GH)
 752                                 exclude_GH = eG = eH = 1;
 753                         eG = 0;
 754                 } else if (*str == 'H') {
 755                         if (!exclude_GH)
 756                                 exclude_GH = eG = eH = 1;
 757                         eH = 0;
 758                 } else if (*str == 'p') {
 759                         precise++;
 760                         /* use of precise requires exclude_guest */
 761                         if (!exclude_GH)
 762                                 eG = 1;
 763                 } else if (*str == 'S') {
 764                         sample_read = 1;
 765                 } else if (*str == 'D') {
 766                         pinned = 1;
 767                 } else
 768                         break;
 769
 770                 ++str;
 771         }
 772
 773         /*
 774          * precise ip:
 775          *
 776          *  0 - SAMPLE_IP can have arbitrary skid
 777          *  1 - SAMPLE_IP must have constant skid
 778          *  2 - SAMPLE_IP requested to have 0 skid
 779          *  3 - SAMPLE_IP must have 0 skid
 780          *
 781          *  See also PERF_RECORD_MISC_EXACT_IP
 782          */
 783         if (precise > 3)
 784                 return -EINVAL;
 785
 786         mod->eu = eu;
 787         mod->ek = ek;
 788         mod->eh = eh;
 789         mod->eH = eH;
 790         mod->eG = eG;
 791         mod->precise = precise;
 792         mod->exclude_GH = exclude_GH;
 793         mod->sample_read = sample_read;
 794         mod->pinned = pinned;
 795
 796         return 0;
 797 }
 798
 799 /*
 800  * Basic modifier sanity check to validate it contains only one
 801  * instance of any modifier (apart from 'p') present.
 802  */
 803 static int check_modifier(char *str)
 804 {
 805         char *p = str;
 806
 807         /* The sizeof includes 0 byte as well. */
 808         if (strlen(str) > (sizeof("ukhGHpppSD") - 1))
 809                 return -1;
 810
 811         while (*p) {
 812                 if (*p != 'p' && strchr(p + 1, *p))
 813                         return -1;
 814                 p++;
 815         }
 816
 817         return 0;
 818 }
 819
 820 int parse_events__modifier_event(struct list_head *list, char *str, bool add)
 821 {
 822         struct perf_evsel *evsel;
 823         struct event_modifier mod;
 824
 825         if (str == NULL)
 826                 return 0;
 827
 828         if (check_modifier(str))
 829                 return -EINVAL;
 830
 831         if (!add && get_event_modifier(&mod, str, NULL))
 832                 return -EINVAL;
 833
 834         __evlist__for_each(list, evsel) {
 835                 if (add && get_event_modifier(&mod, str, evsel))
 836                         return -EINVAL;
 837
 838                 evsel->attr.exclude_user   = mod.eu;
 839                 evsel->attr.exclude_kernel = mod.ek;
 840                 evsel->attr.exclude_hv     = mod.eh;
 841                 evsel->attr.precise_ip     = mod.precise;
 842                 evsel->attr.exclude_host   = mod.eH;
 843                 evsel->attr.exclude_guest  = mod.eG;
 844                 evsel->exclude_GH          = mod.exclude_GH;
 845                 evsel->sample_read         = mod.sample_read;
 846
 847                 if (perf_evsel__is_group_leader(evsel))
 848                         evsel->attr.pinned = mod.pinned;
 849         }
 850
 851         return 0;
 852 }
 853
 854 int parse_events_name(struct list_head *list, char *name)
 855 {
 856         struct perf_evsel *evsel;
 857
 858         __evlist__for_each(list, evsel) {
 859                 if (!evsel->name)
 860                         evsel->name = strdup(name);
 861         }
 862
 863         return 0;
 864 }
 865
 866 static int parse_events__scanner(const char *str, void *data, int start_token);
 867
 868 static int parse_events_fixup(int ret, const char *str, void *data,
 869                               int start_token)
 870 {
 871         char *o = strdup(str);
 872         char *s = NULL;
 873         char *t = o;
 874         char *p;
 875         int len = 0;
 876
 877         if (!o)
 878                 return ret;
 879         while ((p = strsep(&t, ",")) != NULL) {
 880                 if (s)
 881                         str_append(&s, &len, ",");
 882                 str_append(&s, &len, "cpu/");
 883                 str_append(&s, &len, p);
 884                 str_append(&s, &len, "/");
 885         }
 886         free(o);
 887         if (!s)
 888                 return -ENOMEM;
 889         return parse_events__scanner(s, data, start_token);
 890 }
 891
 892 static int parse_events__scanner(const char *str, void *data, int start_token)
 893 {
 894         YY_BUFFER_STATE buffer;
 895         void *scanner;
 896         int ret;
 897
 898         ret = parse_events_lex_init_extra(start_token, &scanner);
 899         if (ret)
 900                 return ret;
 901
 902         buffer = parse_events__scan_string(str, scanner);
 903
 904 #ifdef PARSER_DEBUG
 905         parse_events_debug = 1;
 906 #endif
 907         ret = parse_events_parse(data, scanner);
 908
 909         parse_events__flush_buffer(buffer, scanner);
 910         parse_events__delete_buffer(buffer, scanner);
 911         parse_events_lex_destroy(scanner);
 912         if (ret && !strchr(str, '/'))
 913                 ret = parse_events_fixup(ret, str, data, start_token);
 914         return ret;
 915 }
 916
 917 /*
 918  * parse event config string, return a list of event terms.
 919  */
 920 int parse_events_terms(struct list_head *terms, const char *str)
 921 {
 922         struct parse_events_terms data = {
 923                 .terms = NULL,
 924         };
 925         int ret;
 926
 927         ret = parse_events__scanner(str, &data, PE_START_TERMS);
 928         if (!ret) {
 929                 list_splice(data.terms, terms);
 930                 zfree(&data.terms);
 931                 return 0;
 932         }
 933
 934         if (data.terms)
 935                 parse_events__free_terms(data.terms);
 936         return ret;
 937 }
 938
 939 int parse_events(struct perf_evlist *evlist, const char *str)
 940 {
 941         struct parse_events_evlist data = {
 942                 .list = LIST_HEAD_INIT(data.list),
 943                 .idx  = evlist->nr_entries,
 944         };
 945         int ret;
 946
 947         ret = parse_events__scanner(str, &data, PE_START_EVENTS);
 948         if (!ret) {
 949                 int entries = data.idx - evlist->nr_entries;
 950                 perf_evlist__splice_list_tail(evlist, &data.list, entries);
 951                 evlist->nr_groups += data.nr_groups;
 952                 return 0;
 953         }
 954
 955         /*
 956          * There are 2 users - builtin-record and builtin-test objects.
 957          * Both call perf_evlist__delete in case of error, so we dont
 958          * need to bother.
 959          */
 960         return ret;
 961 }
 962
 963 int parse_events_option(const struct option *opt, const char *str,
 964                         int unset __maybe_unused)
 965 {
 966         struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
 967         int ret = parse_events(evlist, str);
 968
 969         if (ret) {
 970                 fprintf(stderr, "invalid or unsupported event: '%s'\n", str);
 971                 fprintf(stderr, "Run 'perf list' for a list of valid events\n");
 972         }
 973         return ret;
 974 }
 975
 976 int parse_filter(const struct option *opt, const char *str,
 977                  int unset __maybe_unused)
 978 {
 979         struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
 980         struct perf_evsel *last = NULL;
 981
 982         if (evlist->nr_entries > 0)
 983                 last = perf_evlist__last(evlist);
 984
 985         if (last == NULL || last->attr.type != PERF_TYPE_TRACEPOINT) {
 986                 fprintf(stderr,
 987                         "--filter option should follow a -e tracepoint option\n");
 988                 return -1;
 989         }
 990
 991         last->filter = strdup(str);
 992         if (last->filter == NULL) {
 993                 fprintf(stderr, "not enough memory to hold filter string\n");
 994                 return -1;
 995         }
 996
 997         return 0;
 998 }
 999
1000 static const char * const event_type_descriptors[] = {
1001         "Hardware event",
1002         "Software event",
1003         "Tracepoint event",
1004         "Hardware cache event",
1005         "Raw hardware event descriptor",
1006         "Hardware breakpoint",
1007 };
1008
1009 /*
1010  * Print the events from <debugfs_mount_point>/tracing/events
1011  */
1012
1013 void print_tracepoint_events(const char *subsys_glob, const char *event_glob,
1014                              bool name_only)
1015 {
1016         DIR *sys_dir, *evt_dir;
1017         struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
1018         char evt_path[MAXPATHLEN];
1019         char dir_path[MAXPATHLEN];
1020         char sbuf[STRERR_BUFSIZE];
1021
1022         if (debugfs_valid_mountpoint(tracing_events_path)) {
1023                 printf("  [ Tracepoints not available: %s ]\n",
1024                         strerror_r(errno, sbuf, sizeof(sbuf)));
1025                 return;
1026         }
1027
1028         sys_dir = opendir(tracing_events_path);
1029         if (!sys_dir)
1030                 return;
1031
1032         for_each_subsystem(sys_dir, sys_dirent, sys_next) {
1033                 if (subsys_glob != NULL &&
1034                     !strglobmatch(sys_dirent.d_name, subsys_glob))
1035                         continue;
1036
1037                 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
1038                          sys_dirent.d_name);
1039                 evt_dir = opendir(dir_path);
1040                 if (!evt_dir)
1041                         continue;
1042
1043                 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) {
1044                         if (event_glob != NULL &&
1045                             !strglobmatch(evt_dirent.d_name, event_glob))
1046                                 continue;
1047
1048                         if (name_only) {
1049                                 printf("%s:%s ", sys_dirent.d_name, evt_dirent.d_name);
1050                                 continue;
1051                         }
1052
1053                         snprintf(evt_path, MAXPATHLEN, "%s:%s",
1054                                  sys_dirent.d_name, evt_dirent.d_name);
1055                         printf("  %-50s [%s]\n", evt_path,
1056                                 event_type_descriptors[PERF_TYPE_TRACEPOINT]);
1057                 }
1058                 closedir(evt_dir);
1059         }
1060         closedir(sys_dir);
1061 }
1062
1063 /*
1064  * Check whether event is in <debugfs_mount_point>/tracing/events
1065  */
1066
1067 int is_valid_tracepoint(const char *event_string)
1068 {
1069         DIR *sys_dir, *evt_dir;
1070         struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
1071         char evt_path[MAXPATHLEN];
1072         char dir_path[MAXPATHLEN];
1073
1074         if (debugfs_valid_mountpoint(tracing_events_path))
1075                 return 0;
1076
1077         sys_dir = opendir(tracing_events_path);
1078         if (!sys_dir)
1079                 return 0;
1080
1081         for_each_subsystem(sys_dir, sys_dirent, sys_next) {
1082
1083                 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
1084                          sys_dirent.d_name);
1085                 evt_dir = opendir(dir_path);
1086                 if (!evt_dir)
1087                         continue;
1088
1089                 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) {
1090                         snprintf(evt_path, MAXPATHLEN, "%s:%s",
1091                                  sys_dirent.d_name, evt_dirent.d_name);
1092                         if (!strcmp(evt_path, event_string)) {
1093                                 closedir(evt_dir);
1094                                 closedir(sys_dir);
1095                                 return 1;
1096                         }
1097                 }
1098                 closedir(evt_dir);
1099         }
1100         closedir(sys_dir);
1101         return 0;
1102 }
1103
1104 static bool is_event_supported(u8 type, unsigned config)
1105 {
1106         bool ret = true;
1107         int open_return;
1108         struct perf_evsel *evsel;
1109         struct perf_event_attr attr = {
1110                 .type = type,
1111                 .config = config,
1112                 .disabled = 1,
1113         };
1114         struct {
1115                 struct thread_map map;
1116                 int threads[1];
1117         } tmap = {
1118                 .map.nr  = 1,
1119                 .threads = { 0 },
1120         };
1121
1122         evsel = perf_evsel__new(&attr);
1123         if (evsel) {
1124                 open_return = perf_evsel__open(evsel, NULL, &tmap.map);
1125                 ret = open_return >= 0;
1126
1127                 if (open_return == -EACCES) {
1128                         /*
1129                          * This happens if the paranoid value
1130                          * /proc/sys/kernel/perf_event_paranoid is set to 2
1131                          * Re-run with exclude_kernel set; we don't do that
1132                          * by default as some ARM machines do not support it.
1133                          *
1134                          */
1135                         evsel->attr.exclude_kernel = 1;
1136                         ret = perf_evsel__open(evsel, NULL, &tmap.map) >= 0;
1137                 }
1138                 perf_evsel__delete(evsel);
1139         }
1140
1141         return ret;
1142 }
1143
1144 static void __print_events_type(u8 type, struct event_symbol *syms,
1145                                 unsigned max)
1146 {
1147         char name[64];
1148         unsigned i;
1149
1150         for (i = 0; i < max ; i++, syms++) {
1151                 if (!is_event_supported(type, i))
1152                         continue;
1153
1154                 if (strlen(syms->alias))
1155                         snprintf(name, sizeof(name),  "%s OR %s",
1156                                  syms->symbol, syms->alias);
1157                 else
1158                         snprintf(name, sizeof(name), "%s", syms->symbol);
1159
1160                 printf("  %-50s [%s]\n", name, event_type_descriptors[type]);
1161         }
1162 }
1163
1164 void print_events_type(u8 type)
1165 {
1166         if (type == PERF_TYPE_SOFTWARE)
1167                 __print_events_type(type, event_symbols_sw, PERF_COUNT_SW_MAX);
1168         else
1169                 __print_events_type(type, event_symbols_hw, PERF_COUNT_HW_MAX);
1170 }
1171
1172 int print_hwcache_events(const char *event_glob, bool name_only)
1173 {
1174         unsigned int type, op, i, printed = 0;
1175         char name[64];
1176
1177         for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) {
1178                 for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) {
1179                         /* skip invalid cache type */
1180                         if (!perf_evsel__is_cache_op_valid(type, op))
1181                                 continue;
1182
1183                         for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
1184                                 __perf_evsel__hw_cache_type_op_res_name(type, op, i,
1185                                                                         name, sizeof(name));
1186                                 if (event_glob != NULL && !strglobmatch(name, event_glob))
1187                                         continue;
1188
1189                                 if (!is_event_supported(PERF_TYPE_HW_CACHE,
1190                                                         type | (op << 8) | (i << 16)))
1191                                         continue;
1192
1193                                 if (name_only)
1194                                         printf("%s ", name);
1195                                 else
1196                                         printf("  %-50s [%s]\n", name,
1197                                                event_type_descriptors[PERF_TYPE_HW_CACHE]);
1198                                 ++printed;
1199                         }
1200                 }
1201         }
1202
1203         if (printed)
1204                 printf("\n");
1205         return printed;
1206 }
1207
1208 static void print_symbol_events(const char *event_glob, unsigned type,
1209                                 struct event_symbol *syms, unsigned max,
1210                                 bool name_only)
1211 {
1212         unsigned i, printed = 0;
1213         char name[MAX_NAME_LEN];
1214
1215         for (i = 0; i < max; i++, syms++) {
1216
1217                 if (event_glob != NULL &&
1218                     !(strglobmatch(syms->symbol, event_glob) ||
1219                       (syms->alias && strglobmatch(syms->alias, event_glob))))
1220                         continue;
1221
1222                 if (!is_event_supported(type, i))
1223                         continue;
1224
1225                 if (name_only) {
1226                         printf("%s ", syms->symbol);
1227                         continue;
1228                 }
1229
1230                 if (strlen(syms->alias))
1231                         snprintf(name, MAX_NAME_LEN, "%s OR %s", syms->symbol, syms->alias);
1232                 else
1233                         strncpy(name, syms->symbol, MAX_NAME_LEN);
1234
1235                 printf("  %-50s [%s]\n", name, event_type_descriptors[type]);
1236
1237                 printed++;
1238         }
1239
1240         if (printed)
1241                 printf("\n");
1242 }
1243
1244 /*
1245  * Print the help text for the event symbols:
1246  */
1247 void print_events(const char *event_glob, bool name_only)
1248 {
1249         if (!name_only) {
1250                 printf("\n");
1251                 printf("List of pre-defined events (to be used in -e):\n");
1252         }
1253
1254         print_symbol_events(event_glob, PERF_TYPE_HARDWARE,
1255                             event_symbols_hw, PERF_COUNT_HW_MAX, name_only);
1256
1257         print_symbol_events(event_glob, PERF_TYPE_SOFTWARE,
1258                             event_symbols_sw, PERF_COUNT_SW_MAX, name_only);
1259
1260         print_hwcache_events(event_glob, name_only);
1261
1262         print_pmu_events(event_glob, name_only);
1263
1264         if (event_glob != NULL)
1265                 return;
1266
1267         if (!name_only) {
1268                 printf("  %-50s [%s]\n",
1269                        "rNNN",
1270                        event_type_descriptors[PERF_TYPE_RAW]);
1271                 printf("  %-50s [%s]\n",
1272                        "cpu/t1=v1[,t2=v2,t3 ...]/modifier",
1273                        event_type_descriptors[PERF_TYPE_RAW]);
1274                 printf("   (see 'man perf-list' on how to encode it)\n");
1275                 printf("\n");
1276
1277                 printf("  %-50s [%s]\n",
1278                        "mem:<addr>[:access]",
1279                         event_type_descriptors[PERF_TYPE_BREAKPOINT]);
1280                 printf("\n");
1281         }
1282
1283         print_tracepoint_events(NULL, NULL, name_only);
1284 }
1285
1286 int parse_events__is_hardcoded_term(struct parse_events_term *term)
1287 {
1288         return term->type_term != PARSE_EVENTS__TERM_TYPE_USER;
1289 }
1290
1291 static int new_term(struct parse_events_term **_term, int type_val,
1292                     int type_term, char *config,
1293                     char *str, u64 num)
1294 {
1295         struct parse_events_term *term;
1296
1297         term = zalloc(sizeof(*term));
1298         if (!term)
1299                 return -ENOMEM;
1300
1301         INIT_LIST_HEAD(&term->list);
1302         term->type_val  = type_val;
1303         term->type_term = type_term;
1304         term->config = config;
1305
1306         switch (type_val) {
1307         case PARSE_EVENTS__TERM_TYPE_NUM:
1308                 term->val.num = num;
1309                 break;
1310         case PARSE_EVENTS__TERM_TYPE_STR:
1311                 term->val.str = str;
1312                 break;
1313         default:
1314                 free(term);
1315                 return -EINVAL;
1316         }
1317
1318         *_term = term;
1319         return 0;
1320 }
1321
1322 int parse_events_term__num(struct parse_events_term **term,
1323                            int type_term, char *config, u64 num)
1324 {
1325         return new_term(term, PARSE_EVENTS__TERM_TYPE_NUM, type_term,
1326                         config, NULL, num);
1327 }
1328
1329 int parse_events_term__str(struct parse_events_term **term,
1330                            int type_term, char *config, char *str)
1331 {
1332         return new_term(term, PARSE_EVENTS__TERM_TYPE_STR, type_term,
1333                         config, str, 0);
1334 }
1335
1336 int parse_events_term__sym_hw(struct parse_events_term **term,
1337                               char *config, unsigned idx)
1338 {
1339         struct event_symbol *sym;
1340
1341         BUG_ON(idx >= PERF_COUNT_HW_MAX);
1342         sym = &event_symbols_hw[idx];
1343
1344         if (config)
1345                 return new_term(term, PARSE_EVENTS__TERM_TYPE_STR,
1346                                 PARSE_EVENTS__TERM_TYPE_USER, config,
1347                                 (char *) sym->symbol, 0);
1348         else
1349                 return new_term(term, PARSE_EVENTS__TERM_TYPE_STR,
1350                                 PARSE_EVENTS__TERM_TYPE_USER,
1351                                 (char *) "event", (char *) sym->symbol, 0);
1352 }
1353
1354 int parse_events_term__clone(struct parse_events_term **new,
1355                              struct parse_events_term *term)
1356 {
1357         return new_term(new, term->type_val, term->type_term, term->config,
1358                         term->val.str, term->val.num);
1359 }
1360
1361 void parse_events__free_terms(struct list_head *terms)
1362 {
1363         struct parse_events_term *term, *h;
1364
1365         list_for_each_entry_safe(term, h, terms, list)
1366                 free(term);
1367 }