tools/perf/util/parse-events.c

   1 #include <linux/hw_breakpoint.h>
   2 #include <linux/err.h>
   3 #include "util.h"
   4 #include "../perf.h"
   5 #include "evlist.h"
   6 #include "evsel.h"
   7 #include "parse-options.h"
   8 #include "parse-events.h"
   9 #include "exec_cmd.h"
  10 #include "string.h"
  11 #include "symbol.h"
  12 #include "cache.h"
  13 #include "header.h"
  14 #include "debug.h"
  15 #include <api/fs/tracing_path.h>
  16 #include "parse-events-bison.h"
  17 #define YY_EXTRA_TYPE int
  18 #include "parse-events-flex.h"
  19 #include "pmu.h"
  20 #include "thread_map.h"
  21 #include "cpumap.h"
  22 #include "asm/bug.h"
  23
  24 #define MAX_NAME_LEN 100
  25
  26 #ifdef PARSER_DEBUG
  27 extern int parse_events_debug;
  28 #endif
  29 int parse_events_parse(void *data, void *scanner);
  30
  31 static struct perf_pmu_event_symbol *perf_pmu_events_list;
  32 /*
  33  * The variable indicates the number of supported pmu event symbols.
  34  * 0 means not initialized and ready to init
  35  * -1 means failed to init, don't try anymore
  36  * >0 is the number of supported pmu event symbols
  37  */
  38 static int perf_pmu_events_list_num;
  39
  40 struct event_symbol event_symbols_hw[PERF_COUNT_HW_MAX] = {
  41         [PERF_COUNT_HW_CPU_CYCLES] = {
  42                 .symbol = "cpu-cycles",
  43                 .alias  = "cycles",
  44         },
  45         [PERF_COUNT_HW_INSTRUCTIONS] = {
  46                 .symbol = "instructions",
  47                 .alias  = "",
  48         },
  49         [PERF_COUNT_HW_CACHE_REFERENCES] = {
  50                 .symbol = "cache-references",
  51                 .alias  = "",
  52         },
  53         [PERF_COUNT_HW_CACHE_MISSES] = {
  54                 .symbol = "cache-misses",
  55                 .alias  = "",
  56         },
  57         [PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = {
  58                 .symbol = "branch-instructions",
  59                 .alias  = "branches",
  60         },
  61         [PERF_COUNT_HW_BRANCH_MISSES] = {
  62                 .symbol = "branch-misses",
  63                 .alias  = "",
  64         },
  65         [PERF_COUNT_HW_BUS_CYCLES] = {
  66                 .symbol = "bus-cycles",
  67                 .alias  = "",
  68         },
  69         [PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = {
  70                 .symbol = "stalled-cycles-frontend",
  71                 .alias  = "idle-cycles-frontend",
  72         },
  73         [PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = {
  74                 .symbol = "stalled-cycles-backend",
  75                 .alias  = "idle-cycles-backend",
  76         },
  77         [PERF_COUNT_HW_REF_CPU_CYCLES] = {
  78                 .symbol = "ref-cycles",
  79                 .alias  = "",
  80         },
  81 };
  82
  83 struct event_symbol event_symbols_sw[PERF_COUNT_SW_MAX] = {
  84         [PERF_COUNT_SW_CPU_CLOCK] = {
  85                 .symbol = "cpu-clock",
  86                 .alias  = "",
  87         },
  88         [PERF_COUNT_SW_TASK_CLOCK] = {
  89                 .symbol = "task-clock",
  90                 .alias  = "",
  91         },
  92         [PERF_COUNT_SW_PAGE_FAULTS] = {
  93                 .symbol = "page-faults",
  94                 .alias  = "faults",
  95         },
  96         [PERF_COUNT_SW_CONTEXT_SWITCHES] = {
  97                 .symbol = "context-switches",
  98                 .alias  = "cs",
  99         },
 100         [PERF_COUNT_SW_CPU_MIGRATIONS] = {
 101                 .symbol = "cpu-migrations",
 102                 .alias  = "migrations",
 103         },
 104         [PERF_COUNT_SW_PAGE_FAULTS_MIN] = {
 105                 .symbol = "minor-faults",
 106                 .alias  = "",
 107         },
 108         [PERF_COUNT_SW_PAGE_FAULTS_MAJ] = {
 109                 .symbol = "major-faults",
 110                 .alias  = "",
 111         },
 112         [PERF_COUNT_SW_ALIGNMENT_FAULTS] = {
 113                 .symbol = "alignment-faults",
 114                 .alias  = "",
 115         },
 116         [PERF_COUNT_SW_EMULATION_FAULTS] = {
 117                 .symbol = "emulation-faults",
 118                 .alias  = "",
 119         },
 120         [PERF_COUNT_SW_DUMMY] = {
 121                 .symbol = "dummy",
 122                 .alias  = "",
 123         },
 124 };
 125
 126 #define __PERF_EVENT_FIELD(config, name) \
 127         ((config & PERF_EVENT_##name##_MASK) >> PERF_EVENT_##name##_SHIFT)
 128
 129 #define PERF_EVENT_RAW(config)          __PERF_EVENT_FIELD(config, RAW)
 130 #define PERF_EVENT_CONFIG(config)       __PERF_EVENT_FIELD(config, CONFIG)
 131 #define PERF_EVENT_TYPE(config)         __PERF_EVENT_FIELD(config, TYPE)
 132 #define PERF_EVENT_ID(config)           __PERF_EVENT_FIELD(config, EVENT)
 133
 134 #define for_each_subsystem(sys_dir, sys_dirent, sys_next)              \
 135         while (!readdir_r(sys_dir, &sys_dirent, &sys_next) && sys_next)        \
 136         if (sys_dirent.d_type == DT_DIR &&                                     \
 137            (strcmp(sys_dirent.d_name, ".")) &&                                 \
 138            (strcmp(sys_dirent.d_name, "..")))
 139
 140 static int tp_event_has_id(struct dirent *sys_dir, struct dirent *evt_dir)
 141 {
 142         char evt_path[MAXPATHLEN];
 143         int fd;
 144
 145         snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", tracing_events_path,
 146                         sys_dir->d_name, evt_dir->d_name);
 147         fd = open(evt_path, O_RDONLY);
 148         if (fd < 0)
 149                 return -EINVAL;
 150         close(fd);
 151
 152         return 0;
 153 }
 154
 155 #define for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next)              \
 156         while (!readdir_r(evt_dir, &evt_dirent, &evt_next) && evt_next)        \
 157         if (evt_dirent.d_type == DT_DIR &&                                     \
 158            (strcmp(evt_dirent.d_name, ".")) &&                                 \
 159            (strcmp(evt_dirent.d_name, "..")) &&                                \
 160            (!tp_event_has_id(&sys_dirent, &evt_dirent)))
 161
 162 #define MAX_EVENT_LENGTH 512
 163
 164
 165 struct tracepoint_path *tracepoint_id_to_path(u64 config)
 166 {
 167         struct tracepoint_path *path = NULL;
 168         DIR *sys_dir, *evt_dir;
 169         struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
 170         char id_buf[24];
 171         int fd;
 172         u64 id;
 173         char evt_path[MAXPATHLEN];
 174         char dir_path[MAXPATHLEN];
 175
 176         sys_dir = opendir(tracing_events_path);
 177         if (!sys_dir)
 178                 return NULL;
 179
 180         for_each_subsystem(sys_dir, sys_dirent, sys_next) {
 181
 182                 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
 183                          sys_dirent.d_name);
 184                 evt_dir = opendir(dir_path);
 185                 if (!evt_dir)
 186                         continue;
 187
 188                 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) {
 189
 190                         snprintf(evt_path, MAXPATHLEN, "%s/%s/id", dir_path,
 191                                  evt_dirent.d_name);
 192                         fd = open(evt_path, O_RDONLY);
 193                         if (fd < 0)
 194                                 continue;
 195                         if (read(fd, id_buf, sizeof(id_buf)) < 0) {
 196                                 close(fd);
 197                                 continue;
 198                         }
 199                         close(fd);
 200                         id = atoll(id_buf);
 201                         if (id == config) {
 202                                 closedir(evt_dir);
 203                                 closedir(sys_dir);
 204                                 path = zalloc(sizeof(*path));
 205                                 path->system = malloc(MAX_EVENT_LENGTH);
 206                                 if (!path->system) {
 207                                         free(path);
 208                                         return NULL;
 209                                 }
 210                                 path->name = malloc(MAX_EVENT_LENGTH);
 211                                 if (!path->name) {
 212                                         zfree(&path->system);
 213                                         free(path);
 214                                         return NULL;
 215                                 }
 216                                 strncpy(path->system, sys_dirent.d_name,
 217                                         MAX_EVENT_LENGTH);
 218                                 strncpy(path->name, evt_dirent.d_name,
 219                                         MAX_EVENT_LENGTH);
 220                                 return path;
 221                         }
 222                 }
 223                 closedir(evt_dir);
 224         }
 225
 226         closedir(sys_dir);
 227         return NULL;
 228 }
 229
 230 struct tracepoint_path *tracepoint_name_to_path(const char *name)
 231 {
 232         struct tracepoint_path *path = zalloc(sizeof(*path));
 233         char *str = strchr(name, ':');
 234
 235         if (path == NULL || str == NULL) {
 236                 free(path);
 237                 return NULL;
 238         }
 239
 240         path->system = strndup(name, str - name);
 241         path->name = strdup(str+1);
 242
 243         if (path->system == NULL || path->name == NULL) {
 244                 zfree(&path->system);
 245                 zfree(&path->name);
 246                 free(path);
 247                 path = NULL;
 248         }
 249
 250         return path;
 251 }
 252
 253 const char *event_type(int type)
 254 {
 255         switch (type) {
 256         case PERF_TYPE_HARDWARE:
 257                 return "hardware";
 258
 259         case PERF_TYPE_SOFTWARE:
 260                 return "software";
 261
 262         case PERF_TYPE_TRACEPOINT:
 263                 return "tracepoint";
 264
 265         case PERF_TYPE_HW_CACHE:
 266                 return "hardware-cache";
 267
 268         default:
 269                 break;
 270         }
 271
 272         return "unknown";
 273 }
 274
 275
 276
 277 static struct perf_evsel *
 278 __add_event(struct list_head *list, int *idx,
 279             struct perf_event_attr *attr,
 280             char *name, struct cpu_map *cpus,
 281             struct list_head *config_terms)
 282 {
 283         struct perf_evsel *evsel;
 284
 285         event_attr_init(attr);
 286
 287         evsel = perf_evsel__new_idx(attr, (*idx)++);
 288         if (!evsel)
 289                 return NULL;
 290
 291         evsel->cpus     = cpu_map__get(cpus);
 292         evsel->own_cpus = cpu_map__get(cpus);
 293
 294         if (name)
 295                 evsel->name = strdup(name);
 296
 297         if (config_terms)
 298                 list_splice(config_terms, &evsel->config_terms);
 299
 300         list_add_tail(&evsel->node, list);
 301         return evsel;
 302 }
 303
 304 static int add_event(struct list_head *list, int *idx,
 305                      struct perf_event_attr *attr, char *name,
 306                      struct list_head *config_terms)
 307 {
 308         return __add_event(list, idx, attr, name, NULL, config_terms) ? 0 : -ENOMEM;
 309 }
 310
 311 static int parse_aliases(char *str, const char *names[][PERF_EVSEL__MAX_ALIASES], int size)
 312 {
 313         int i, j;
 314         int n, longest = -1;
 315
 316         for (i = 0; i < size; i++) {
 317                 for (j = 0; j < PERF_EVSEL__MAX_ALIASES && names[i][j]; j++) {
 318                         n = strlen(names[i][j]);
 319                         if (n > longest && !strncasecmp(str, names[i][j], n))
 320                                 longest = n;
 321                 }
 322                 if (longest > 0)
 323                         return i;
 324         }
 325
 326         return -1;
 327 }
 328
 329 int parse_events_add_cache(struct list_head *list, int *idx,
 330                            char *type, char *op_result1, char *op_result2)
 331 {
 332         struct perf_event_attr attr;
 333         char name[MAX_NAME_LEN];
 334         int cache_type = -1, cache_op = -1, cache_result = -1;
 335         char *op_result[2] = { op_result1, op_result2 };
 336         int i, n;
 337
 338         /*
 339          * No fallback - if we cannot get a clear cache type
 340          * then bail out:
 341          */
 342         cache_type = parse_aliases(type, perf_evsel__hw_cache,
 343                                    PERF_COUNT_HW_CACHE_MAX);
 344         if (cache_type == -1)
 345                 return -EINVAL;
 346
 347         n = snprintf(name, MAX_NAME_LEN, "%s", type);
 348
 349         for (i = 0; (i < 2) && (op_result[i]); i++) {
 350                 char *str = op_result[i];
 351
 352                 n += snprintf(name + n, MAX_NAME_LEN - n, "-%s", str);
 353
 354                 if (cache_op == -1) {
 355                         cache_op = parse_aliases(str, perf_evsel__hw_cache_op,
 356                                                  PERF_COUNT_HW_CACHE_OP_MAX);
 357                         if (cache_op >= 0) {
 358                                 if (!perf_evsel__is_cache_op_valid(cache_type, cache_op))
 359                                         return -EINVAL;
 360                                 continue;
 361                         }
 362                 }
 363
 364                 if (cache_result == -1) {
 365                         cache_result = parse_aliases(str, perf_evsel__hw_cache_result,
 366                                                      PERF_COUNT_HW_CACHE_RESULT_MAX);
 367                         if (cache_result >= 0)
 368                                 continue;
 369                 }
 370         }
 371
 372         /*
 373          * Fall back to reads:
 374          */
 375         if (cache_op == -1)
 376                 cache_op = PERF_COUNT_HW_CACHE_OP_READ;
 377
 378         /*
 379          * Fall back to accesses:
 380          */
 381         if (cache_result == -1)
 382                 cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS;
 383
 384         memset(&attr, 0, sizeof(attr));
 385         attr.config = cache_type | (cache_op << 8) | (cache_result << 16);
 386         attr.type = PERF_TYPE_HW_CACHE;
 387         return add_event(list, idx, &attr, name, NULL);
 388 }
 389
 390 static void tracepoint_error(struct parse_events_error *error, int err,
 391                              char *sys, char *name)
 392 {
 393         char help[BUFSIZ];
 394
 395         /*
 396          * We get error directly from syscall errno ( > 0),
 397          * or from encoded pointer's error ( < 0).
 398          */
 399         err = abs(err);
 400
 401         switch (err) {
 402         case EACCES:
 403                 error->str = strdup("can't access trace events");
 404                 break;
 405         case ENOENT:
 406                 error->str = strdup("unknown tracepoint");
 407                 break;
 408         default:
 409                 error->str = strdup("failed to add tracepoint");
 410                 break;
 411         }
 412
 413         tracing_path__strerror_open_tp(err, help, sizeof(help), sys, name);
 414         error->help = strdup(help);
 415 }
 416
 417 static int add_tracepoint(struct list_head *list, int *idx,
 418                           char *sys_name, char *evt_name,
 419                           struct parse_events_error *error __maybe_unused)
 420 {
 421         struct perf_evsel *evsel;
 422
 423         evsel = perf_evsel__newtp_idx(sys_name, evt_name, (*idx)++);
 424         if (IS_ERR(evsel)) {
 425                 tracepoint_error(error, PTR_ERR(evsel), sys_name, evt_name);
 426                 return PTR_ERR(evsel);
 427         }
 428
 429         list_add_tail(&evsel->node, list);
 430         return 0;
 431 }
 432
 433 static int add_tracepoint_multi_event(struct list_head *list, int *idx,
 434                                       char *sys_name, char *evt_name,
 435                                       struct parse_events_error *error)
 436 {
 437         char evt_path[MAXPATHLEN];
 438         struct dirent *evt_ent;
 439         DIR *evt_dir;
 440         int ret = 0;
 441
 442         snprintf(evt_path, MAXPATHLEN, "%s/%s", tracing_events_path, sys_name);
 443         evt_dir = opendir(evt_path);
 444         if (!evt_dir) {
 445                 tracepoint_error(error, errno, sys_name, evt_name);
 446                 return -1;
 447         }
 448
 449         while (!ret && (evt_ent = readdir(evt_dir))) {
 450                 if (!strcmp(evt_ent->d_name, ".")
 451                     || !strcmp(evt_ent->d_name, "..")
 452                     || !strcmp(evt_ent->d_name, "enable")
 453                     || !strcmp(evt_ent->d_name, "filter"))
 454                         continue;
 455
 456                 if (!strglobmatch(evt_ent->d_name, evt_name))
 457                         continue;
 458
 459                 ret = add_tracepoint(list, idx, sys_name, evt_ent->d_name, error);
 460         }
 461
 462         closedir(evt_dir);
 463         return ret;
 464 }
 465
 466 static int add_tracepoint_event(struct list_head *list, int *idx,
 467                                 char *sys_name, char *evt_name,
 468                                 struct parse_events_error *error)
 469 {
 470         return strpbrk(evt_name, "*?") ?
 471                add_tracepoint_multi_event(list, idx, sys_name, evt_name, error) :
 472                add_tracepoint(list, idx, sys_name, evt_name, error);
 473 }
 474
 475 static int add_tracepoint_multi_sys(struct list_head *list, int *idx,
 476                                     char *sys_name, char *evt_name,
 477                                     struct parse_events_error *error)
 478 {
 479         struct dirent *events_ent;
 480         DIR *events_dir;
 481         int ret = 0;
 482
 483         events_dir = opendir(tracing_events_path);
 484         if (!events_dir) {
 485                 tracepoint_error(error, errno, sys_name, evt_name);
 486                 return -1;
 487         }
 488
 489         while (!ret && (events_ent = readdir(events_dir))) {
 490                 if (!strcmp(events_ent->d_name, ".")
 491                     || !strcmp(events_ent->d_name, "..")
 492                     || !strcmp(events_ent->d_name, "enable")
 493                     || !strcmp(events_ent->d_name, "header_event")
 494                     || !strcmp(events_ent->d_name, "header_page"))
 495                         continue;
 496
 497                 if (!strglobmatch(events_ent->d_name, sys_name))
 498                         continue;
 499
 500                 ret = add_tracepoint_event(list, idx, events_ent->d_name,
 501                                            evt_name, error);
 502         }
 503
 504         closedir(events_dir);
 505         return ret;
 506 }
 507
 508 int parse_events_add_tracepoint(struct list_head *list, int *idx,
 509                                 char *sys, char *event,
 510                                 struct parse_events_error *error)
 511 {
 512         if (strpbrk(sys, "*?"))
 513                 return add_tracepoint_multi_sys(list, idx, sys, event, error);
 514         else
 515                 return add_tracepoint_event(list, idx, sys, event, error);
 516 }
 517
 518 static int
 519 parse_breakpoint_type(const char *type, struct perf_event_attr *attr)
 520 {
 521         int i;
 522
 523         for (i = 0; i < 3; i++) {
 524                 if (!type || !type[i])
 525                         break;
 526
 527 #define CHECK_SET_TYPE(bit)             \
 528 do {                                    \
 529         if (attr->bp_type & bit)        \
 530                 return -EINVAL;         \
 531         else                            \
 532                 attr->bp_type |= bit;   \
 533 } while (0)
 534
 535                 switch (type[i]) {
 536                 case 'r':
 537                         CHECK_SET_TYPE(HW_BREAKPOINT_R);
 538                         break;
 539                 case 'w':
 540                         CHECK_SET_TYPE(HW_BREAKPOINT_W);
 541                         break;
 542                 case 'x':
 543                         CHECK_SET_TYPE(HW_BREAKPOINT_X);
 544                         break;
 545                 default:
 546                         return -EINVAL;
 547                 }
 548         }
 549
 550 #undef CHECK_SET_TYPE
 551
 552         if (!attr->bp_type) /* Default */
 553                 attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W;
 554
 555         return 0;
 556 }
 557
 558 int parse_events_add_breakpoint(struct list_head *list, int *idx,
 559                                 void *ptr, char *type, u64 len)
 560 {
 561         struct perf_event_attr attr;
 562
 563         memset(&attr, 0, sizeof(attr));
 564         attr.bp_addr = (unsigned long) ptr;
 565
 566         if (parse_breakpoint_type(type, &attr))
 567                 return -EINVAL;
 568
 569         /* Provide some defaults if len is not specified */
 570         if (!len) {
 571                 if (attr.bp_type == HW_BREAKPOINT_X)
 572                         len = sizeof(long);
 573                 else
 574                         len = HW_BREAKPOINT_LEN_4;
 575         }
 576
 577         attr.bp_len = len;
 578
 579         attr.type = PERF_TYPE_BREAKPOINT;
 580         attr.sample_period = 1;
 581
 582         return add_event(list, idx, &attr, NULL, NULL);
 583 }
 584
 585 static int check_type_val(struct parse_events_term *term,
 586                           struct parse_events_error *err,
 587                           int type)
 588 {
 589         if (type == term->type_val)
 590                 return 0;
 591
 592         if (err) {
 593                 err->idx = term->err_val;
 594                 if (type == PARSE_EVENTS__TERM_TYPE_NUM)
 595                         err->str = strdup("expected numeric value");
 596                 else
 597                         err->str = strdup("expected string value");
 598         }
 599         return -EINVAL;
 600 }
 601
 602 static int config_term(struct perf_event_attr *attr,
 603                        struct parse_events_term *term,
 604                        struct parse_events_error *err)
 605 {
 606 #define CHECK_TYPE_VAL(type)                                               \
 607 do {                                                                       \
 608         if (check_type_val(term, err, PARSE_EVENTS__TERM_TYPE_ ## type)) \
 609                 return -EINVAL;                                            \
 610 } while (0)
 611
 612         switch (term->type_term) {
 613         case PARSE_EVENTS__TERM_TYPE_USER:
 614                 /*
 615                  * Always succeed for sysfs terms, as we dont know
 616                  * at this point what type they need to have.
 617                  */
 618                 return 0;
 619         case PARSE_EVENTS__TERM_TYPE_CONFIG:
 620                 CHECK_TYPE_VAL(NUM);
 621                 attr->config = term->val.num;
 622                 break;
 623         case PARSE_EVENTS__TERM_TYPE_CONFIG1:
 624                 CHECK_TYPE_VAL(NUM);
 625                 attr->config1 = term->val.num;
 626                 break;
 627         case PARSE_EVENTS__TERM_TYPE_CONFIG2:
 628                 CHECK_TYPE_VAL(NUM);
 629                 attr->config2 = term->val.num;
 630                 break;
 631         case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
 632                 CHECK_TYPE_VAL(NUM);
 633                 break;
 634         case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ:
 635                 CHECK_TYPE_VAL(NUM);
 636                 break;
 637         case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
 638                 /*
 639                  * TODO uncomment when the field is available
 640                  * attr->branch_sample_type = term->val.num;
 641                  */
 642                 break;
 643         case PARSE_EVENTS__TERM_TYPE_TIME:
 644                 CHECK_TYPE_VAL(NUM);
 645                 if (term->val.num > 1) {
 646                         err->str = strdup("expected 0 or 1");
 647                         err->idx = term->err_val;
 648                         return -EINVAL;
 649                 }
 650                 break;
 651         case PARSE_EVENTS__TERM_TYPE_CALLGRAPH:
 652                 CHECK_TYPE_VAL(STR);
 653                 break;
 654         case PARSE_EVENTS__TERM_TYPE_STACKSIZE:
 655                 CHECK_TYPE_VAL(NUM);
 656                 break;
 657         case PARSE_EVENTS__TERM_TYPE_NAME:
 658                 CHECK_TYPE_VAL(STR);
 659                 break;
 660         default:
 661                 return -EINVAL;
 662         }
 663
 664         return 0;
 665 #undef CHECK_TYPE_VAL
 666 }
 667
 668 static int config_attr(struct perf_event_attr *attr,
 669                        struct list_head *head,
 670                        struct parse_events_error *err)
 671 {
 672         struct parse_events_term *term;
 673
 674         list_for_each_entry(term, head, list)
 675                 if (config_term(attr, term, err))
 676                         return -EINVAL;
 677
 678         return 0;
 679 }
 680
 681 static int get_config_terms(struct list_head *head_config,
 682                             struct list_head *head_terms __maybe_unused)
 683 {
 684 #define ADD_CONFIG_TERM(__type, __name, __val)                  \
 685 do {                                                            \
 686         struct perf_evsel_config_term *__t;                     \
 687                                                                 \
 688         __t = zalloc(sizeof(*__t));                             \
 689         if (!__t)                                               \
 690                 return -ENOMEM;                                 \
 691                                                                 \
 692         INIT_LIST_HEAD(&__t->list);                             \
 693         __t->type       = PERF_EVSEL__CONFIG_TERM_ ## __type;   \
 694         __t->val.__name = __val;                                \
 695         list_add_tail(&__t->list, head_terms);                  \
 696 } while (0)
 697
 698         struct parse_events_term *term;
 699
 700         list_for_each_entry(term, head_config, list) {
 701                 switch (term->type_term) {
 702                 case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
 703                         ADD_CONFIG_TERM(PERIOD, period, term->val.num);
 704                         break;
 705                 case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ:
 706                         ADD_CONFIG_TERM(FREQ, freq, term->val.num);
 707                         break;
 708                 case PARSE_EVENTS__TERM_TYPE_TIME:
 709                         ADD_CONFIG_TERM(TIME, time, term->val.num);
 710                         break;
 711                 case PARSE_EVENTS__TERM_TYPE_CALLGRAPH:
 712                         ADD_CONFIG_TERM(CALLGRAPH, callgraph, term->val.str);
 713                         break;
 714                 case PARSE_EVENTS__TERM_TYPE_STACKSIZE:
 715                         ADD_CONFIG_TERM(STACK_USER, stack_user, term->val.num);
 716                         break;
 717                 default:
 718                         break;
 719                 }
 720         }
 721 #undef ADD_EVSEL_CONFIG
 722         return 0;
 723 }
 724
 725 int parse_events_add_numeric(struct parse_events_evlist *data,
 726                              struct list_head *list,
 727                              u32 type, u64 config,
 728                              struct list_head *head_config)
 729 {
 730         struct perf_event_attr attr;
 731         LIST_HEAD(config_terms);
 732
 733         memset(&attr, 0, sizeof(attr));
 734         attr.type = type;
 735         attr.config = config;
 736
 737         if (head_config) {
 738                 if (config_attr(&attr, head_config, data->error))
 739                         return -EINVAL;
 740
 741                 if (get_config_terms(head_config, &config_terms))
 742                         return -ENOMEM;
 743         }
 744
 745         return add_event(list, &data->idx, &attr, NULL, &config_terms);
 746 }
 747
 748 static int parse_events__is_name_term(struct parse_events_term *term)
 749 {
 750         return term->type_term == PARSE_EVENTS__TERM_TYPE_NAME;
 751 }
 752
 753 static char *pmu_event_name(struct list_head *head_terms)
 754 {
 755         struct parse_events_term *term;
 756
 757         list_for_each_entry(term, head_terms, list)
 758                 if (parse_events__is_name_term(term))
 759                         return term->val.str;
 760
 761         return NULL;
 762 }
 763
 764 int parse_events_add_pmu(struct parse_events_evlist *data,
 765                          struct list_head *list, char *name,
 766                          struct list_head *head_config)
 767 {
 768         struct perf_event_attr attr;
 769         struct perf_pmu_info info;
 770         struct perf_pmu *pmu;
 771         struct perf_evsel *evsel;
 772         LIST_HEAD(config_terms);
 773
 774         pmu = perf_pmu__find(name);
 775         if (!pmu)
 776                 return -EINVAL;
 777
 778         if (pmu->default_config) {
 779                 memcpy(&attr, pmu->default_config,
 780                        sizeof(struct perf_event_attr));
 781         } else {
 782                 memset(&attr, 0, sizeof(attr));
 783         }
 784
 785         if (!head_config) {
 786                 attr.type = pmu->type;
 787                 evsel = __add_event(list, &data->idx, &attr, NULL, pmu->cpus, NULL);
 788                 return evsel ? 0 : -ENOMEM;
 789         }
 790
 791         if (perf_pmu__check_alias(pmu, head_config, &info))
 792                 return -EINVAL;
 793
 794         /*
 795          * Configure hardcoded terms first, no need to check
 796          * return value when called with fail == 0 ;)
 797          */
 798         if (config_attr(&attr, head_config, data->error))
 799                 return -EINVAL;
 800
 801         if (get_config_terms(head_config, &config_terms))
 802                 return -ENOMEM;
 803
 804         if (perf_pmu__config(pmu, &attr, head_config, data->error))
 805                 return -EINVAL;
 806
 807         evsel = __add_event(list, &data->idx, &attr,
 808                             pmu_event_name(head_config), pmu->cpus,
 809                             &config_terms);
 810         if (evsel) {
 811                 evsel->unit = info.unit;
 812                 evsel->scale = info.scale;
 813                 evsel->per_pkg = info.per_pkg;
 814                 evsel->snapshot = info.snapshot;
 815         }
 816
 817         return evsel ? 0 : -ENOMEM;
 818 }
 819
 820 int parse_events__modifier_group(struct list_head *list,
 821                                  char *event_mod)
 822 {
 823         return parse_events__modifier_event(list, event_mod, true);
 824 }
 825
 826 void parse_events__set_leader(char *name, struct list_head *list)
 827 {
 828         struct perf_evsel *leader;
 829
 830         __perf_evlist__set_leader(list);
 831         leader = list_entry(list->next, struct perf_evsel, node);
 832         leader->group_name = name ? strdup(name) : NULL;
 833 }
 834
 835 /* list_event is assumed to point to malloc'ed memory */
 836 void parse_events_update_lists(struct list_head *list_event,
 837                                struct list_head *list_all)
 838 {
 839         /*
 840          * Called for single event definition. Update the
 841          * 'all event' list, and reinit the 'single event'
 842          * list, for next event definition.
 843          */
 844         list_splice_tail(list_event, list_all);
 845         free(list_event);
 846 }
 847
 848 struct event_modifier {
 849         int eu;
 850         int ek;
 851         int eh;
 852         int eH;
 853         int eG;
 854         int eI;
 855         int precise;
 856         int exclude_GH;
 857         int sample_read;
 858         int pinned;
 859 };
 860
 861 static int get_event_modifier(struct event_modifier *mod, char *str,
 862                                struct perf_evsel *evsel)
 863 {
 864         int eu = evsel ? evsel->attr.exclude_user : 0;
 865         int ek = evsel ? evsel->attr.exclude_kernel : 0;
 866         int eh = evsel ? evsel->attr.exclude_hv : 0;
 867         int eH = evsel ? evsel->attr.exclude_host : 0;
 868         int eG = evsel ? evsel->attr.exclude_guest : 0;
 869         int eI = evsel ? evsel->attr.exclude_idle : 0;
 870         int precise = evsel ? evsel->attr.precise_ip : 0;
 871         int sample_read = 0;
 872         int pinned = evsel ? evsel->attr.pinned : 0;
 873
 874         int exclude = eu | ek | eh;
 875         int exclude_GH = evsel ? evsel->exclude_GH : 0;
 876
 877         memset(mod, 0, sizeof(*mod));
 878
 879         while (*str) {
 880                 if (*str == 'u') {
 881                         if (!exclude)
 882                                 exclude = eu = ek = eh = 1;
 883                         eu = 0;
 884                 } else if (*str == 'k') {
 885                         if (!exclude)
 886                                 exclude = eu = ek = eh = 1;
 887                         ek = 0;
 888                 } else if (*str == 'h') {
 889                         if (!exclude)
 890                                 exclude = eu = ek = eh = 1;
 891                         eh = 0;
 892                 } else if (*str == 'G') {
 893                         if (!exclude_GH)
 894                                 exclude_GH = eG = eH = 1;
 895                         eG = 0;
 896                 } else if (*str == 'H') {
 897                         if (!exclude_GH)
 898                                 exclude_GH = eG = eH = 1;
 899                         eH = 0;
 900                 } else if (*str == 'I') {
 901                         eI = 1;
 902                 } else if (*str == 'p') {
 903                         precise++;
 904                         /* use of precise requires exclude_guest */
 905                         if (!exclude_GH)
 906                                 eG = 1;
 907                 } else if (*str == 'S') {
 908                         sample_read = 1;
 909                 } else if (*str == 'D') {
 910                         pinned = 1;
 911                 } else
 912                         break;
 913
 914                 ++str;
 915         }
 916
 917         /*
 918          * precise ip:
 919          *
 920          *  0 - SAMPLE_IP can have arbitrary skid
 921          *  1 - SAMPLE_IP must have constant skid
 922          *  2 - SAMPLE_IP requested to have 0 skid
 923          *  3 - SAMPLE_IP must have 0 skid
 924          *
 925          *  See also PERF_RECORD_MISC_EXACT_IP
 926          */
 927         if (precise > 3)
 928                 return -EINVAL;
 929
 930         mod->eu = eu;
 931         mod->ek = ek;
 932         mod->eh = eh;
 933         mod->eH = eH;
 934         mod->eG = eG;
 935         mod->eI = eI;
 936         mod->precise = precise;
 937         mod->exclude_GH = exclude_GH;
 938         mod->sample_read = sample_read;
 939         mod->pinned = pinned;
 940
 941         return 0;
 942 }
 943
 944 /*
 945  * Basic modifier sanity check to validate it contains only one
 946  * instance of any modifier (apart from 'p') present.
 947  */
 948 static int check_modifier(char *str)
 949 {
 950         char *p = str;
 951
 952         /* The sizeof includes 0 byte as well. */
 953         if (strlen(str) > (sizeof("ukhGHpppSDI") - 1))
 954                 return -1;
 955
 956         while (*p) {
 957                 if (*p != 'p' && strchr(p + 1, *p))
 958                         return -1;
 959                 p++;
 960         }
 961
 962         return 0;
 963 }
 964
 965 int parse_events__modifier_event(struct list_head *list, char *str, bool add)
 966 {
 967         struct perf_evsel *evsel;
 968         struct event_modifier mod;
 969
 970         if (str == NULL)
 971                 return 0;
 972
 973         if (check_modifier(str))
 974                 return -EINVAL;
 975
 976         if (!add && get_event_modifier(&mod, str, NULL))
 977                 return -EINVAL;
 978
 979         __evlist__for_each(list, evsel) {
 980                 if (add && get_event_modifier(&mod, str, evsel))
 981                         return -EINVAL;
 982
 983                 evsel->attr.exclude_user   = mod.eu;
 984                 evsel->attr.exclude_kernel = mod.ek;
 985                 evsel->attr.exclude_hv     = mod.eh;
 986                 evsel->attr.precise_ip     = mod.precise;
 987                 evsel->attr.exclude_host   = mod.eH;
 988                 evsel->attr.exclude_guest  = mod.eG;
 989                 evsel->attr.exclude_idle   = mod.eI;
 990                 evsel->exclude_GH          = mod.exclude_GH;
 991                 evsel->sample_read         = mod.sample_read;
 992
 993                 if (perf_evsel__is_group_leader(evsel))
 994                         evsel->attr.pinned = mod.pinned;
 995         }
 996
 997         return 0;
 998 }
 999
1000 int parse_events_name(struct list_head *list, char *name)
1001 {
1002         struct perf_evsel *evsel;
1003
1004         __evlist__for_each(list, evsel) {
1005                 if (!evsel->name)
1006                         evsel->name = strdup(name);
1007         }
1008
1009         return 0;
1010 }
1011
1012 static int
1013 comp_pmu(const void *p1, const void *p2)
1014 {
1015         struct perf_pmu_event_symbol *pmu1 = (struct perf_pmu_event_symbol *) p1;
1016         struct perf_pmu_event_symbol *pmu2 = (struct perf_pmu_event_symbol *) p2;
1017
1018         return strcmp(pmu1->symbol, pmu2->symbol);
1019 }
1020
1021 static void perf_pmu__parse_cleanup(void)
1022 {
1023         if (perf_pmu_events_list_num > 0) {
1024                 struct perf_pmu_event_symbol *p;
1025                 int i;
1026
1027                 for (i = 0; i < perf_pmu_events_list_num; i++) {
1028                         p = perf_pmu_events_list + i;
1029                         free(p->symbol);
1030                 }
1031                 free(perf_pmu_events_list);
1032                 perf_pmu_events_list = NULL;
1033                 perf_pmu_events_list_num = 0;
1034         }
1035 }
1036
1037 #define SET_SYMBOL(str, stype)          \
1038 do {                                    \
1039         p->symbol = str;                \
1040         if (!p->symbol)                 \
1041                 goto err;               \
1042         p->type = stype;                \
1043 } while (0)
1044
1045 /*
1046  * Read the pmu events list from sysfs
1047  * Save it into perf_pmu_events_list
1048  */
1049 static void perf_pmu__parse_init(void)
1050 {
1051
1052         struct perf_pmu *pmu = NULL;
1053         struct perf_pmu_alias *alias;
1054         int len = 0;
1055
1056         pmu = perf_pmu__find("cpu");
1057         if ((pmu == NULL) || list_empty(&pmu->aliases)) {
1058                 perf_pmu_events_list_num = -1;
1059                 return;
1060         }
1061         list_for_each_entry(alias, &pmu->aliases, list) {
1062                 if (strchr(alias->name, '-'))
1063                         len++;
1064                 len++;
1065         }
1066         perf_pmu_events_list = malloc(sizeof(struct perf_pmu_event_symbol) * len);
1067         if (!perf_pmu_events_list)
1068                 return;
1069         perf_pmu_events_list_num = len;
1070
1071         len = 0;
1072         list_for_each_entry(alias, &pmu->aliases, list) {
1073                 struct perf_pmu_event_symbol *p = perf_pmu_events_list + len;
1074                 char *tmp = strchr(alias->name, '-');
1075
1076                 if (tmp != NULL) {
1077                         SET_SYMBOL(strndup(alias->name, tmp - alias->name),
1078                                         PMU_EVENT_SYMBOL_PREFIX);
1079                         p++;
1080                         SET_SYMBOL(strdup(++tmp), PMU_EVENT_SYMBOL_SUFFIX);
1081                         len += 2;
1082                 } else {
1083                         SET_SYMBOL(strdup(alias->name), PMU_EVENT_SYMBOL);
1084                         len++;
1085                 }
1086         }
1087         qsort(perf_pmu_events_list, len,
1088                 sizeof(struct perf_pmu_event_symbol), comp_pmu);
1089
1090         return;
1091 err:
1092         perf_pmu__parse_cleanup();
1093 }
1094
1095 enum perf_pmu_event_symbol_type
1096 perf_pmu__parse_check(const char *name)
1097 {
1098         struct perf_pmu_event_symbol p, *r;
1099
1100         /* scan kernel pmu events from sysfs if needed */
1101         if (perf_pmu_events_list_num == 0)
1102                 perf_pmu__parse_init();
1103         /*
1104          * name "cpu" could be prefix of cpu-cycles or cpu// events.
1105          * cpu-cycles has been handled by hardcode.
1106          * So it must be cpu// events, not kernel pmu event.
1107          */
1108         if ((perf_pmu_events_list_num <= 0) || !strcmp(name, "cpu"))
1109                 return PMU_EVENT_SYMBOL_ERR;
1110
1111         p.symbol = strdup(name);
1112         r = bsearch(&p, perf_pmu_events_list,
1113                         (size_t) perf_pmu_events_list_num,
1114                         sizeof(struct perf_pmu_event_symbol), comp_pmu);
1115         free(p.symbol);
1116         return r ? r->type : PMU_EVENT_SYMBOL_ERR;
1117 }
1118
1119 static int parse_events__scanner(const char *str, void *data, int start_token)
1120 {
1121         YY_BUFFER_STATE buffer;
1122         void *scanner;
1123         int ret;
1124
1125         ret = parse_events_lex_init_extra(start_token, &scanner);
1126         if (ret)
1127                 return ret;
1128
1129         buffer = parse_events__scan_string(str, scanner);
1130
1131 #ifdef PARSER_DEBUG
1132         parse_events_debug = 1;
1133 #endif
1134         ret = parse_events_parse(data, scanner);
1135
1136         parse_events__flush_buffer(buffer, scanner);
1137         parse_events__delete_buffer(buffer, scanner);
1138         parse_events_lex_destroy(scanner);
1139         return ret;
1140 }
1141
1142 /*
1143  * parse event config string, return a list of event terms.
1144  */
1145 int parse_events_terms(struct list_head *terms, const char *str)
1146 {
1147         struct parse_events_terms data = {
1148                 .terms = NULL,
1149         };
1150         int ret;
1151
1152         ret = parse_events__scanner(str, &data, PE_START_TERMS);
1153         if (!ret) {
1154                 list_splice(data.terms, terms);
1155                 zfree(&data.terms);
1156                 return 0;
1157         }
1158
1159         if (data.terms)
1160                 parse_events__free_terms(data.terms);
1161         return ret;
1162 }
1163
1164 int parse_events(struct perf_evlist *evlist, const char *str,
1165                  struct parse_events_error *err)
1166 {
1167         struct parse_events_evlist data = {
1168                 .list  = LIST_HEAD_INIT(data.list),
1169                 .idx   = evlist->nr_entries,
1170                 .error = err,
1171         };
1172         int ret;
1173
1174         ret = parse_events__scanner(str, &data, PE_START_EVENTS);
1175         perf_pmu__parse_cleanup();
1176         if (!ret) {
1177                 struct perf_evsel *last;
1178
1179                 perf_evlist__splice_list_tail(evlist, &data.list);
1180                 evlist->nr_groups += data.nr_groups;
1181                 last = perf_evlist__last(evlist);
1182                 last->cmdline_group_boundary = true;
1183
1184                 return 0;
1185         }
1186
1187         /*
1188          * There are 2 users - builtin-record and builtin-test objects.
1189          * Both call perf_evlist__delete in case of error, so we dont
1190          * need to bother.
1191          */
1192         return ret;
1193 }
1194
1195 #define MAX_WIDTH 1000
1196 static int get_term_width(void)
1197 {
1198         struct winsize ws;
1199
1200         get_term_dimensions(&ws);
1201         return ws.ws_col > MAX_WIDTH ? MAX_WIDTH : ws.ws_col;
1202 }
1203
1204 static void parse_events_print_error(struct parse_events_error *err,
1205                                      const char *event)
1206 {
1207         const char *str = "invalid or unsupported event: ";
1208         char _buf[MAX_WIDTH];
1209         char *buf = (char *) event;
1210         int idx = 0;
1211
1212         if (err->str) {
1213                 /* -2 for extra '' in the final fprintf */
1214                 int width       = get_term_width() - 2;
1215                 int len_event   = strlen(event);
1216                 int len_str, max_len, cut = 0;
1217
1218                 /*
1219                  * Maximum error index indent, we will cut
1220                  * the event string if it's bigger.
1221                  */
1222                 int max_err_idx = 13;
1223
1224                 /*
1225                  * Let's be specific with the message when
1226                  * we have the precise error.
1227                  */
1228                 str     = "event syntax error: ";
1229                 len_str = strlen(str);
1230                 max_len = width - len_str;
1231
1232                 buf = _buf;
1233
1234                 /* We're cutting from the beggining. */
1235                 if (err->idx > max_err_idx)
1236                         cut = err->idx - max_err_idx;
1237
1238                 strncpy(buf, event + cut, max_len);
1239
1240                 /* Mark cut parts with '..' on both sides. */
1241                 if (cut)
1242                         buf[0] = buf[1] = '.';
1243
1244                 if ((len_event - cut) > max_len) {
1245                         buf[max_len - 1] = buf[max_len - 2] = '.';
1246                         buf[max_len] = 0;
1247                 }
1248
1249                 idx = len_str + err->idx - cut;
1250         }
1251
1252         fprintf(stderr, "%s'%s'\n", str, buf);
1253         if (idx) {
1254                 fprintf(stderr, "%*s\\___ %s\n", idx + 1, "", err->str);
1255                 if (err->help)
1256                         fprintf(stderr, "\n%s\n", err->help);
1257                 free(err->str);
1258                 free(err->help);
1259         }
1260
1261         fprintf(stderr, "Run 'perf list' for a list of valid events\n");
1262 }
1263
1264 #undef MAX_WIDTH
1265
1266 int parse_events_option(const struct option *opt, const char *str,
1267                         int unset __maybe_unused)
1268 {
1269         struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
1270         struct parse_events_error err = { .idx = 0, };
1271         int ret = parse_events(evlist, str, &err);
1272
1273         if (ret)
1274                 parse_events_print_error(&err, str);
1275
1276         return ret;
1277 }
1278
1279 static int
1280 foreach_evsel_in_last_glob(struct perf_evlist *evlist,
1281                            int (*func)(struct perf_evsel *evsel,
1282                                        const void *arg),
1283                            const void *arg)
1284 {
1285         struct perf_evsel *last = NULL;
1286         int err;
1287
1288         if (evlist->nr_entries > 0)
1289                 last = perf_evlist__last(evlist);
1290
1291         do {
1292                 err = (*func)(last, arg);
1293                 if (err)
1294                         return -1;
1295                 if (!last)
1296                         return 0;
1297
1298                 if (last->node.prev == &evlist->entries)
1299                         return 0;
1300                 last = list_entry(last->node.prev, struct perf_evsel, node);
1301         } while (!last->cmdline_group_boundary);
1302
1303         return 0;
1304 }
1305
1306 static int set_filter(struct perf_evsel *evsel, const void *arg)
1307 {
1308         const char *str = arg;
1309
1310         if (evsel == NULL || evsel->attr.type != PERF_TYPE_TRACEPOINT) {
1311                 fprintf(stderr,
1312                         "--filter option should follow a -e tracepoint option\n");
1313                 return -1;
1314         }
1315
1316         if (perf_evsel__append_filter(evsel, "&&", str) < 0) {
1317                 fprintf(stderr,
1318                         "not enough memory to hold filter string\n");
1319                 return -1;
1320         }
1321
1322         return 0;
1323 }
1324
1325 int parse_filter(const struct option *opt, const char *str,
1326                  int unset __maybe_unused)
1327 {
1328         struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
1329
1330         return foreach_evsel_in_last_glob(evlist, set_filter,
1331                                           (const void *)str);
1332 }
1333
1334 static int add_exclude_perf_filter(struct perf_evsel *evsel,
1335                                    const void *arg __maybe_unused)
1336 {
1337         char new_filter[64];
1338
1339         if (evsel == NULL || evsel->attr.type != PERF_TYPE_TRACEPOINT) {
1340                 fprintf(stderr,
1341                         "--exclude-perf option should follow a -e tracepoint option\n");
1342                 return -1;
1343         }
1344
1345         snprintf(new_filter, sizeof(new_filter), "common_pid != %d", getpid());
1346
1347         if (perf_evsel__append_filter(evsel, "&&", new_filter) < 0) {
1348                 fprintf(stderr,
1349                         "not enough memory to hold filter string\n");
1350                 return -1;
1351         }
1352
1353         return 0;
1354 }
1355
1356 int exclude_perf(const struct option *opt,
1357                  const char *arg __maybe_unused,
1358                  int unset __maybe_unused)
1359 {
1360         struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
1361
1362         return foreach_evsel_in_last_glob(evlist, add_exclude_perf_filter,
1363                                           NULL);
1364 }
1365
1366 static const char * const event_type_descriptors[] = {
1367         "Hardware event",
1368         "Software event",
1369         "Tracepoint event",
1370         "Hardware cache event",
1371         "Raw hardware event descriptor",
1372         "Hardware breakpoint",
1373 };
1374
1375 static int cmp_string(const void *a, const void *b)
1376 {
1377         const char * const *as = a;
1378         const char * const *bs = b;
1379
1380         return strcmp(*as, *bs);
1381 }
1382
1383 /*
1384  * Print the events from <debugfs_mount_point>/tracing/events
1385  */
1386
1387 void print_tracepoint_events(const char *subsys_glob, const char *event_glob,
1388                              bool name_only)
1389 {
1390         DIR *sys_dir, *evt_dir;
1391         struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
1392         char evt_path[MAXPATHLEN];
1393         char dir_path[MAXPATHLEN];
1394         char **evt_list = NULL;
1395         unsigned int evt_i = 0, evt_num = 0;
1396         bool evt_num_known = false;
1397
1398 restart:
1399         sys_dir = opendir(tracing_events_path);
1400         if (!sys_dir)
1401                 return;
1402
1403         if (evt_num_known) {
1404                 evt_list = zalloc(sizeof(char *) * evt_num);
1405                 if (!evt_list)
1406                         goto out_close_sys_dir;
1407         }
1408
1409         for_each_subsystem(sys_dir, sys_dirent, sys_next) {
1410                 if (subsys_glob != NULL &&
1411                     !strglobmatch(sys_dirent.d_name, subsys_glob))
1412                         continue;
1413
1414                 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
1415                          sys_dirent.d_name);
1416                 evt_dir = opendir(dir_path);
1417                 if (!evt_dir)
1418                         continue;
1419
1420                 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) {
1421                         if (event_glob != NULL &&
1422                             !strglobmatch(evt_dirent.d_name, event_glob))
1423                                 continue;
1424
1425                         if (!evt_num_known) {
1426                                 evt_num++;
1427                                 continue;
1428                         }
1429
1430                         snprintf(evt_path, MAXPATHLEN, "%s:%s",
1431                                  sys_dirent.d_name, evt_dirent.d_name);
1432
1433                         evt_list[evt_i] = strdup(evt_path);
1434                         if (evt_list[evt_i] == NULL)
1435                                 goto out_close_evt_dir;
1436                         evt_i++;
1437                 }
1438                 closedir(evt_dir);
1439         }
1440         closedir(sys_dir);
1441
1442         if (!evt_num_known) {
1443                 evt_num_known = true;
1444                 goto restart;
1445         }
1446         qsort(evt_list, evt_num, sizeof(char *), cmp_string);
1447         evt_i = 0;
1448         while (evt_i < evt_num) {
1449                 if (name_only) {
1450                         printf("%s ", evt_list[evt_i++]);
1451                         continue;
1452                 }
1453                 printf("  %-50s [%s]\n", evt_list[evt_i++],
1454                                 event_type_descriptors[PERF_TYPE_TRACEPOINT]);
1455         }
1456         if (evt_num)
1457                 printf("\n");
1458
1459 out_free:
1460         evt_num = evt_i;
1461         for (evt_i = 0; evt_i < evt_num; evt_i++)
1462                 zfree(&evt_list[evt_i]);
1463         zfree(&evt_list);
1464         return;
1465
1466 out_close_evt_dir:
1467         closedir(evt_dir);
1468 out_close_sys_dir:
1469         closedir(sys_dir);
1470
1471         printf("FATAL: not enough memory to print %s\n",
1472                         event_type_descriptors[PERF_TYPE_TRACEPOINT]);
1473         if (evt_list)
1474                 goto out_free;
1475 }
1476
1477 /*
1478  * Check whether event is in <debugfs_mount_point>/tracing/events
1479  */
1480
1481 int is_valid_tracepoint(const char *event_string)
1482 {
1483         DIR *sys_dir, *evt_dir;
1484         struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
1485         char evt_path[MAXPATHLEN];
1486         char dir_path[MAXPATHLEN];
1487
1488         sys_dir = opendir(tracing_events_path);
1489         if (!sys_dir)
1490                 return 0;
1491
1492         for_each_subsystem(sys_dir, sys_dirent, sys_next) {
1493
1494                 snprintf(dir_path, MAXPATHLEN, "%s/%s", tracing_events_path,
1495                          sys_dirent.d_name);
1496                 evt_dir = opendir(dir_path);
1497                 if (!evt_dir)
1498                         continue;
1499
1500                 for_each_event(sys_dirent, evt_dir, evt_dirent, evt_next) {
1501                         snprintf(evt_path, MAXPATHLEN, "%s:%s",
1502                                  sys_dirent.d_name, evt_dirent.d_name);
1503                         if (!strcmp(evt_path, event_string)) {
1504                                 closedir(evt_dir);
1505                                 closedir(sys_dir);
1506                                 return 1;
1507                         }
1508                 }
1509                 closedir(evt_dir);
1510         }
1511         closedir(sys_dir);
1512         return 0;
1513 }
1514
1515 static bool is_event_supported(u8 type, unsigned config)
1516 {
1517         bool ret = true;
1518         int open_return;
1519         struct perf_evsel *evsel;
1520         struct perf_event_attr attr = {
1521                 .type = type,
1522                 .config = config,
1523                 .disabled = 1,
1524         };
1525         struct {
1526                 struct thread_map map;
1527                 int threads[1];
1528         } tmap = {
1529                 .map.nr  = 1,
1530                 .threads = { 0 },
1531         };
1532
1533         evsel = perf_evsel__new(&attr);
1534         if (evsel) {
1535                 open_return = perf_evsel__open(evsel, NULL, &tmap.map);
1536                 ret = open_return >= 0;
1537
1538                 if (open_return == -EACCES) {
1539                         /*
1540                          * This happens if the paranoid value
1541                          * /proc/sys/kernel/perf_event_paranoid is set to 2
1542                          * Re-run with exclude_kernel set; we don't do that
1543                          * by default as some ARM machines do not support it.
1544                          *
1545                          */
1546                         evsel->attr.exclude_kernel = 1;
1547                         ret = perf_evsel__open(evsel, NULL, &tmap.map) >= 0;
1548                 }
1549                 perf_evsel__delete(evsel);
1550         }
1551
1552         return ret;
1553 }
1554
1555 int print_hwcache_events(const char *event_glob, bool name_only)
1556 {
1557         unsigned int type, op, i, evt_i = 0, evt_num = 0;
1558         char name[64];
1559         char **evt_list = NULL;
1560         bool evt_num_known = false;
1561
1562 restart:
1563         if (evt_num_known) {
1564                 evt_list = zalloc(sizeof(char *) * evt_num);
1565                 if (!evt_list)
1566                         goto out_enomem;
1567         }
1568
1569         for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) {
1570                 for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) {
1571                         /* skip invalid cache type */
1572                         if (!perf_evsel__is_cache_op_valid(type, op))
1573                                 continue;
1574
1575                         for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
1576                                 __perf_evsel__hw_cache_type_op_res_name(type, op, i,
1577                                                                         name, sizeof(name));
1578                                 if (event_glob != NULL && !strglobmatch(name, event_glob))
1579                                         continue;
1580
1581                                 if (!is_event_supported(PERF_TYPE_HW_CACHE,
1582                                                         type | (op << 8) | (i << 16)))
1583                                         continue;
1584
1585                                 if (!evt_num_known) {
1586                                         evt_num++;
1587                                         continue;
1588                                 }
1589
1590                                 evt_list[evt_i] = strdup(name);
1591                                 if (evt_list[evt_i] == NULL)
1592                                         goto out_enomem;
1593                                 evt_i++;
1594                         }
1595                 }
1596         }
1597
1598         if (!evt_num_known) {
1599                 evt_num_known = true;
1600                 goto restart;
1601         }
1602         qsort(evt_list, evt_num, sizeof(char *), cmp_string);
1603         evt_i = 0;
1604         while (evt_i < evt_num) {
1605                 if (name_only) {
1606                         printf("%s ", evt_list[evt_i++]);
1607                         continue;
1608                 }
1609                 printf("  %-50s [%s]\n", evt_list[evt_i++],
1610                                 event_type_descriptors[PERF_TYPE_HW_CACHE]);
1611         }
1612         if (evt_num)
1613                 printf("\n");
1614
1615 out_free:
1616         evt_num = evt_i;
1617         for (evt_i = 0; evt_i < evt_num; evt_i++)
1618                 zfree(&evt_list[evt_i]);
1619         zfree(&evt_list);
1620         return evt_num;
1621
1622 out_enomem:
1623         printf("FATAL: not enough memory to print %s\n", event_type_descriptors[PERF_TYPE_HW_CACHE]);
1624         if (evt_list)
1625                 goto out_free;
1626         return evt_num;
1627 }
1628
1629 void print_symbol_events(const char *event_glob, unsigned type,
1630                                 struct event_symbol *syms, unsigned max,
1631                                 bool name_only)
1632 {
1633         unsigned int i, evt_i = 0, evt_num = 0;
1634         char name[MAX_NAME_LEN];
1635         char **evt_list = NULL;
1636         bool evt_num_known = false;
1637
1638 restart:
1639         if (evt_num_known) {
1640                 evt_list = zalloc(sizeof(char *) * evt_num);
1641                 if (!evt_list)
1642                         goto out_enomem;
1643                 syms -= max;
1644         }
1645
1646         for (i = 0; i < max; i++, syms++) {
1647
1648                 if (event_glob != NULL &&
1649                     !(strglobmatch(syms->symbol, event_glob) ||
1650                       (syms->alias && strglobmatch(syms->alias, event_glob))))
1651                         continue;
1652
1653                 if (!is_event_supported(type, i))
1654                         continue;
1655
1656                 if (!evt_num_known) {
1657                         evt_num++;
1658                         continue;
1659                 }
1660
1661                 if (!name_only && strlen(syms->alias))
1662                         snprintf(name, MAX_NAME_LEN, "%s OR %s", syms->symbol, syms->alias);
1663                 else
1664                         strncpy(name, syms->symbol, MAX_NAME_LEN);
1665
1666                 evt_list[evt_i] = strdup(name);
1667                 if (evt_list[evt_i] == NULL)
1668                         goto out_enomem;
1669                 evt_i++;
1670         }
1671
1672         if (!evt_num_known) {
1673                 evt_num_known = true;
1674                 goto restart;
1675         }
1676         qsort(evt_list, evt_num, sizeof(char *), cmp_string);
1677         evt_i = 0;
1678         while (evt_i < evt_num) {
1679                 if (name_only) {
1680                         printf("%s ", evt_list[evt_i++]);
1681                         continue;
1682                 }
1683                 printf("  %-50s [%s]\n", evt_list[evt_i++], event_type_descriptors[type]);
1684         }
1685         if (evt_num)
1686                 printf("\n");
1687
1688 out_free:
1689         evt_num = evt_i;
1690         for (evt_i = 0; evt_i < evt_num; evt_i++)
1691                 zfree(&evt_list[evt_i]);
1692         zfree(&evt_list);
1693         return;
1694
1695 out_enomem:
1696         printf("FATAL: not enough memory to print %s\n", event_type_descriptors[type]);
1697         if (evt_list)
1698                 goto out_free;
1699 }
1700
1701 /*
1702  * Print the help text for the event symbols:
1703  */
1704 void print_events(const char *event_glob, bool name_only)
1705 {
1706         print_symbol_events(event_glob, PERF_TYPE_HARDWARE,
1707                             event_symbols_hw, PERF_COUNT_HW_MAX, name_only);
1708
1709         print_symbol_events(event_glob, PERF_TYPE_SOFTWARE,
1710                             event_symbols_sw, PERF_COUNT_SW_MAX, name_only);
1711
1712         print_hwcache_events(event_glob, name_only);
1713
1714         print_pmu_events(event_glob, name_only);
1715
1716         if (event_glob != NULL)
1717                 return;
1718
1719         if (!name_only) {
1720                 printf("  %-50s [%s]\n",
1721                        "rNNN",
1722                        event_type_descriptors[PERF_TYPE_RAW]);
1723                 printf("  %-50s [%s]\n",
1724                        "cpu/t1=v1[,t2=v2,t3 ...]/modifier",
1725                        event_type_descriptors[PERF_TYPE_RAW]);
1726                 printf("   (see 'man perf-list' on how to encode it)\n");
1727                 printf("\n");
1728
1729                 printf("  %-50s [%s]\n",
1730                        "mem:<addr>[/len][:access]",
1731                         event_type_descriptors[PERF_TYPE_BREAKPOINT]);
1732                 printf("\n");
1733         }
1734
1735         print_tracepoint_events(NULL, NULL, name_only);
1736 }
1737
1738 int parse_events__is_hardcoded_term(struct parse_events_term *term)
1739 {
1740         return term->type_term != PARSE_EVENTS__TERM_TYPE_USER;
1741 }
1742
1743 static int new_term(struct parse_events_term **_term, int type_val,
1744                     int type_term, char *config,
1745                     char *str, u64 num, int err_term, int err_val)
1746 {
1747         struct parse_events_term *term;
1748
1749         term = zalloc(sizeof(*term));
1750         if (!term)
1751                 return -ENOMEM;
1752
1753         INIT_LIST_HEAD(&term->list);
1754         term->type_val  = type_val;
1755         term->type_term = type_term;
1756         term->config = config;
1757         term->err_term = err_term;
1758         term->err_val  = err_val;
1759
1760         switch (type_val) {
1761         case PARSE_EVENTS__TERM_TYPE_NUM:
1762                 term->val.num = num;
1763                 break;
1764         case PARSE_EVENTS__TERM_TYPE_STR:
1765                 term->val.str = str;
1766                 break;
1767         default:
1768                 free(term);
1769                 return -EINVAL;
1770         }
1771
1772         *_term = term;
1773         return 0;
1774 }
1775
1776 int parse_events_term__num(struct parse_events_term **term,
1777                            int type_term, char *config, u64 num,
1778                            void *loc_term_, void *loc_val_)
1779 {
1780         YYLTYPE *loc_term = loc_term_;
1781         YYLTYPE *loc_val = loc_val_;
1782
1783         return new_term(term, PARSE_EVENTS__TERM_TYPE_NUM, type_term,
1784                         config, NULL, num,
1785                         loc_term ? loc_term->first_column : 0,
1786                         loc_val ? loc_val->first_column : 0);
1787 }
1788
1789 int parse_events_term__str(struct parse_events_term **term,
1790                            int type_term, char *config, char *str,
1791                            void *loc_term_, void *loc_val_)
1792 {
1793         YYLTYPE *loc_term = loc_term_;
1794         YYLTYPE *loc_val = loc_val_;
1795
1796         return new_term(term, PARSE_EVENTS__TERM_TYPE_STR, type_term,
1797                         config, str, 0,
1798                         loc_term ? loc_term->first_column : 0,
1799                         loc_val ? loc_val->first_column : 0);
1800 }
1801
1802 int parse_events_term__sym_hw(struct parse_events_term **term,
1803                               char *config, unsigned idx)
1804 {
1805         struct event_symbol *sym;
1806
1807         BUG_ON(idx >= PERF_COUNT_HW_MAX);
1808         sym = &event_symbols_hw[idx];
1809
1810         if (config)
1811                 return new_term(term, PARSE_EVENTS__TERM_TYPE_STR,
1812                                 PARSE_EVENTS__TERM_TYPE_USER, config,
1813                                 (char *) sym->symbol, 0, 0, 0);
1814         else
1815                 return new_term(term, PARSE_EVENTS__TERM_TYPE_STR,
1816                                 PARSE_EVENTS__TERM_TYPE_USER,
1817                                 (char *) "event", (char *) sym->symbol,
1818                                 0, 0, 0);
1819 }
1820
1821 int parse_events_term__clone(struct parse_events_term **new,
1822                              struct parse_events_term *term)
1823 {
1824         return new_term(new, term->type_val, term->type_term, term->config,
1825                         term->val.str, term->val.num,
1826                         term->err_term, term->err_val);
1827 }
1828
1829 void parse_events__free_terms(struct list_head *terms)
1830 {
1831         struct parse_events_term *term, *h;
1832
1833         list_for_each_entry_safe(term, h, terms, list)
1834                 free(term);
1835 }
1836
1837 void parse_events_evlist_error(struct parse_events_evlist *data,
1838                                int idx, const char *str)
1839 {
1840         struct parse_events_error *err = data->error;
1841
1842         if (!err)
1843                 return;
1844         err->idx = idx;
1845         err->str = strdup(str);
1846         WARN_ONCE(!err->str, "WARNING: failed to allocate error string");
1847 }