tools/perf/util/parse-events.c

   1 #include "../../../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 "string.h"
  10 #include "symbol.h"
  11 #include "cache.h"
  12 #include "header.h"
  13 #include "debugfs.h"
  14 #include "parse-events-flex.h"
  15 #include "pmu.h"
  16
  17 #define MAX_NAME_LEN 100
  18
  19 struct event_symbol {
  20         u8              type;
  21         u64             config;
  22         const char      *symbol;
  23         const char      *alias;
  24 };
  25
  26 int parse_events_parse(struct list_head *list, int *idx);
  27
  28 #define CHW(x) .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_##x
  29 #define CSW(x) .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_##x
  30
  31 static struct event_symbol event_symbols[] = {
  32   { CHW(CPU_CYCLES),                    "cpu-cycles",                   "cycles"                },
  33   { CHW(STALLED_CYCLES_FRONTEND),       "stalled-cycles-frontend",      "idle-cycles-frontend"  },
  34   { CHW(STALLED_CYCLES_BACKEND),        "stalled-cycles-backend",       "idle-cycles-backend"   },
  35   { CHW(INSTRUCTIONS),                  "instructions",                 ""                      },
  36   { CHW(CACHE_REFERENCES),              "cache-references",             ""                      },
  37   { CHW(CACHE_MISSES),                  "cache-misses",                 ""                      },
  38   { CHW(BRANCH_INSTRUCTIONS),           "branch-instructions",          "branches"              },
  39   { CHW(BRANCH_MISSES),                 "branch-misses",                ""                      },
  40   { CHW(BUS_CYCLES),                    "bus-cycles",                   ""                      },
  41   { CHW(REF_CPU_CYCLES),                "ref-cycles",                   ""                      },
  42
  43   { CSW(CPU_CLOCK),                     "cpu-clock",                    ""                      },
  44   { CSW(TASK_CLOCK),                    "task-clock",                   ""                      },
  45   { CSW(PAGE_FAULTS),                   "page-faults",                  "faults"                },
  46   { CSW(PAGE_FAULTS_MIN),               "minor-faults",                 ""                      },
  47   { CSW(PAGE_FAULTS_MAJ),               "major-faults",                 ""                      },
  48   { CSW(CONTEXT_SWITCHES),              "context-switches",             "cs"                    },
  49   { CSW(CPU_MIGRATIONS),                "cpu-migrations",               "migrations"            },
  50   { CSW(ALIGNMENT_FAULTS),              "alignment-faults",             ""                      },
  51   { CSW(EMULATION_FAULTS),              "emulation-faults",             ""                      },
  52 };
  53
  54 #define __PERF_EVENT_FIELD(config, name) \
  55         ((config & PERF_EVENT_##name##_MASK) >> PERF_EVENT_##name##_SHIFT)
  56
  57 #define PERF_EVENT_RAW(config)          __PERF_EVENT_FIELD(config, RAW)
  58 #define PERF_EVENT_CONFIG(config)       __PERF_EVENT_FIELD(config, CONFIG)
  59 #define PERF_EVENT_TYPE(config)         __PERF_EVENT_FIELD(config, TYPE)
  60 #define PERF_EVENT_ID(config)           __PERF_EVENT_FIELD(config, EVENT)
  61
  62 static const char *hw_event_names[PERF_COUNT_HW_MAX] = {
  63         "cycles",
  64         "instructions",
  65         "cache-references",
  66         "cache-misses",
  67         "branches",
  68         "branch-misses",
  69         "bus-cycles",
  70         "stalled-cycles-frontend",
  71         "stalled-cycles-backend",
  72         "ref-cycles",
  73 };
  74
  75 static const char *sw_event_names[PERF_COUNT_SW_MAX] = {
  76         "cpu-clock",
  77         "task-clock",
  78         "page-faults",
  79         "context-switches",
  80         "CPU-migrations",
  81         "minor-faults",
  82         "major-faults",
  83         "alignment-faults",
  84         "emulation-faults",
  85 };
  86
  87 #define MAX_ALIASES 8
  88
  89 static const char *hw_cache[PERF_COUNT_HW_CACHE_MAX][MAX_ALIASES] = {
  90  { "L1-dcache", "l1-d",         "l1d",          "L1-data",              },
  91  { "L1-icache", "l1-i",         "l1i",          "L1-instruction",       },
  92  { "LLC",       "L2",                                                   },
  93  { "dTLB",      "d-tlb",        "Data-TLB",                             },
  94  { "iTLB",      "i-tlb",        "Instruction-TLB",                      },
  95  { "branch",    "branches",     "bpu",          "btb",          "bpc",  },
  96  { "node",                                                              },
  97 };
  98
  99 static const char *hw_cache_op[PERF_COUNT_HW_CACHE_OP_MAX][MAX_ALIASES] = {
 100  { "load",      "loads",        "read",                                 },
 101  { "store",     "stores",       "write",                                },
 102  { "prefetch",  "prefetches",   "speculative-read", "speculative-load", },
 103 };
 104
 105 static const char *hw_cache_result[PERF_COUNT_HW_CACHE_RESULT_MAX]
 106                                   [MAX_ALIASES] = {
 107  { "refs",      "Reference",    "ops",          "access",               },
 108  { "misses",    "miss",                                                 },
 109 };
 110
 111 #define C(x)            PERF_COUNT_HW_CACHE_##x
 112 #define CACHE_READ      (1 << C(OP_READ))
 113 #define CACHE_WRITE     (1 << C(OP_WRITE))
 114 #define CACHE_PREFETCH  (1 << C(OP_PREFETCH))
 115 #define COP(x)          (1 << x)
 116
 117 /*
 118  * cache operartion stat
 119  * L1I : Read and prefetch only
 120  * ITLB and BPU : Read-only
 121  */
 122 static unsigned long hw_cache_stat[C(MAX)] = {
 123  [C(L1D)]       = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
 124  [C(L1I)]       = (CACHE_READ | CACHE_PREFETCH),
 125  [C(LL)]        = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
 126  [C(DTLB)]      = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
 127  [C(ITLB)]      = (CACHE_READ),
 128  [C(BPU)]       = (CACHE_READ),
 129  [C(NODE)]      = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
 130 };
 131
 132 #define for_each_subsystem(sys_dir, sys_dirent, sys_next)              \
 133         while (!readdir_r(sys_dir, &sys_dirent, &sys_next) && sys_next)        \
 134         if (sys_dirent.d_type == DT_DIR &&                                     \
 135            (strcmp(sys_dirent.d_name, ".")) &&                                 \
 136            (strcmp(sys_dirent.d_name, "..")))
 137
 138 static int tp_event_has_id(struct dirent *sys_dir, struct dirent *evt_dir)
 139 {
 140         char evt_path[MAXPATHLEN];
 141         int fd;
 142
 143         snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", tracing_events_path,
 144                         sys_dir->d_name, evt_dir->d_name);
 145         fd = open(evt_path, O_RDONLY);
 146         if (fd < 0)
 147                 return -EINVAL;
 148         close(fd);
 149
 150         return 0;
 151 }
 152
 153 #define for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next)              \
 154         while (!readdir_r(evt_dir, &evt_dirent, &evt_next) && evt_next)        \
 155         if (evt_dirent.d_type == DT_DIR &&                                     \
 156            (strcmp(evt_dirent.d_name, ".")) &&                                 \
 157            (strcmp(evt_dirent.d_name, "..")) &&                                \
 158            (!tp_event_has_id(&sys_dirent, &evt_dirent)))
 159
 160 #define MAX_EVENT_LENGTH 512
 161
 162
 163 struct tracepoint_path *tracepoint_id_to_path(u64 config)
 164 {
 165         struct tracepoint_path *path = NULL;
 166         DIR *sys_dir, *evt_dir;
 167         struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
 168         char id_buf[24];
 169         int fd;
 170         u64 id;
 171         char evt_path[MAXPATHLEN];
 172         char dir_path[MAXPATHLEN];
 173
 174         if (debugfs_valid_mountpoint(tracing_events_path))
 175                 return NULL;
 176
 177         sys_dir = opendir(tracing_events_path);
 178         if (!sys_dir)
 179                 return NULL;
 180
 181         for_each_subsystem(sys_dir, sys_dirent, sys_next) {
 182
 183                 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
 184                          sys_dirent.d_name);
 185                 evt_dir = opendir(dir_path);
 186                 if (!evt_dir)
 187                         continue;
 188
 189                 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) {
 190
 191                         snprintf(evt_path, MAXPATHLEN, "%s/%s/id", dir_path,
 192                                  evt_dirent.d_name);
 193                         fd = open(evt_path, O_RDONLY);
 194                         if (fd < 0)
 195                                 continue;
 196                         if (read(fd, id_buf, sizeof(id_buf)) < 0) {
 197                                 close(fd);
 198                                 continue;
 199                         }
 200                         close(fd);
 201                         id = atoll(id_buf);
 202                         if (id == config) {
 203                                 closedir(evt_dir);
 204                                 closedir(sys_dir);
 205                                 path = zalloc(sizeof(*path));
 206                                 path->system = malloc(MAX_EVENT_LENGTH);
 207                                 if (!path->system) {
 208                                         free(path);
 209                                         return NULL;
 210                                 }
 211                                 path->name = malloc(MAX_EVENT_LENGTH);
 212                                 if (!path->name) {
 213                                         free(path->system);
 214                                         free(path);
 215                                         return NULL;
 216                                 }
 217                                 strncpy(path->system, sys_dirent.d_name,
 218                                         MAX_EVENT_LENGTH);
 219                                 strncpy(path->name, evt_dirent.d_name,
 220                                         MAX_EVENT_LENGTH);
 221                                 return path;
 222                         }
 223                 }
 224                 closedir(evt_dir);
 225         }
 226
 227         closedir(sys_dir);
 228         return NULL;
 229 }
 230
 231 #define TP_PATH_LEN (MAX_EVENT_LENGTH * 2 + 1)
 232 static const char *tracepoint_id_to_name(u64 config)
 233 {
 234         static char buf[TP_PATH_LEN];
 235         struct tracepoint_path *path;
 236
 237         path = tracepoint_id_to_path(config);
 238         if (path) {
 239                 snprintf(buf, TP_PATH_LEN, "%s:%s", path->system, path->name);
 240                 free(path->name);
 241                 free(path->system);
 242                 free(path);
 243         } else
 244                 snprintf(buf, TP_PATH_LEN, "%s:%s", "unknown", "unknown");
 245
 246         return buf;
 247 }
 248
 249 static int is_cache_op_valid(u8 cache_type, u8 cache_op)
 250 {
 251         if (hw_cache_stat[cache_type] & COP(cache_op))
 252                 return 1;       /* valid */
 253         else
 254                 return 0;       /* invalid */
 255 }
 256
 257 static char *event_cache_name(u8 cache_type, u8 cache_op, u8 cache_result)
 258 {
 259         static char name[50];
 260
 261         if (cache_result) {
 262                 sprintf(name, "%s-%s-%s", hw_cache[cache_type][0],
 263                         hw_cache_op[cache_op][0],
 264                         hw_cache_result[cache_result][0]);
 265         } else {
 266                 sprintf(name, "%s-%s", hw_cache[cache_type][0],
 267                         hw_cache_op[cache_op][1]);
 268         }
 269
 270         return name;
 271 }
 272
 273 const char *event_type(int type)
 274 {
 275         switch (type) {
 276         case PERF_TYPE_HARDWARE:
 277                 return "hardware";
 278
 279         case PERF_TYPE_SOFTWARE:
 280                 return "software";
 281
 282         case PERF_TYPE_TRACEPOINT:
 283                 return "tracepoint";
 284
 285         case PERF_TYPE_HW_CACHE:
 286                 return "hardware-cache";
 287
 288         default:
 289                 break;
 290         }
 291
 292         return "unknown";
 293 }
 294
 295 const char *event_name(struct perf_evsel *evsel)
 296 {
 297         u64 config = evsel->attr.config;
 298         int type = evsel->attr.type;
 299
 300         if (evsel->name)
 301                 return evsel->name;
 302
 303         return __event_name(type, config);
 304 }
 305
 306 const char *__event_name(int type, u64 config)
 307 {
 308         static char buf[32];
 309
 310         if (type == PERF_TYPE_RAW) {
 311                 sprintf(buf, "raw 0x%" PRIx64, config);
 312                 return buf;
 313         }
 314
 315         switch (type) {
 316         case PERF_TYPE_HARDWARE:
 317                 if (config < PERF_COUNT_HW_MAX && hw_event_names[config])
 318                         return hw_event_names[config];
 319                 return "unknown-hardware";
 320
 321         case PERF_TYPE_HW_CACHE: {
 322                 u8 cache_type, cache_op, cache_result;
 323
 324                 cache_type   = (config >>  0) & 0xff;
 325                 if (cache_type > PERF_COUNT_HW_CACHE_MAX)
 326                         return "unknown-ext-hardware-cache-type";
 327
 328                 cache_op     = (config >>  8) & 0xff;
 329                 if (cache_op > PERF_COUNT_HW_CACHE_OP_MAX)
 330                         return "unknown-ext-hardware-cache-op";
 331
 332                 cache_result = (config >> 16) & 0xff;
 333                 if (cache_result > PERF_COUNT_HW_CACHE_RESULT_MAX)
 334                         return "unknown-ext-hardware-cache-result";
 335
 336                 if (!is_cache_op_valid(cache_type, cache_op))
 337                         return "invalid-cache";
 338
 339                 return event_cache_name(cache_type, cache_op, cache_result);
 340         }
 341
 342         case PERF_TYPE_SOFTWARE:
 343                 if (config < PERF_COUNT_SW_MAX && sw_event_names[config])
 344                         return sw_event_names[config];
 345                 return "unknown-software";
 346
 347         case PERF_TYPE_TRACEPOINT:
 348                 return tracepoint_id_to_name(config);
 349
 350         default:
 351                 break;
 352         }
 353
 354         return "unknown";
 355 }
 356
 357 static int add_event(struct list_head *list, int *idx,
 358                      struct perf_event_attr *attr, char *name)
 359 {
 360         struct perf_evsel *evsel;
 361
 362         event_attr_init(attr);
 363
 364         evsel = perf_evsel__new(attr, (*idx)++);
 365         if (!evsel)
 366                 return -ENOMEM;
 367
 368         list_add_tail(&evsel->node, list);
 369
 370         evsel->name = strdup(name);
 371         return 0;
 372 }
 373
 374 static int parse_aliases(char *str, const char *names[][MAX_ALIASES], int size)
 375 {
 376         int i, j;
 377         int n, longest = -1;
 378
 379         for (i = 0; i < size; i++) {
 380                 for (j = 0; j < MAX_ALIASES && names[i][j]; j++) {
 381                         n = strlen(names[i][j]);
 382                         if (n > longest && !strncasecmp(str, names[i][j], n))
 383                                 longest = n;
 384                 }
 385                 if (longest > 0)
 386                         return i;
 387         }
 388
 389         return -1;
 390 }
 391
 392 int parse_events_add_cache(struct list_head *list, int *idx,
 393                            char *type, char *op_result1, char *op_result2)
 394 {
 395         struct perf_event_attr attr;
 396         char name[MAX_NAME_LEN];
 397         int cache_type = -1, cache_op = -1, cache_result = -1;
 398         char *op_result[2] = { op_result1, op_result2 };
 399         int i, n;
 400
 401         /*
 402          * No fallback - if we cannot get a clear cache type
 403          * then bail out:
 404          */
 405         cache_type = parse_aliases(type, hw_cache,
 406                                    PERF_COUNT_HW_CACHE_MAX);
 407         if (cache_type == -1)
 408                 return -EINVAL;
 409
 410         n = snprintf(name, MAX_NAME_LEN, "%s", type);
 411
 412         for (i = 0; (i < 2) && (op_result[i]); i++) {
 413                 char *str = op_result[i];
 414
 415                 snprintf(name + n, MAX_NAME_LEN - n, "-%s\n", str);
 416
 417                 if (cache_op == -1) {
 418                         cache_op = parse_aliases(str, hw_cache_op,
 419                                                  PERF_COUNT_HW_CACHE_OP_MAX);
 420                         if (cache_op >= 0) {
 421                                 if (!is_cache_op_valid(cache_type, cache_op))
 422                                         return -EINVAL;
 423                                 continue;
 424                         }
 425                 }
 426
 427                 if (cache_result == -1) {
 428                         cache_result = parse_aliases(str, hw_cache_result,
 429                                                 PERF_COUNT_HW_CACHE_RESULT_MAX);
 430                         if (cache_result >= 0)
 431                                 continue;
 432                 }
 433         }
 434
 435         /*
 436          * Fall back to reads:
 437          */
 438         if (cache_op == -1)
 439                 cache_op = PERF_COUNT_HW_CACHE_OP_READ;
 440
 441         /*
 442          * Fall back to accesses:
 443          */
 444         if (cache_result == -1)
 445                 cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS;
 446
 447         memset(&attr, 0, sizeof(attr));
 448         attr.config = cache_type | (cache_op << 8) | (cache_result << 16);
 449         attr.type = PERF_TYPE_HW_CACHE;
 450         return add_event(list, idx, &attr, name);
 451 }
 452
 453 static int add_tracepoint(struct list_head *list, int *idx,
 454                           char *sys_name, char *evt_name)
 455 {
 456         struct perf_event_attr attr;
 457         char name[MAX_NAME_LEN];
 458         char evt_path[MAXPATHLEN];
 459         char id_buf[4];
 460         u64 id;
 461         int fd;
 462
 463         snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", tracing_events_path,
 464                  sys_name, evt_name);
 465
 466         fd = open(evt_path, O_RDONLY);
 467         if (fd < 0)
 468                 return -1;
 469
 470         if (read(fd, id_buf, sizeof(id_buf)) < 0) {
 471                 close(fd);
 472                 return -1;
 473         }
 474
 475         close(fd);
 476         id = atoll(id_buf);
 477
 478         memset(&attr, 0, sizeof(attr));
 479         attr.config = id;
 480         attr.type = PERF_TYPE_TRACEPOINT;
 481         attr.sample_type |= PERF_SAMPLE_RAW;
 482         attr.sample_type |= PERF_SAMPLE_TIME;
 483         attr.sample_type |= PERF_SAMPLE_CPU;
 484         attr.sample_period = 1;
 485
 486         snprintf(name, MAX_NAME_LEN, "%s:%s", sys_name, evt_name);
 487         return add_event(list, idx, &attr, name);
 488 }
 489
 490 static int add_tracepoint_multi(struct list_head *list, int *idx,
 491                                 char *sys_name, char *evt_name)
 492 {
 493         char evt_path[MAXPATHLEN];
 494         struct dirent *evt_ent;
 495         DIR *evt_dir;
 496         int ret = 0;
 497
 498         snprintf(evt_path, MAXPATHLEN, "%s/%s", tracing_events_path, sys_name);
 499         evt_dir = opendir(evt_path);
 500         if (!evt_dir) {
 501                 perror("Can't open event dir");
 502                 return -1;
 503         }
 504
 505         while (!ret && (evt_ent = readdir(evt_dir))) {
 506                 if (!strcmp(evt_ent->d_name, ".")
 507                     || !strcmp(evt_ent->d_name, "..")
 508                     || !strcmp(evt_ent->d_name, "enable")
 509                     || !strcmp(evt_ent->d_name, "filter"))
 510                         continue;
 511
 512                 if (!strglobmatch(evt_ent->d_name, evt_name))
 513                         continue;
 514
 515                 ret = add_tracepoint(list, idx, sys_name, evt_ent->d_name);
 516         }
 517
 518         return ret;
 519 }
 520
 521 int parse_events_add_tracepoint(struct list_head *list, int *idx,
 522                                 char *sys, char *event)
 523 {
 524         int ret;
 525
 526         ret = debugfs_valid_mountpoint(tracing_events_path);
 527         if (ret)
 528                 return ret;
 529
 530         return strpbrk(event, "*?") ?
 531                add_tracepoint_multi(list, idx, sys, event) :
 532                add_tracepoint(list, idx, sys, event);
 533 }
 534
 535 static int
 536 parse_breakpoint_type(const char *type, struct perf_event_attr *attr)
 537 {
 538         int i;
 539
 540         for (i = 0; i < 3; i++) {
 541                 if (!type || !type[i])
 542                         break;
 543
 544                 switch (type[i]) {
 545                 case 'r':
 546                         attr->bp_type |= HW_BREAKPOINT_R;
 547                         break;
 548                 case 'w':
 549                         attr->bp_type |= HW_BREAKPOINT_W;
 550                         break;
 551                 case 'x':
 552                         attr->bp_type |= HW_BREAKPOINT_X;
 553                         break;
 554                 default:
 555                         return -EINVAL;
 556                 }
 557         }
 558
 559         if (!attr->bp_type) /* Default */
 560                 attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W;
 561
 562         return 0;
 563 }
 564
 565 int parse_events_add_breakpoint(struct list_head *list, int *idx,
 566                                 void *ptr, char *type)
 567 {
 568         struct perf_event_attr attr;
 569         char name[MAX_NAME_LEN];
 570
 571         memset(&attr, 0, sizeof(attr));
 572         attr.bp_addr = (unsigned long) ptr;
 573
 574         if (parse_breakpoint_type(type, &attr))
 575                 return -EINVAL;
 576
 577         /*
 578          * We should find a nice way to override the access length
 579          * Provide some defaults for now
 580          */
 581         if (attr.bp_type == HW_BREAKPOINT_X)
 582                 attr.bp_len = sizeof(long);
 583         else
 584                 attr.bp_len = HW_BREAKPOINT_LEN_4;
 585
 586         attr.type = PERF_TYPE_BREAKPOINT;
 587
 588         snprintf(name, MAX_NAME_LEN, "mem:%p:%s", ptr, type ? type : "rw");
 589         return add_event(list, idx, &attr, name);
 590 }
 591
 592 static int config_term(struct perf_event_attr *attr,
 593                        struct parse_events__term *term)
 594 {
 595         switch (term->type) {
 596         case PARSE_EVENTS__TERM_TYPE_CONFIG:
 597                 attr->config = term->val.num;
 598                 break;
 599         case PARSE_EVENTS__TERM_TYPE_CONFIG1:
 600                 attr->config1 = term->val.num;
 601                 break;
 602         case PARSE_EVENTS__TERM_TYPE_CONFIG2:
 603                 attr->config2 = term->val.num;
 604                 break;
 605         case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
 606                 attr->sample_period = term->val.num;
 607                 break;
 608         case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
 609                 /*
 610                  * TODO uncomment when the field is available
 611                  * attr->branch_sample_type = term->val.num;
 612                  */
 613                 break;
 614         default:
 615                 return -EINVAL;
 616         }
 617         return 0;
 618 }
 619
 620 static int config_attr(struct perf_event_attr *attr,
 621                        struct list_head *head, int fail)
 622 {
 623         struct parse_events__term *term;
 624
 625         list_for_each_entry(term, head, list)
 626                 if (config_term(attr, term) && fail)
 627                         return -EINVAL;
 628
 629         return 0;
 630 }
 631
 632 int parse_events_add_numeric(struct list_head *list, int *idx,
 633                              unsigned long type, unsigned long config,
 634                              struct list_head *head_config)
 635 {
 636         struct perf_event_attr attr;
 637
 638         memset(&attr, 0, sizeof(attr));
 639         attr.type = type;
 640         attr.config = config;
 641
 642         if (head_config &&
 643             config_attr(&attr, head_config, 1))
 644                 return -EINVAL;
 645
 646         return add_event(list, idx, &attr,
 647                          (char *) __event_name(type, config));
 648 }
 649
 650 int parse_events_add_pmu(struct list_head *list, int *idx,
 651                          char *name, struct list_head *head_config)
 652 {
 653         struct perf_event_attr attr;
 654         struct perf_pmu *pmu;
 655
 656         pmu = perf_pmu__find(name);
 657         if (!pmu)
 658                 return -EINVAL;
 659
 660         memset(&attr, 0, sizeof(attr));
 661
 662         /*
 663          * Configure hardcoded terms first, no need to check
 664          * return value when called with fail == 0 ;)
 665          */
 666         config_attr(&attr, head_config, 0);
 667
 668         if (perf_pmu__config(pmu, &attr, head_config))
 669                 return -EINVAL;
 670
 671         return add_event(list, idx, &attr, (char *) "pmu");
 672 }
 673
 674 int parse_events_modifier(struct list_head *list, char *str)
 675 {
 676         struct perf_evsel *evsel;
 677         int exclude = 0, exclude_GH = 0;
 678         int eu = 0, ek = 0, eh = 0, eH = 0, eG = 0, precise = 0;
 679
 680         if (str == NULL)
 681                 return 0;
 682
 683         while (*str) {
 684                 if (*str == 'u') {
 685                         if (!exclude)
 686                                 exclude = eu = ek = eh = 1;
 687                         eu = 0;
 688                 } else if (*str == 'k') {
 689                         if (!exclude)
 690                                 exclude = eu = ek = eh = 1;
 691                         ek = 0;
 692                 } else if (*str == 'h') {
 693                         if (!exclude)
 694                                 exclude = eu = ek = eh = 1;
 695                         eh = 0;
 696                 } else if (*str == 'G') {
 697                         if (!exclude_GH)
 698                                 exclude_GH = eG = eH = 1;
 699                         eG = 0;
 700                 } else if (*str == 'H') {
 701                         if (!exclude_GH)
 702                                 exclude_GH = eG = eH = 1;
 703                         eH = 0;
 704                 } else if (*str == 'p') {
 705                         precise++;
 706                 } else
 707                         break;
 708
 709                 ++str;
 710         }
 711
 712         /*
 713          * precise ip:
 714          *
 715          *  0 - SAMPLE_IP can have arbitrary skid
 716          *  1 - SAMPLE_IP must have constant skid
 717          *  2 - SAMPLE_IP requested to have 0 skid
 718          *  3 - SAMPLE_IP must have 0 skid
 719          *
 720          *  See also PERF_RECORD_MISC_EXACT_IP
 721          */
 722         if (precise > 3)
 723                 return -EINVAL;
 724
 725         list_for_each_entry(evsel, list, node) {
 726                 evsel->attr.exclude_user   = eu;
 727                 evsel->attr.exclude_kernel = ek;
 728                 evsel->attr.exclude_hv     = eh;
 729                 evsel->attr.precise_ip     = precise;
 730                 evsel->attr.exclude_host   = eH;
 731                 evsel->attr.exclude_guest  = eG;
 732         }
 733
 734         return 0;
 735 }
 736
 737 int parse_events(struct perf_evlist *evlist, const char *str, int unset __used)
 738 {
 739         struct perf_evsel *evsel, *h;
 740         LIST_HEAD(list);
 741         YY_BUFFER_STATE buffer;
 742         int ret, idx = evlist->nr_entries;
 743
 744         buffer = parse_events__scan_string(str);
 745
 746         ret = parse_events_parse(&list, &idx);
 747
 748         parse_events__flush_buffer(buffer);
 749         parse_events__delete_buffer(buffer);
 750
 751         if (!ret) {
 752                 int entries = idx - evlist->nr_entries;
 753                 perf_evlist__splice_list_tail(evlist, &list, entries);
 754                 return 0;
 755         }
 756
 757         list_for_each_entry_safe(evsel, h, &list, node)
 758                 perf_evsel__delete(evsel);
 759
 760         fprintf(stderr, "invalid or unsupported event: '%s'\n", str);
 761         fprintf(stderr, "Run 'perf list' for a list of valid events\n");
 762         return ret;
 763 }
 764
 765 int parse_events_option(const struct option *opt, const char *str,
 766                         int unset __used)
 767 {
 768         struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
 769         return parse_events(evlist, str, unset);
 770 }
 771
 772 int parse_filter(const struct option *opt, const char *str,
 773                  int unset __used)
 774 {
 775         struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
 776         struct perf_evsel *last = NULL;
 777
 778         if (evlist->nr_entries > 0)
 779                 last = list_entry(evlist->entries.prev, struct perf_evsel, node);
 780
 781         if (last == NULL || last->attr.type != PERF_TYPE_TRACEPOINT) {
 782                 fprintf(stderr,
 783                         "-F option should follow a -e tracepoint option\n");
 784                 return -1;
 785         }
 786
 787         last->filter = strdup(str);
 788         if (last->filter == NULL) {
 789                 fprintf(stderr, "not enough memory to hold filter string\n");
 790                 return -1;
 791         }
 792
 793         return 0;
 794 }
 795
 796 static const char * const event_type_descriptors[] = {
 797         "Hardware event",
 798         "Software event",
 799         "Tracepoint event",
 800         "Hardware cache event",
 801         "Raw hardware event descriptor",
 802         "Hardware breakpoint",
 803 };
 804
 805 /*
 806  * Print the events from <debugfs_mount_point>/tracing/events
 807  */
 808
 809 void print_tracepoint_events(const char *subsys_glob, const char *event_glob)
 810 {
 811         DIR *sys_dir, *evt_dir;
 812         struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
 813         char evt_path[MAXPATHLEN];
 814         char dir_path[MAXPATHLEN];
 815
 816         if (debugfs_valid_mountpoint(tracing_events_path))
 817                 return;
 818
 819         sys_dir = opendir(tracing_events_path);
 820         if (!sys_dir)
 821                 return;
 822
 823         for_each_subsystem(sys_dir, sys_dirent, sys_next) {
 824                 if (subsys_glob != NULL &&
 825                     !strglobmatch(sys_dirent.d_name, subsys_glob))
 826                         continue;
 827
 828                 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
 829                          sys_dirent.d_name);
 830                 evt_dir = opendir(dir_path);
 831                 if (!evt_dir)
 832                         continue;
 833
 834                 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) {
 835                         if (event_glob != NULL &&
 836                             !strglobmatch(evt_dirent.d_name, event_glob))
 837                                 continue;
 838
 839                         snprintf(evt_path, MAXPATHLEN, "%s:%s",
 840                                  sys_dirent.d_name, evt_dirent.d_name);
 841                         printf("  %-50s [%s]\n", evt_path,
 842                                 event_type_descriptors[PERF_TYPE_TRACEPOINT]);
 843                 }
 844                 closedir(evt_dir);
 845         }
 846         closedir(sys_dir);
 847 }
 848
 849 /*
 850  * Check whether event is in <debugfs_mount_point>/tracing/events
 851  */
 852
 853 int is_valid_tracepoint(const char *event_string)
 854 {
 855         DIR *sys_dir, *evt_dir;
 856         struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
 857         char evt_path[MAXPATHLEN];
 858         char dir_path[MAXPATHLEN];
 859
 860         if (debugfs_valid_mountpoint(tracing_events_path))
 861                 return 0;
 862
 863         sys_dir = opendir(tracing_events_path);
 864         if (!sys_dir)
 865                 return 0;
 866
 867         for_each_subsystem(sys_dir, sys_dirent, sys_next) {
 868
 869                 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
 870                          sys_dirent.d_name);
 871                 evt_dir = opendir(dir_path);
 872                 if (!evt_dir)
 873                         continue;
 874
 875                 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) {
 876                         snprintf(evt_path, MAXPATHLEN, "%s:%s",
 877                                  sys_dirent.d_name, evt_dirent.d_name);
 878                         if (!strcmp(evt_path, event_string)) {
 879                                 closedir(evt_dir);
 880                                 closedir(sys_dir);
 881                                 return 1;
 882                         }
 883                 }
 884                 closedir(evt_dir);
 885         }
 886         closedir(sys_dir);
 887         return 0;
 888 }
 889
 890 void print_events_type(u8 type)
 891 {
 892         struct event_symbol *syms = event_symbols;
 893         unsigned int i;
 894         char name[64];
 895
 896         for (i = 0; i < ARRAY_SIZE(event_symbols); i++, syms++) {
 897                 if (type != syms->type)
 898                         continue;
 899
 900                 if (strlen(syms->alias))
 901                         snprintf(name, sizeof(name),  "%s OR %s",
 902                                  syms->symbol, syms->alias);
 903                 else
 904                         snprintf(name, sizeof(name), "%s", syms->symbol);
 905
 906                 printf("  %-50s [%s]\n", name,
 907                         event_type_descriptors[type]);
 908         }
 909 }
 910
 911 int print_hwcache_events(const char *event_glob)
 912 {
 913         unsigned int type, op, i, printed = 0;
 914
 915         for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) {
 916                 for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) {
 917                         /* skip invalid cache type */
 918                         if (!is_cache_op_valid(type, op))
 919                                 continue;
 920
 921                         for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
 922                                 char *name = event_cache_name(type, op, i);
 923
 924                                 if (event_glob != NULL && !strglobmatch(name, event_glob))
 925                                         continue;
 926
 927                                 printf("  %-50s [%s]\n", name,
 928                                         event_type_descriptors[PERF_TYPE_HW_CACHE]);
 929                                 ++printed;
 930                         }
 931                 }
 932         }
 933
 934         return printed;
 935 }
 936
 937 /*
 938  * Print the help text for the event symbols:
 939  */
 940 void print_events(const char *event_glob)
 941 {
 942         unsigned int i, type, prev_type = -1, printed = 0, ntypes_printed = 0;
 943         struct event_symbol *syms = event_symbols;
 944         char name[MAX_NAME_LEN];
 945
 946         printf("\n");
 947         printf("List of pre-defined events (to be used in -e):\n");
 948
 949         for (i = 0; i < ARRAY_SIZE(event_symbols); i++, syms++) {
 950                 type = syms->type;
 951
 952                 if (type != prev_type && printed) {
 953                         printf("\n");
 954                         printed = 0;
 955                         ntypes_printed++;
 956                 }
 957
 958                 if (event_glob != NULL &&
 959                     !(strglobmatch(syms->symbol, event_glob) ||
 960                       (syms->alias && strglobmatch(syms->alias, event_glob))))
 961                         continue;
 962
 963                 if (strlen(syms->alias))
 964                         snprintf(name, MAX_NAME_LEN, "%s OR %s", syms->symbol, syms->alias);
 965                 else
 966                         strncpy(name, syms->symbol, MAX_NAME_LEN);
 967                 printf("  %-50s [%s]\n", name,
 968                         event_type_descriptors[type]);
 969
 970                 prev_type = type;
 971                 ++printed;
 972         }
 973
 974         if (ntypes_printed) {
 975                 printed = 0;
 976                 printf("\n");
 977         }
 978         print_hwcache_events(event_glob);
 979
 980         if (event_glob != NULL)
 981                 return;
 982
 983         printf("\n");
 984         printf("  %-50s [%s]\n",
 985                "rNNN",
 986                event_type_descriptors[PERF_TYPE_RAW]);
 987         printf("  %-50s [%s]\n",
 988                "cpu/t1=v1[,t2=v2,t3 ...]/modifier",
 989                event_type_descriptors[PERF_TYPE_RAW]);
 990         printf("   (see 'perf list --help' on how to encode it)\n");
 991         printf("\n");
 992
 993         printf("  %-50s [%s]\n",
 994                         "mem:<addr>[:access]",
 995                         event_type_descriptors[PERF_TYPE_BREAKPOINT]);
 996         printf("\n");
 997
 998         print_tracepoint_events(NULL, NULL);
 999 }
1000
1001 int parse_events__is_hardcoded_term(struct parse_events__term *term)
1002 {
1003         return term->type <= PARSE_EVENTS__TERM_TYPE_HARDCODED_MAX;
1004 }
1005
1006 int parse_events__new_term(struct parse_events__term **_term, int type,
1007                            char *config, char *str, long num)
1008 {
1009         struct parse_events__term *term;
1010
1011         term = zalloc(sizeof(*term));
1012         if (!term)
1013                 return -ENOMEM;
1014
1015         INIT_LIST_HEAD(&term->list);
1016         term->type = type;
1017         term->config = config;
1018
1019         switch (type) {
1020         case PARSE_EVENTS__TERM_TYPE_CONFIG:
1021         case PARSE_EVENTS__TERM_TYPE_CONFIG1:
1022         case PARSE_EVENTS__TERM_TYPE_CONFIG2:
1023         case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
1024         case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
1025         case PARSE_EVENTS__TERM_TYPE_NUM:
1026                 term->val.num = num;
1027                 break;
1028         case PARSE_EVENTS__TERM_TYPE_STR:
1029                 term->val.str = str;
1030                 break;
1031         default:
1032                 return -EINVAL;
1033         }
1034
1035         *_term = term;
1036         return 0;
1037 }
1038
1039 void parse_events__free_terms(struct list_head *terms)
1040 {
1041         struct parse_events__term *term, *h;
1042
1043         list_for_each_entry_safe(term, h, terms, list)
1044                 free(term);
1045
1046         free(terms);
1047 }