tools/perf/util/parse-events.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/hw_breakpoint.h>
   3 #include <linux/err.h>
   4 #include <linux/list_sort.h>
   5 #include <linux/zalloc.h>
   6 #include <dirent.h>
   7 #include <errno.h>
   8 #include <sys/ioctl.h>
   9 #include <sys/param.h>
  10 #include "term.h"
  11 #include "evlist.h"
  12 #include "evsel.h"
  13 #include <subcmd/parse-options.h>
  14 #include "parse-events.h"
  15 #include "string2.h"
  16 #include "strlist.h"
  17 #include "bpf-loader.h"
  18 #include "debug.h"
  19 #include <api/fs/tracing_path.h>
  20 #include <perf/cpumap.h>
  21 #include "parse-events-bison.h"
  22 #include "parse-events-flex.h"
  23 #include "pmu.h"
  24 #include "pmus.h"
  25 #include "asm/bug.h"
  26 #include "util/parse-branch-options.h"
  27 #include "util/evsel_config.h"
  28 #include "util/event.h"
  29 #include "util/bpf-filter.h"
  30 #include "util/util.h"
  31 #include "tracepoint.h"
  32
  33 #define MAX_NAME_LEN 100
  34
  35 #ifdef PARSER_DEBUG
  36 extern int parse_events_debug;
  37 #endif
  38 int parse_events_parse(void *parse_state, void *scanner);
  39 static int get_config_terms(struct list_head *head_config,
  40                             struct list_head *head_terms __maybe_unused);
  41
  42 struct event_symbol event_symbols_hw[PERF_COUNT_HW_MAX] = {
  43         [PERF_COUNT_HW_CPU_CYCLES] = {
  44                 .symbol = "cpu-cycles",
  45                 .alias  = "cycles",
  46         },
  47         [PERF_COUNT_HW_INSTRUCTIONS] = {
  48                 .symbol = "instructions",
  49                 .alias  = "",
  50         },
  51         [PERF_COUNT_HW_CACHE_REFERENCES] = {
  52                 .symbol = "cache-references",
  53                 .alias  = "",
  54         },
  55         [PERF_COUNT_HW_CACHE_MISSES] = {
  56                 .symbol = "cache-misses",
  57                 .alias  = "",
  58         },
  59         [PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = {
  60                 .symbol = "branch-instructions",
  61                 .alias  = "branches",
  62         },
  63         [PERF_COUNT_HW_BRANCH_MISSES] = {
  64                 .symbol = "branch-misses",
  65                 .alias  = "",
  66         },
  67         [PERF_COUNT_HW_BUS_CYCLES] = {
  68                 .symbol = "bus-cycles",
  69                 .alias  = "",
  70         },
  71         [PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = {
  72                 .symbol = "stalled-cycles-frontend",
  73                 .alias  = "idle-cycles-frontend",
  74         },
  75         [PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = {
  76                 .symbol = "stalled-cycles-backend",
  77                 .alias  = "idle-cycles-backend",
  78         },
  79         [PERF_COUNT_HW_REF_CPU_CYCLES] = {
  80                 .symbol = "ref-cycles",
  81                 .alias  = "",
  82         },
  83 };
  84
  85 struct event_symbol event_symbols_sw[PERF_COUNT_SW_MAX] = {
  86         [PERF_COUNT_SW_CPU_CLOCK] = {
  87                 .symbol = "cpu-clock",
  88                 .alias  = "",
  89         },
  90         [PERF_COUNT_SW_TASK_CLOCK] = {
  91                 .symbol = "task-clock",
  92                 .alias  = "",
  93         },
  94         [PERF_COUNT_SW_PAGE_FAULTS] = {
  95                 .symbol = "page-faults",
  96                 .alias  = "faults",
  97         },
  98         [PERF_COUNT_SW_CONTEXT_SWITCHES] = {
  99                 .symbol = "context-switches",
 100                 .alias  = "cs",
 101         },
 102         [PERF_COUNT_SW_CPU_MIGRATIONS] = {
 103                 .symbol = "cpu-migrations",
 104                 .alias  = "migrations",
 105         },
 106         [PERF_COUNT_SW_PAGE_FAULTS_MIN] = {
 107                 .symbol = "minor-faults",
 108                 .alias  = "",
 109         },
 110         [PERF_COUNT_SW_PAGE_FAULTS_MAJ] = {
 111                 .symbol = "major-faults",
 112                 .alias  = "",
 113         },
 114         [PERF_COUNT_SW_ALIGNMENT_FAULTS] = {
 115                 .symbol = "alignment-faults",
 116                 .alias  = "",
 117         },
 118         [PERF_COUNT_SW_EMULATION_FAULTS] = {
 119                 .symbol = "emulation-faults",
 120                 .alias  = "",
 121         },
 122         [PERF_COUNT_SW_DUMMY] = {
 123                 .symbol = "dummy",
 124                 .alias  = "",
 125         },
 126         [PERF_COUNT_SW_BPF_OUTPUT] = {
 127                 .symbol = "bpf-output",
 128                 .alias  = "",
 129         },
 130         [PERF_COUNT_SW_CGROUP_SWITCHES] = {
 131                 .symbol = "cgroup-switches",
 132                 .alias  = "",
 133         },
 134 };
 135
 136 const char *event_type(int type)
 137 {
 138         switch (type) {
 139         case PERF_TYPE_HARDWARE:
 140                 return "hardware";
 141
 142         case PERF_TYPE_SOFTWARE:
 143                 return "software";
 144
 145         case PERF_TYPE_TRACEPOINT:
 146                 return "tracepoint";
 147
 148         case PERF_TYPE_HW_CACHE:
 149                 return "hardware-cache";
 150
 151         default:
 152                 break;
 153         }
 154
 155         return "unknown";
 156 }
 157
 158 static char *get_config_str(struct list_head *head_terms, int type_term)
 159 {
 160         struct parse_events_term *term;
 161
 162         if (!head_terms)
 163                 return NULL;
 164
 165         list_for_each_entry(term, head_terms, list)
 166                 if (term->type_term == type_term)
 167                         return term->val.str;
 168
 169         return NULL;
 170 }
 171
 172 static char *get_config_metric_id(struct list_head *head_terms)
 173 {
 174         return get_config_str(head_terms, PARSE_EVENTS__TERM_TYPE_METRIC_ID);
 175 }
 176
 177 static char *get_config_name(struct list_head *head_terms)
 178 {
 179         return get_config_str(head_terms, PARSE_EVENTS__TERM_TYPE_NAME);
 180 }
 181
 182 /**
 183  * fix_raw - For each raw term see if there is an event (aka alias) in pmu that
 184  *           matches the raw's string value. If the string value matches an
 185  *           event then change the term to be an event, if not then change it to
 186  *           be a config term. For example, "read" may be an event of the PMU or
 187  *           a raw hex encoding of 0xead. The fix-up is done late so the PMU of
 188  *           the event can be determined and we don't need to scan all PMUs
 189  *           ahead-of-time.
 190  * @config_terms: the list of terms that may contain a raw term.
 191  * @pmu: the PMU to scan for events from.
 192  */
 193 static void fix_raw(struct list_head *config_terms, struct perf_pmu *pmu)
 194 {
 195         struct parse_events_term *term;
 196
 197         list_for_each_entry(term, config_terms, list) {
 198                 struct perf_pmu_alias *alias;
 199                 bool matched = false;
 200
 201                 if (term->type_term != PARSE_EVENTS__TERM_TYPE_RAW)
 202                         continue;
 203
 204                 list_for_each_entry(alias, &pmu->aliases, list) {
 205                         if (!strcmp(alias->name, term->val.str)) {
 206                                 free(term->config);
 207                                 term->config = term->val.str;
 208                                 term->type_val = PARSE_EVENTS__TERM_TYPE_NUM;
 209                                 term->type_term = PARSE_EVENTS__TERM_TYPE_USER;
 210                                 term->val.num = 1;
 211                                 term->no_value = true;
 212                                 matched = true;
 213                                 break;
 214                         }
 215                 }
 216                 if (!matched) {
 217                         u64 num;
 218
 219                         free(term->config);
 220                         term->config = strdup("config");
 221                         errno = 0;
 222                         num = strtoull(term->val.str + 1, NULL, 16);
 223                         assert(errno == 0);
 224                         free(term->val.str);
 225                         term->type_val = PARSE_EVENTS__TERM_TYPE_NUM;
 226                         term->type_term = PARSE_EVENTS__TERM_TYPE_CONFIG;
 227                         term->val.num = num;
 228                         term->no_value = false;
 229                 }
 230         }
 231 }
 232
 233 static struct evsel *
 234 __add_event(struct list_head *list, int *idx,
 235             struct perf_event_attr *attr,
 236             bool init_attr,
 237             const char *name, const char *metric_id, struct perf_pmu *pmu,
 238             struct list_head *config_terms, bool auto_merge_stats,
 239             const char *cpu_list)
 240 {
 241         struct evsel *evsel;
 242         struct perf_cpu_map *cpus = pmu ? perf_cpu_map__get(pmu->cpus) :
 243                                cpu_list ? perf_cpu_map__new(cpu_list) : NULL;
 244
 245         if (pmu)
 246                 perf_pmu__warn_invalid_formats(pmu);
 247
 248         if (pmu && (attr->type == PERF_TYPE_RAW || attr->type >= PERF_TYPE_MAX)) {
 249                 perf_pmu__warn_invalid_config(pmu, attr->config, name,
 250                                               PERF_PMU_FORMAT_VALUE_CONFIG, "config");
 251                 perf_pmu__warn_invalid_config(pmu, attr->config1, name,
 252                                               PERF_PMU_FORMAT_VALUE_CONFIG1, "config1");
 253                 perf_pmu__warn_invalid_config(pmu, attr->config2, name,
 254                                               PERF_PMU_FORMAT_VALUE_CONFIG2, "config2");
 255                 perf_pmu__warn_invalid_config(pmu, attr->config3, name,
 256                                               PERF_PMU_FORMAT_VALUE_CONFIG3, "config3");
 257         }
 258         if (init_attr)
 259                 event_attr_init(attr);
 260
 261         evsel = evsel__new_idx(attr, *idx);
 262         if (!evsel) {
 263                 perf_cpu_map__put(cpus);
 264                 return NULL;
 265         }
 266
 267         (*idx)++;
 268         evsel->core.cpus = cpus;
 269         evsel->core.own_cpus = perf_cpu_map__get(cpus);
 270         evsel->core.requires_cpu = pmu ? pmu->is_uncore : false;
 271         evsel->core.is_pmu_core = pmu ? pmu->is_core : false;
 272         evsel->auto_merge_stats = auto_merge_stats;
 273         evsel->pmu = pmu;
 274         evsel->pmu_name = pmu && pmu->name ? strdup(pmu->name) : NULL;
 275
 276         if (name)
 277                 evsel->name = strdup(name);
 278
 279         if (metric_id)
 280                 evsel->metric_id = strdup(metric_id);
 281
 282         if (config_terms)
 283                 list_splice_init(config_terms, &evsel->config_terms);
 284
 285         if (list)
 286                 list_add_tail(&evsel->core.node, list);
 287
 288         return evsel;
 289 }
 290
 291 struct evsel *parse_events__add_event(int idx, struct perf_event_attr *attr,
 292                                       const char *name, const char *metric_id,
 293                                       struct perf_pmu *pmu)
 294 {
 295         return __add_event(/*list=*/NULL, &idx, attr, /*init_attr=*/false, name,
 296                            metric_id, pmu, /*config_terms=*/NULL,
 297                            /*auto_merge_stats=*/false, /*cpu_list=*/NULL);
 298 }
 299
 300 static int add_event(struct list_head *list, int *idx,
 301                      struct perf_event_attr *attr, const char *name,
 302                      const char *metric_id, struct list_head *config_terms)
 303 {
 304         return __add_event(list, idx, attr, /*init_attr*/true, name, metric_id,
 305                            /*pmu=*/NULL, config_terms,
 306                            /*auto_merge_stats=*/false, /*cpu_list=*/NULL) ? 0 : -ENOMEM;
 307 }
 308
 309 static int add_event_tool(struct list_head *list, int *idx,
 310                           enum perf_tool_event tool_event)
 311 {
 312         struct evsel *evsel;
 313         struct perf_event_attr attr = {
 314                 .type = PERF_TYPE_SOFTWARE,
 315                 .config = PERF_COUNT_SW_DUMMY,
 316         };
 317
 318         evsel = __add_event(list, idx, &attr, /*init_attr=*/true, /*name=*/NULL,
 319                             /*metric_id=*/NULL, /*pmu=*/NULL,
 320                             /*config_terms=*/NULL, /*auto_merge_stats=*/false,
 321                             /*cpu_list=*/"0");
 322         if (!evsel)
 323                 return -ENOMEM;
 324         evsel->tool_event = tool_event;
 325         if (tool_event == PERF_TOOL_DURATION_TIME
 326             || tool_event == PERF_TOOL_USER_TIME
 327             || tool_event == PERF_TOOL_SYSTEM_TIME) {
 328                 free((char *)evsel->unit);
 329                 evsel->unit = strdup("ns");
 330         }
 331         return 0;
 332 }
 333
 334 /**
 335  * parse_aliases - search names for entries beginning or equalling str ignoring
 336  *                 case. If mutliple entries in names match str then the longest
 337  *                 is chosen.
 338  * @str: The needle to look for.
 339  * @names: The haystack to search.
 340  * @size: The size of the haystack.
 341  * @longest: Out argument giving the length of the matching entry.
 342  */
 343 static int parse_aliases(const char *str, const char *const names[][EVSEL__MAX_ALIASES], int size,
 344                          int *longest)
 345 {
 346         *longest = -1;
 347         for (int i = 0; i < size; i++) {
 348                 for (int j = 0; j < EVSEL__MAX_ALIASES && names[i][j]; j++) {
 349                         int n = strlen(names[i][j]);
 350
 351                         if (n > *longest && !strncasecmp(str, names[i][j], n))
 352                                 *longest = n;
 353                 }
 354                 if (*longest > 0)
 355                         return i;
 356         }
 357
 358         return -1;
 359 }
 360
 361 typedef int config_term_func_t(struct perf_event_attr *attr,
 362                                struct parse_events_term *term,
 363                                struct parse_events_error *err);
 364 static int config_term_common(struct perf_event_attr *attr,
 365                               struct parse_events_term *term,
 366                               struct parse_events_error *err);
 367 static int config_attr(struct perf_event_attr *attr,
 368                        struct list_head *head,
 369                        struct parse_events_error *err,
 370                        config_term_func_t config_term);
 371
 372 /**
 373  * parse_events__decode_legacy_cache - Search name for the legacy cache event
 374  *                                     name composed of 1, 2 or 3 hyphen
 375  *                                     separated sections. The first section is
 376  *                                     the cache type while the others are the
 377  *                                     optional op and optional result. To make
 378  *                                     life hard the names in the table also
 379  *                                     contain hyphens and the longest name
 380  *                                     should always be selected.
 381  */
 382 int parse_events__decode_legacy_cache(const char *name, int extended_pmu_type, __u64 *config)
 383 {
 384         int len, cache_type = -1, cache_op = -1, cache_result = -1;
 385         const char *name_end = &name[strlen(name) + 1];
 386         const char *str = name;
 387
 388         cache_type = parse_aliases(str, evsel__hw_cache, PERF_COUNT_HW_CACHE_MAX, &len);
 389         if (cache_type == -1)
 390                 return -EINVAL;
 391         str += len + 1;
 392
 393         if (str < name_end) {
 394                 cache_op = parse_aliases(str, evsel__hw_cache_op,
 395                                         PERF_COUNT_HW_CACHE_OP_MAX, &len);
 396                 if (cache_op >= 0) {
 397                         if (!evsel__is_cache_op_valid(cache_type, cache_op))
 398                                 return -EINVAL;
 399                         str += len + 1;
 400                 } else {
 401                         cache_result = parse_aliases(str, evsel__hw_cache_result,
 402                                                 PERF_COUNT_HW_CACHE_RESULT_MAX, &len);
 403                         if (cache_result >= 0)
 404                                 str += len + 1;
 405                 }
 406         }
 407         if (str < name_end) {
 408                 if (cache_op < 0) {
 409                         cache_op = parse_aliases(str, evsel__hw_cache_op,
 410                                                 PERF_COUNT_HW_CACHE_OP_MAX, &len);
 411                         if (cache_op >= 0) {
 412                                 if (!evsel__is_cache_op_valid(cache_type, cache_op))
 413                                         return -EINVAL;
 414                         }
 415                 } else if (cache_result < 0) {
 416                         cache_result = parse_aliases(str, evsel__hw_cache_result,
 417                                                 PERF_COUNT_HW_CACHE_RESULT_MAX, &len);
 418                 }
 419         }
 420
 421         /*
 422          * Fall back to reads:
 423          */
 424         if (cache_op == -1)
 425                 cache_op = PERF_COUNT_HW_CACHE_OP_READ;
 426
 427         /*
 428          * Fall back to accesses:
 429          */
 430         if (cache_result == -1)
 431                 cache_result = PERF_COUNT_HW_CACHE_RESULT_ACCESS;
 432
 433         *config = cache_type | (cache_op << 8) | (cache_result << 16);
 434         if (perf_pmus__supports_extended_type())
 435                 *config |= (__u64)extended_pmu_type << PERF_PMU_TYPE_SHIFT;
 436         return 0;
 437 }
 438
 439 /**
 440  * parse_events__filter_pmu - returns false if a wildcard PMU should be
 441  *                            considered, true if it should be filtered.
 442  */
 443 bool parse_events__filter_pmu(const struct parse_events_state *parse_state,
 444                               const struct perf_pmu *pmu)
 445 {
 446         if (parse_state->pmu_filter == NULL)
 447                 return false;
 448
 449         if (pmu->name == NULL)
 450                 return true;
 451
 452         return strcmp(parse_state->pmu_filter, pmu->name) != 0;
 453 }
 454
 455 int parse_events_add_cache(struct list_head *list, int *idx, const char *name,
 456                            struct parse_events_state *parse_state,
 457                            struct list_head *head_config)
 458 {
 459         struct perf_pmu *pmu = NULL;
 460         bool found_supported = false;
 461         const char *config_name = get_config_name(head_config);
 462         const char *metric_id = get_config_metric_id(head_config);
 463
 464         /* Legacy cache events are only supported by core PMUs. */
 465         while ((pmu = perf_pmus__scan_core(pmu)) != NULL) {
 466                 LIST_HEAD(config_terms);
 467                 struct perf_event_attr attr;
 468                 int ret;
 469
 470                 if (parse_events__filter_pmu(parse_state, pmu))
 471                         continue;
 472
 473                 memset(&attr, 0, sizeof(attr));
 474                 attr.type = PERF_TYPE_HW_CACHE;
 475
 476                 ret = parse_events__decode_legacy_cache(name, pmu->type, &attr.config);
 477                 if (ret)
 478                         return ret;
 479
 480                 found_supported = true;
 481
 482                 if (head_config) {
 483                         if (config_attr(&attr, head_config, parse_state->error, config_term_common))
 484                                 return -EINVAL;
 485
 486                         if (get_config_terms(head_config, &config_terms))
 487                                 return -ENOMEM;
 488                 }
 489
 490                 if (__add_event(list, idx, &attr, /*init_attr*/true, config_name ?: name,
 491                                 metric_id, pmu, &config_terms, /*auto_merge_stats=*/false,
 492                                 /*cpu_list=*/NULL) == NULL)
 493                         return -ENOMEM;
 494
 495                 free_config_terms(&config_terms);
 496         }
 497         return found_supported ? 0 : -EINVAL;
 498 }
 499
 500 #ifdef HAVE_LIBTRACEEVENT
 501 static void tracepoint_error(struct parse_events_error *e, int err,
 502                              const char *sys, const char *name)
 503 {
 504         const char *str;
 505         char help[BUFSIZ];
 506
 507         if (!e)
 508                 return;
 509
 510         /*
 511          * We get error directly from syscall errno ( > 0),
 512          * or from encoded pointer's error ( < 0).
 513          */
 514         err = abs(err);
 515
 516         switch (err) {
 517         case EACCES:
 518                 str = "can't access trace events";
 519                 break;
 520         case ENOENT:
 521                 str = "unknown tracepoint";
 522                 break;
 523         default:
 524                 str = "failed to add tracepoint";
 525                 break;
 526         }
 527
 528         tracing_path__strerror_open_tp(err, help, sizeof(help), sys, name);
 529         parse_events_error__handle(e, 0, strdup(str), strdup(help));
 530 }
 531
 532 static int add_tracepoint(struct list_head *list, int *idx,
 533                           const char *sys_name, const char *evt_name,
 534                           struct parse_events_error *err,
 535                           struct list_head *head_config)
 536 {
 537         struct evsel *evsel = evsel__newtp_idx(sys_name, evt_name, (*idx)++);
 538
 539         if (IS_ERR(evsel)) {
 540                 tracepoint_error(err, PTR_ERR(evsel), sys_name, evt_name);
 541                 return PTR_ERR(evsel);
 542         }
 543
 544         if (head_config) {
 545                 LIST_HEAD(config_terms);
 546
 547                 if (get_config_terms(head_config, &config_terms))
 548                         return -ENOMEM;
 549                 list_splice(&config_terms, &evsel->config_terms);
 550         }
 551
 552         list_add_tail(&evsel->core.node, list);
 553         return 0;
 554 }
 555
 556 static int add_tracepoint_multi_event(struct list_head *list, int *idx,
 557                                       const char *sys_name, const char *evt_name,
 558                                       struct parse_events_error *err,
 559                                       struct list_head *head_config)
 560 {
 561         char *evt_path;
 562         struct dirent *evt_ent;
 563         DIR *evt_dir;
 564         int ret = 0, found = 0;
 565
 566         evt_path = get_events_file(sys_name);
 567         if (!evt_path) {
 568                 tracepoint_error(err, errno, sys_name, evt_name);
 569                 return -1;
 570         }
 571         evt_dir = opendir(evt_path);
 572         if (!evt_dir) {
 573                 put_events_file(evt_path);
 574                 tracepoint_error(err, errno, sys_name, evt_name);
 575                 return -1;
 576         }
 577
 578         while (!ret && (evt_ent = readdir(evt_dir))) {
 579                 if (!strcmp(evt_ent->d_name, ".")
 580                     || !strcmp(evt_ent->d_name, "..")
 581                     || !strcmp(evt_ent->d_name, "enable")
 582                     || !strcmp(evt_ent->d_name, "filter"))
 583                         continue;
 584
 585                 if (!strglobmatch(evt_ent->d_name, evt_name))
 586                         continue;
 587
 588                 found++;
 589
 590                 ret = add_tracepoint(list, idx, sys_name, evt_ent->d_name,
 591                                      err, head_config);
 592         }
 593
 594         if (!found) {
 595                 tracepoint_error(err, ENOENT, sys_name, evt_name);
 596                 ret = -1;
 597         }
 598
 599         put_events_file(evt_path);
 600         closedir(evt_dir);
 601         return ret;
 602 }
 603
 604 static int add_tracepoint_event(struct list_head *list, int *idx,
 605                                 const char *sys_name, const char *evt_name,
 606                                 struct parse_events_error *err,
 607                                 struct list_head *head_config)
 608 {
 609         return strpbrk(evt_name, "*?") ?
 610                add_tracepoint_multi_event(list, idx, sys_name, evt_name,
 611                                           err, head_config) :
 612                add_tracepoint(list, idx, sys_name, evt_name,
 613                               err, head_config);
 614 }
 615
 616 static int add_tracepoint_multi_sys(struct list_head *list, int *idx,
 617                                     const char *sys_name, const char *evt_name,
 618                                     struct parse_events_error *err,
 619                                     struct list_head *head_config)
 620 {
 621         struct dirent *events_ent;
 622         DIR *events_dir;
 623         int ret = 0;
 624
 625         events_dir = tracing_events__opendir();
 626         if (!events_dir) {
 627                 tracepoint_error(err, errno, sys_name, evt_name);
 628                 return -1;
 629         }
 630
 631         while (!ret && (events_ent = readdir(events_dir))) {
 632                 if (!strcmp(events_ent->d_name, ".")
 633                     || !strcmp(events_ent->d_name, "..")
 634                     || !strcmp(events_ent->d_name, "enable")
 635                     || !strcmp(events_ent->d_name, "header_event")
 636                     || !strcmp(events_ent->d_name, "header_page"))
 637                         continue;
 638
 639                 if (!strglobmatch(events_ent->d_name, sys_name))
 640                         continue;
 641
 642                 ret = add_tracepoint_event(list, idx, events_ent->d_name,
 643                                            evt_name, err, head_config);
 644         }
 645
 646         closedir(events_dir);
 647         return ret;
 648 }
 649 #endif /* HAVE_LIBTRACEEVENT */
 650
 651 #ifdef HAVE_LIBBPF_SUPPORT
 652 struct __add_bpf_event_param {
 653         struct parse_events_state *parse_state;
 654         struct list_head *list;
 655         struct list_head *head_config;
 656 };
 657
 658 static int add_bpf_event(const char *group, const char *event, int fd, struct bpf_object *obj,
 659                          void *_param)
 660 {
 661         LIST_HEAD(new_evsels);
 662         struct __add_bpf_event_param *param = _param;
 663         struct parse_events_state *parse_state = param->parse_state;
 664         struct list_head *list = param->list;
 665         struct evsel *pos;
 666         int err;
 667         /*
 668          * Check if we should add the event, i.e. if it is a TP but starts with a '!',
 669          * then don't add the tracepoint, this will be used for something else, like
 670          * adding to a BPF_MAP_TYPE_PROG_ARRAY.
 671          *
 672          * See tools/perf/examples/bpf/augmented_raw_syscalls.c
 673          */
 674         if (group[0] == '!')
 675                 return 0;
 676
 677         pr_debug("add bpf event %s:%s and attach bpf program %d\n",
 678                  group, event, fd);
 679
 680         err = parse_events_add_tracepoint(&new_evsels, &parse_state->idx, group,
 681                                           event, parse_state->error,
 682                                           param->head_config);
 683         if (err) {
 684                 struct evsel *evsel, *tmp;
 685
 686                 pr_debug("Failed to add BPF event %s:%s\n",
 687                          group, event);
 688                 list_for_each_entry_safe(evsel, tmp, &new_evsels, core.node) {
 689                         list_del_init(&evsel->core.node);
 690                         evsel__delete(evsel);
 691                 }
 692                 return err;
 693         }
 694         pr_debug("adding %s:%s\n", group, event);
 695
 696         list_for_each_entry(pos, &new_evsels, core.node) {
 697                 pr_debug("adding %s:%s to %p\n",
 698                          group, event, pos);
 699                 pos->bpf_fd = fd;
 700                 pos->bpf_obj = obj;
 701         }
 702         list_splice(&new_evsels, list);
 703         return 0;
 704 }
 705
 706 int parse_events_load_bpf_obj(struct parse_events_state *parse_state,
 707                               struct list_head *list,
 708                               struct bpf_object *obj,
 709                               struct list_head *head_config)
 710 {
 711         int err;
 712         char errbuf[BUFSIZ];
 713         struct __add_bpf_event_param param = {parse_state, list, head_config};
 714         static bool registered_unprobe_atexit = false;
 715
 716         if (IS_ERR(obj) || !obj) {
 717                 snprintf(errbuf, sizeof(errbuf),
 718                          "Internal error: load bpf obj with NULL");
 719                 err = -EINVAL;
 720                 goto errout;
 721         }
 722
 723         /*
 724          * Register atexit handler before calling bpf__probe() so
 725          * bpf__probe() don't need to unprobe probe points its already
 726          * created when failure.
 727          */
 728         if (!registered_unprobe_atexit) {
 729                 atexit(bpf__clear);
 730                 registered_unprobe_atexit = true;
 731         }
 732
 733         err = bpf__probe(obj);
 734         if (err) {
 735                 bpf__strerror_probe(obj, err, errbuf, sizeof(errbuf));
 736                 goto errout;
 737         }
 738
 739         err = bpf__load(obj);
 740         if (err) {
 741                 bpf__strerror_load(obj, err, errbuf, sizeof(errbuf));
 742                 goto errout;
 743         }
 744
 745         err = bpf__foreach_event(obj, add_bpf_event, &param);
 746         if (err) {
 747                 snprintf(errbuf, sizeof(errbuf),
 748                          "Attach events in BPF object failed");
 749                 goto errout;
 750         }
 751
 752         return 0;
 753 errout:
 754         parse_events_error__handle(parse_state->error, 0,
 755                                 strdup(errbuf), strdup("(add -v to see detail)"));
 756         return err;
 757 }
 758
 759 static int
 760 parse_events_config_bpf(struct parse_events_state *parse_state,
 761                         struct bpf_object *obj,
 762                         struct list_head *head_config)
 763 {
 764         struct parse_events_term *term;
 765         int error_pos = 0;
 766
 767         if (!head_config || list_empty(head_config))
 768                 return 0;
 769
 770         list_for_each_entry(term, head_config, list) {
 771                 int err;
 772
 773                 if (term->type_term != PARSE_EVENTS__TERM_TYPE_USER) {
 774                         parse_events_error__handle(parse_state->error, term->err_term,
 775                                                 strdup("Invalid config term for BPF object"),
 776                                                 NULL);
 777                         return -EINVAL;
 778                 }
 779
 780                 err = bpf__config_obj(obj, term, parse_state->evlist, &error_pos);
 781                 if (err) {
 782                         char errbuf[BUFSIZ];
 783                         int idx;
 784
 785                         bpf__strerror_config_obj(obj, term, parse_state->evlist,
 786                                                  &error_pos, err, errbuf,
 787                                                  sizeof(errbuf));
 788
 789                         if (err == -BPF_LOADER_ERRNO__OBJCONF_MAP_VALUE)
 790                                 idx = term->err_val;
 791                         else
 792                                 idx = term->err_term + error_pos;
 793
 794                         parse_events_error__handle(parse_state->error, idx,
 795                                                 strdup(errbuf),
 796                                                 strdup(
 797 "Hint:\tValid config terms:\n"
 798 "     \tmap:[<arraymap>].value<indices>=[value]\n"
 799 "     \tmap:[<eventmap>].event<indices>=[event]\n"
 800 "\n"
 801 "     \twhere <indices> is something like [0,3...5] or [all]\n"
 802 "     \t(add -v to see detail)"));
 803                         return err;
 804                 }
 805         }
 806         return 0;
 807 }
 808
 809 /*
 810  * Split config terms:
 811  * perf record -e bpf.c/call-graph=fp,map:array.value[0]=1/ ...
 812  *  'call-graph=fp' is 'evt config', should be applied to each
 813  *  events in bpf.c.
 814  * 'map:array.value[0]=1' is 'obj config', should be processed
 815  * with parse_events_config_bpf.
 816  *
 817  * Move object config terms from the first list to obj_head_config.
 818  */
 819 static void
 820 split_bpf_config_terms(struct list_head *evt_head_config,
 821                        struct list_head *obj_head_config)
 822 {
 823         struct parse_events_term *term, *temp;
 824
 825         /*
 826          * Currently, all possible user config term
 827          * belong to bpf object. parse_events__is_hardcoded_term()
 828          * happens to be a good flag.
 829          *
 830          * See parse_events_config_bpf() and
 831          * config_term_tracepoint().
 832          */
 833         list_for_each_entry_safe(term, temp, evt_head_config, list)
 834                 if (!parse_events__is_hardcoded_term(term))
 835                         list_move_tail(&term->list, obj_head_config);
 836 }
 837
 838 int parse_events_load_bpf(struct parse_events_state *parse_state,
 839                           struct list_head *list,
 840                           char *bpf_file_name,
 841                           bool source,
 842                           struct list_head *head_config)
 843 {
 844         int err;
 845         struct bpf_object *obj;
 846         LIST_HEAD(obj_head_config);
 847
 848         if (head_config)
 849                 split_bpf_config_terms(head_config, &obj_head_config);
 850
 851         obj = bpf__prepare_load(bpf_file_name, source);
 852         if (IS_ERR(obj)) {
 853                 char errbuf[BUFSIZ];
 854
 855                 err = PTR_ERR(obj);
 856
 857                 if (err == -ENOTSUP)
 858                         snprintf(errbuf, sizeof(errbuf),
 859                                  "BPF support is not compiled");
 860                 else
 861                         bpf__strerror_prepare_load(bpf_file_name,
 862                                                    source,
 863                                                    -err, errbuf,
 864                                                    sizeof(errbuf));
 865
 866                 parse_events_error__handle(parse_state->error, 0,
 867                                         strdup(errbuf), strdup("(add -v to see detail)"));
 868                 return err;
 869         }
 870
 871         err = parse_events_load_bpf_obj(parse_state, list, obj, head_config);
 872         if (err)
 873                 return err;
 874         err = parse_events_config_bpf(parse_state, obj, &obj_head_config);
 875
 876         /*
 877          * Caller doesn't know anything about obj_head_config,
 878          * so combine them together again before returning.
 879          */
 880         if (head_config)
 881                 list_splice_tail(&obj_head_config, head_config);
 882         return err;
 883 }
 884 #else // HAVE_LIBBPF_SUPPORT
 885 int parse_events_load_bpf_obj(struct parse_events_state *parse_state,
 886                               struct list_head *list __maybe_unused,
 887                               struct bpf_object *obj __maybe_unused,
 888                               struct list_head *head_config __maybe_unused)
 889 {
 890         parse_events_error__handle(parse_state->error, 0,
 891                                    strdup("BPF support is not compiled"),
 892                                    strdup("Make sure libbpf-devel is available at build time."));
 893         return -ENOTSUP;
 894 }
 895
 896 int parse_events_load_bpf(struct parse_events_state *parse_state,
 897                           struct list_head *list __maybe_unused,
 898                           char *bpf_file_name __maybe_unused,
 899                           bool source __maybe_unused,
 900                           struct list_head *head_config __maybe_unused)
 901 {
 902         parse_events_error__handle(parse_state->error, 0,
 903                                    strdup("BPF support is not compiled"),
 904                                    strdup("Make sure libbpf-devel is available at build time."));
 905         return -ENOTSUP;
 906 }
 907 #endif // HAVE_LIBBPF_SUPPORT
 908
 909 static int
 910 parse_breakpoint_type(const char *type, struct perf_event_attr *attr)
 911 {
 912         int i;
 913
 914         for (i = 0; i < 3; i++) {
 915                 if (!type || !type[i])
 916                         break;
 917
 918 #define CHECK_SET_TYPE(bit)             \
 919 do {                                    \
 920         if (attr->bp_type & bit)        \
 921                 return -EINVAL;         \
 922         else                            \
 923                 attr->bp_type |= bit;   \
 924 } while (0)
 925
 926                 switch (type[i]) {
 927                 case 'r':
 928                         CHECK_SET_TYPE(HW_BREAKPOINT_R);
 929                         break;
 930                 case 'w':
 931                         CHECK_SET_TYPE(HW_BREAKPOINT_W);
 932                         break;
 933                 case 'x':
 934                         CHECK_SET_TYPE(HW_BREAKPOINT_X);
 935                         break;
 936                 default:
 937                         return -EINVAL;
 938                 }
 939         }
 940
 941 #undef CHECK_SET_TYPE
 942
 943         if (!attr->bp_type) /* Default */
 944                 attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W;
 945
 946         return 0;
 947 }
 948
 949 int parse_events_add_breakpoint(struct parse_events_state *parse_state,
 950                                 struct list_head *list,
 951                                 u64 addr, char *type, u64 len,
 952                                 struct list_head *head_config __maybe_unused)
 953 {
 954         struct perf_event_attr attr;
 955         LIST_HEAD(config_terms);
 956         const char *name;
 957
 958         memset(&attr, 0, sizeof(attr));
 959         attr.bp_addr = addr;
 960
 961         if (parse_breakpoint_type(type, &attr))
 962                 return -EINVAL;
 963
 964         /* Provide some defaults if len is not specified */
 965         if (!len) {
 966                 if (attr.bp_type == HW_BREAKPOINT_X)
 967                         len = sizeof(long);
 968                 else
 969                         len = HW_BREAKPOINT_LEN_4;
 970         }
 971
 972         attr.bp_len = len;
 973
 974         attr.type = PERF_TYPE_BREAKPOINT;
 975         attr.sample_period = 1;
 976
 977         if (head_config) {
 978                 if (config_attr(&attr, head_config, parse_state->error,
 979                                 config_term_common))
 980                         return -EINVAL;
 981
 982                 if (get_config_terms(head_config, &config_terms))
 983                         return -ENOMEM;
 984         }
 985
 986         name = get_config_name(head_config);
 987
 988         return add_event(list, &parse_state->idx, &attr, name, /*mertic_id=*/NULL,
 989                          &config_terms);
 990 }
 991
 992 static int check_type_val(struct parse_events_term *term,
 993                           struct parse_events_error *err,
 994                           int type)
 995 {
 996         if (type == term->type_val)
 997                 return 0;
 998
 999         if (err) {
1000                 parse_events_error__handle(err, term->err_val,
1001                                         type == PARSE_EVENTS__TERM_TYPE_NUM
1002                                         ? strdup("expected numeric value")
1003                                         : strdup("expected string value"),
1004                                         NULL);
1005         }
1006         return -EINVAL;
1007 }
1008
1009 /*
1010  * Update according to parse-events.l
1011  */
1012 static const char *config_term_names[__PARSE_EVENTS__TERM_TYPE_NR] = {
1013         [PARSE_EVENTS__TERM_TYPE_USER]                  = "<sysfs term>",
1014         [PARSE_EVENTS__TERM_TYPE_CONFIG]                = "config",
1015         [PARSE_EVENTS__TERM_TYPE_CONFIG1]               = "config1",
1016         [PARSE_EVENTS__TERM_TYPE_CONFIG2]               = "config2",
1017         [PARSE_EVENTS__TERM_TYPE_CONFIG3]               = "config3",
1018         [PARSE_EVENTS__TERM_TYPE_NAME]                  = "name",
1019         [PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD]         = "period",
1020         [PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ]           = "freq",
1021         [PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE]    = "branch_type",
1022         [PARSE_EVENTS__TERM_TYPE_TIME]                  = "time",
1023         [PARSE_EVENTS__TERM_TYPE_CALLGRAPH]             = "call-graph",
1024         [PARSE_EVENTS__TERM_TYPE_STACKSIZE]             = "stack-size",
1025         [PARSE_EVENTS__TERM_TYPE_NOINHERIT]             = "no-inherit",
1026         [PARSE_EVENTS__TERM_TYPE_INHERIT]               = "inherit",
1027         [PARSE_EVENTS__TERM_TYPE_MAX_STACK]             = "max-stack",
1028         [PARSE_EVENTS__TERM_TYPE_MAX_EVENTS]            = "nr",
1029         [PARSE_EVENTS__TERM_TYPE_OVERWRITE]             = "overwrite",
1030         [PARSE_EVENTS__TERM_TYPE_NOOVERWRITE]           = "no-overwrite",
1031         [PARSE_EVENTS__TERM_TYPE_DRV_CFG]               = "driver-config",
1032         [PARSE_EVENTS__TERM_TYPE_PERCORE]               = "percore",
1033         [PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT]            = "aux-output",
1034         [PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE]       = "aux-sample-size",
1035         [PARSE_EVENTS__TERM_TYPE_METRIC_ID]             = "metric-id",
1036         [PARSE_EVENTS__TERM_TYPE_RAW]                   = "raw",
1037         [PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE]          = "legacy-cache",
1038         [PARSE_EVENTS__TERM_TYPE_HARDWARE]              = "hardware",
1039 };
1040
1041 static bool config_term_shrinked;
1042
1043 static bool
1044 config_term_avail(int term_type, struct parse_events_error *err)
1045 {
1046         char *err_str;
1047
1048         if (term_type < 0 || term_type >= __PARSE_EVENTS__TERM_TYPE_NR) {
1049                 parse_events_error__handle(err, -1,
1050                                         strdup("Invalid term_type"), NULL);
1051                 return false;
1052         }
1053         if (!config_term_shrinked)
1054                 return true;
1055
1056         switch (term_type) {
1057         case PARSE_EVENTS__TERM_TYPE_CONFIG:
1058         case PARSE_EVENTS__TERM_TYPE_CONFIG1:
1059         case PARSE_EVENTS__TERM_TYPE_CONFIG2:
1060         case PARSE_EVENTS__TERM_TYPE_CONFIG3:
1061         case PARSE_EVENTS__TERM_TYPE_NAME:
1062         case PARSE_EVENTS__TERM_TYPE_METRIC_ID:
1063         case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
1064         case PARSE_EVENTS__TERM_TYPE_PERCORE:
1065                 return true;
1066         default:
1067                 if (!err)
1068                         return false;
1069
1070                 /* term_type is validated so indexing is safe */
1071                 if (asprintf(&err_str, "'%s' is not usable in 'perf stat'",
1072                                 config_term_names[term_type]) >= 0)
1073                         parse_events_error__handle(err, -1, err_str, NULL);
1074                 return false;
1075         }
1076 }
1077
1078 void parse_events__shrink_config_terms(void)
1079 {
1080         config_term_shrinked = true;
1081 }
1082
1083 static int config_term_common(struct perf_event_attr *attr,
1084                               struct parse_events_term *term,
1085                               struct parse_events_error *err)
1086 {
1087 #define CHECK_TYPE_VAL(type)                                               \
1088 do {                                                                       \
1089         if (check_type_val(term, err, PARSE_EVENTS__TERM_TYPE_ ## type)) \
1090                 return -EINVAL;                                            \
1091 } while (0)
1092
1093         switch (term->type_term) {
1094         case PARSE_EVENTS__TERM_TYPE_CONFIG:
1095                 CHECK_TYPE_VAL(NUM);
1096                 attr->config = term->val.num;
1097                 break;
1098         case PARSE_EVENTS__TERM_TYPE_CONFIG1:
1099                 CHECK_TYPE_VAL(NUM);
1100                 attr->config1 = term->val.num;
1101                 break;
1102         case PARSE_EVENTS__TERM_TYPE_CONFIG2:
1103                 CHECK_TYPE_VAL(NUM);
1104                 attr->config2 = term->val.num;
1105                 break;
1106         case PARSE_EVENTS__TERM_TYPE_CONFIG3:
1107                 CHECK_TYPE_VAL(NUM);
1108                 attr->config3 = term->val.num;
1109                 break;
1110         case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
1111                 CHECK_TYPE_VAL(NUM);
1112                 break;
1113         case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ:
1114                 CHECK_TYPE_VAL(NUM);
1115                 break;
1116         case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
1117                 CHECK_TYPE_VAL(STR);
1118                 if (strcmp(term->val.str, "no") &&
1119                     parse_branch_str(term->val.str,
1120                                     &attr->branch_sample_type)) {
1121                         parse_events_error__handle(err, term->err_val,
1122                                         strdup("invalid branch sample type"),
1123                                         NULL);
1124                         return -EINVAL;
1125                 }
1126                 break;
1127         case PARSE_EVENTS__TERM_TYPE_TIME:
1128                 CHECK_TYPE_VAL(NUM);
1129                 if (term->val.num > 1) {
1130                         parse_events_error__handle(err, term->err_val,
1131                                                 strdup("expected 0 or 1"),
1132                                                 NULL);
1133                         return -EINVAL;
1134                 }
1135                 break;
1136         case PARSE_EVENTS__TERM_TYPE_CALLGRAPH:
1137                 CHECK_TYPE_VAL(STR);
1138                 break;
1139         case PARSE_EVENTS__TERM_TYPE_STACKSIZE:
1140                 CHECK_TYPE_VAL(NUM);
1141                 break;
1142         case PARSE_EVENTS__TERM_TYPE_INHERIT:
1143                 CHECK_TYPE_VAL(NUM);
1144                 break;
1145         case PARSE_EVENTS__TERM_TYPE_NOINHERIT:
1146                 CHECK_TYPE_VAL(NUM);
1147                 break;
1148         case PARSE_EVENTS__TERM_TYPE_OVERWRITE:
1149                 CHECK_TYPE_VAL(NUM);
1150                 break;
1151         case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE:
1152                 CHECK_TYPE_VAL(NUM);
1153                 break;
1154         case PARSE_EVENTS__TERM_TYPE_NAME:
1155                 CHECK_TYPE_VAL(STR);
1156                 break;
1157         case PARSE_EVENTS__TERM_TYPE_METRIC_ID:
1158                 CHECK_TYPE_VAL(STR);
1159                 break;
1160         case PARSE_EVENTS__TERM_TYPE_RAW:
1161                 CHECK_TYPE_VAL(STR);
1162                 break;
1163         case PARSE_EVENTS__TERM_TYPE_MAX_STACK:
1164                 CHECK_TYPE_VAL(NUM);
1165                 break;
1166         case PARSE_EVENTS__TERM_TYPE_MAX_EVENTS:
1167                 CHECK_TYPE_VAL(NUM);
1168                 break;
1169         case PARSE_EVENTS__TERM_TYPE_PERCORE:
1170                 CHECK_TYPE_VAL(NUM);
1171                 if ((unsigned int)term->val.num > 1) {
1172                         parse_events_error__handle(err, term->err_val,
1173                                                 strdup("expected 0 or 1"),
1174                                                 NULL);
1175                         return -EINVAL;
1176                 }
1177                 break;
1178         case PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT:
1179                 CHECK_TYPE_VAL(NUM);
1180                 break;
1181         case PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE:
1182                 CHECK_TYPE_VAL(NUM);
1183                 if (term->val.num > UINT_MAX) {
1184                         parse_events_error__handle(err, term->err_val,
1185                                                 strdup("too big"),
1186                                                 NULL);
1187                         return -EINVAL;
1188                 }
1189                 break;
1190         default:
1191                 parse_events_error__handle(err, term->err_term,
1192                                 strdup("unknown term"),
1193                                 parse_events_formats_error_string(NULL));
1194                 return -EINVAL;
1195         }
1196
1197         /*
1198          * Check term availability after basic checking so
1199          * PARSE_EVENTS__TERM_TYPE_USER can be found and filtered.
1200          *
1201          * If check availability at the entry of this function,
1202          * user will see "'<sysfs term>' is not usable in 'perf stat'"
1203          * if an invalid config term is provided for legacy events
1204          * (for example, instructions/badterm/...), which is confusing.
1205          */
1206         if (!config_term_avail(term->type_term, err))
1207                 return -EINVAL;
1208         return 0;
1209 #undef CHECK_TYPE_VAL
1210 }
1211
1212 static int config_term_pmu(struct perf_event_attr *attr,
1213                            struct parse_events_term *term,
1214                            struct parse_events_error *err)
1215 {
1216         if (term->type_term == PARSE_EVENTS__TERM_TYPE_LEGACY_CACHE) {
1217                 const struct perf_pmu *pmu = perf_pmus__find_by_type(attr->type);
1218
1219                 if (!pmu) {
1220                         char *err_str;
1221
1222                         if (asprintf(&err_str, "Failed to find PMU for type %d", attr->type) >= 0)
1223                                 parse_events_error__handle(err, term->err_term,
1224                                                            err_str, /*help=*/NULL);
1225                         return -EINVAL;
1226                 }
1227                 if (perf_pmu__supports_legacy_cache(pmu)) {
1228                         attr->type = PERF_TYPE_HW_CACHE;
1229                         return parse_events__decode_legacy_cache(term->config, pmu->type,
1230                                                                  &attr->config);
1231                 } else
1232                         term->type_term = PARSE_EVENTS__TERM_TYPE_USER;
1233         }
1234         if (term->type_term == PARSE_EVENTS__TERM_TYPE_HARDWARE) {
1235                 const struct perf_pmu *pmu = perf_pmus__find_by_type(attr->type);
1236
1237                 if (!pmu) {
1238                         char *err_str;
1239
1240                         if (asprintf(&err_str, "Failed to find PMU for type %d", attr->type) >= 0)
1241                                 parse_events_error__handle(err, term->err_term,
1242                                                            err_str, /*help=*/NULL);
1243                         return -EINVAL;
1244                 }
1245                 attr->type = PERF_TYPE_HARDWARE;
1246                 attr->config = term->val.num;
1247                 if (perf_pmus__supports_extended_type())
1248                         attr->config |= (__u64)pmu->type << PERF_PMU_TYPE_SHIFT;
1249                 return 0;
1250         }
1251         if (term->type_term == PARSE_EVENTS__TERM_TYPE_USER ||
1252             term->type_term == PARSE_EVENTS__TERM_TYPE_DRV_CFG) {
1253                 /*
1254                  * Always succeed for sysfs terms, as we dont know
1255                  * at this point what type they need to have.
1256                  */
1257                 return 0;
1258         }
1259         return config_term_common(attr, term, err);
1260 }
1261
1262 #ifdef HAVE_LIBTRACEEVENT
1263 static int config_term_tracepoint(struct perf_event_attr *attr,
1264                                   struct parse_events_term *term,
1265                                   struct parse_events_error *err)
1266 {
1267         switch (term->type_term) {
1268         case PARSE_EVENTS__TERM_TYPE_CALLGRAPH:
1269         case PARSE_EVENTS__TERM_TYPE_STACKSIZE:
1270         case PARSE_EVENTS__TERM_TYPE_INHERIT:
1271         case PARSE_EVENTS__TERM_TYPE_NOINHERIT:
1272         case PARSE_EVENTS__TERM_TYPE_MAX_STACK:
1273         case PARSE_EVENTS__TERM_TYPE_MAX_EVENTS:
1274         case PARSE_EVENTS__TERM_TYPE_OVERWRITE:
1275         case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE:
1276         case PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT:
1277         case PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE:
1278                 return config_term_common(attr, term, err);
1279         default:
1280                 if (err) {
1281                         parse_events_error__handle(err, term->err_term,
1282                                 strdup("unknown term"),
1283                                 strdup("valid terms: call-graph,stack-size\n"));
1284                 }
1285                 return -EINVAL;
1286         }
1287
1288         return 0;
1289 }
1290 #endif
1291
1292 static int config_attr(struct perf_event_attr *attr,
1293                        struct list_head *head,
1294                        struct parse_events_error *err,
1295                        config_term_func_t config_term)
1296 {
1297         struct parse_events_term *term;
1298
1299         list_for_each_entry(term, head, list)
1300                 if (config_term(attr, term, err))
1301                         return -EINVAL;
1302
1303         return 0;
1304 }
1305
1306 static int get_config_terms(struct list_head *head_config,
1307                             struct list_head *head_terms __maybe_unused)
1308 {
1309 #define ADD_CONFIG_TERM(__type, __weak)                         \
1310         struct evsel_config_term *__t;                  \
1311                                                                 \
1312         __t = zalloc(sizeof(*__t));                             \
1313         if (!__t)                                               \
1314                 return -ENOMEM;                                 \
1315                                                                 \
1316         INIT_LIST_HEAD(&__t->list);                             \
1317         __t->type       = EVSEL__CONFIG_TERM_ ## __type;        \
1318         __t->weak       = __weak;                               \
1319         list_add_tail(&__t->list, head_terms)
1320
1321 #define ADD_CONFIG_TERM_VAL(__type, __name, __val, __weak)      \
1322 do {                                                            \
1323         ADD_CONFIG_TERM(__type, __weak);                        \
1324         __t->val.__name = __val;                                \
1325 } while (0)
1326
1327 #define ADD_CONFIG_TERM_STR(__type, __val, __weak)              \
1328 do {                                                            \
1329         ADD_CONFIG_TERM(__type, __weak);                        \
1330         __t->val.str = strdup(__val);                           \
1331         if (!__t->val.str) {                                    \
1332                 zfree(&__t);                                    \
1333                 return -ENOMEM;                                 \
1334         }                                                       \
1335         __t->free_str = true;                                   \
1336 } while (0)
1337
1338         struct parse_events_term *term;
1339
1340         list_for_each_entry(term, head_config, list) {
1341                 switch (term->type_term) {
1342                 case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
1343                         ADD_CONFIG_TERM_VAL(PERIOD, period, term->val.num, term->weak);
1344                         break;
1345                 case PARSE_EVENTS__TERM_TYPE_SAMPLE_FREQ:
1346                         ADD_CONFIG_TERM_VAL(FREQ, freq, term->val.num, term->weak);
1347                         break;
1348                 case PARSE_EVENTS__TERM_TYPE_TIME:
1349                         ADD_CONFIG_TERM_VAL(TIME, time, term->val.num, term->weak);
1350                         break;
1351                 case PARSE_EVENTS__TERM_TYPE_CALLGRAPH:
1352                         ADD_CONFIG_TERM_STR(CALLGRAPH, term->val.str, term->weak);
1353                         break;
1354                 case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
1355                         ADD_CONFIG_TERM_STR(BRANCH, term->val.str, term->weak);
1356                         break;
1357                 case PARSE_EVENTS__TERM_TYPE_STACKSIZE:
1358                         ADD_CONFIG_TERM_VAL(STACK_USER, stack_user,
1359                                             term->val.num, term->weak);
1360                         break;
1361                 case PARSE_EVENTS__TERM_TYPE_INHERIT:
1362                         ADD_CONFIG_TERM_VAL(INHERIT, inherit,
1363                                             term->val.num ? 1 : 0, term->weak);
1364                         break;
1365                 case PARSE_EVENTS__TERM_TYPE_NOINHERIT:
1366                         ADD_CONFIG_TERM_VAL(INHERIT, inherit,
1367                                             term->val.num ? 0 : 1, term->weak);
1368                         break;
1369                 case PARSE_EVENTS__TERM_TYPE_MAX_STACK:
1370                         ADD_CONFIG_TERM_VAL(MAX_STACK, max_stack,
1371                                             term->val.num, term->weak);
1372                         break;
1373                 case PARSE_EVENTS__TERM_TYPE_MAX_EVENTS:
1374                         ADD_CONFIG_TERM_VAL(MAX_EVENTS, max_events,
1375                                             term->val.num, term->weak);
1376                         break;
1377                 case PARSE_EVENTS__TERM_TYPE_OVERWRITE:
1378                         ADD_CONFIG_TERM_VAL(OVERWRITE, overwrite,
1379                                             term->val.num ? 1 : 0, term->weak);
1380                         break;
1381                 case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE:
1382                         ADD_CONFIG_TERM_VAL(OVERWRITE, overwrite,
1383                                             term->val.num ? 0 : 1, term->weak);
1384                         break;
1385                 case PARSE_EVENTS__TERM_TYPE_DRV_CFG:
1386                         ADD_CONFIG_TERM_STR(DRV_CFG, term->val.str, term->weak);
1387                         break;
1388                 case PARSE_EVENTS__TERM_TYPE_PERCORE:
1389                         ADD_CONFIG_TERM_VAL(PERCORE, percore,
1390                                             term->val.num ? true : false, term->weak);
1391                         break;
1392                 case PARSE_EVENTS__TERM_TYPE_AUX_OUTPUT:
1393                         ADD_CONFIG_TERM_VAL(AUX_OUTPUT, aux_output,
1394                                             term->val.num ? 1 : 0, term->weak);
1395                         break;
1396                 case PARSE_EVENTS__TERM_TYPE_AUX_SAMPLE_SIZE:
1397                         ADD_CONFIG_TERM_VAL(AUX_SAMPLE_SIZE, aux_sample_size,
1398                                             term->val.num, term->weak);
1399                         break;
1400                 default:
1401                         break;
1402                 }
1403         }
1404         return 0;
1405 }
1406
1407 /*
1408  * Add EVSEL__CONFIG_TERM_CFG_CHG where cfg_chg will have a bit set for
1409  * each bit of attr->config that the user has changed.
1410  */
1411 static int get_config_chgs(struct perf_pmu *pmu, struct list_head *head_config,
1412                            struct list_head *head_terms)
1413 {
1414         struct parse_events_term *term;
1415         u64 bits = 0;
1416         int type;
1417
1418         list_for_each_entry(term, head_config, list) {
1419                 switch (term->type_term) {
1420                 case PARSE_EVENTS__TERM_TYPE_USER:
1421                         type = perf_pmu__format_type(&pmu->format, term->config);
1422                         if (type != PERF_PMU_FORMAT_VALUE_CONFIG)
1423                                 continue;
1424                         bits |= perf_pmu__format_bits(&pmu->format, term->config);
1425                         break;
1426                 case PARSE_EVENTS__TERM_TYPE_CONFIG:
1427                         bits = ~(u64)0;
1428                         break;
1429                 default:
1430                         break;
1431                 }
1432         }
1433
1434         if (bits)
1435                 ADD_CONFIG_TERM_VAL(CFG_CHG, cfg_chg, bits, false);
1436
1437 #undef ADD_CONFIG_TERM
1438         return 0;
1439 }
1440
1441 int parse_events_add_tracepoint(struct list_head *list, int *idx,
1442                                 const char *sys, const char *event,
1443                                 struct parse_events_error *err,
1444                                 struct list_head *head_config)
1445 {
1446 #ifdef HAVE_LIBTRACEEVENT
1447         if (head_config) {
1448                 struct perf_event_attr attr;
1449
1450                 if (config_attr(&attr, head_config, err,
1451                                 config_term_tracepoint))
1452                         return -EINVAL;
1453         }
1454
1455         if (strpbrk(sys, "*?"))
1456                 return add_tracepoint_multi_sys(list, idx, sys, event,
1457                                                 err, head_config);
1458         else
1459                 return add_tracepoint_event(list, idx, sys, event,
1460                                             err, head_config);
1461 #else
1462         (void)list;
1463         (void)idx;
1464         (void)sys;
1465         (void)event;
1466         (void)head_config;
1467         parse_events_error__handle(err, 0, strdup("unsupported tracepoint"),
1468                                 strdup("libtraceevent is necessary for tracepoint support"));
1469         return -1;
1470 #endif
1471 }
1472
1473 static int __parse_events_add_numeric(struct parse_events_state *parse_state,
1474                                 struct list_head *list,
1475                                 struct perf_pmu *pmu, u32 type, u32 extended_type,
1476                                 u64 config, struct list_head *head_config)
1477 {
1478         struct perf_event_attr attr;
1479         LIST_HEAD(config_terms);
1480         const char *name, *metric_id;
1481         int ret;
1482
1483         memset(&attr, 0, sizeof(attr));
1484         attr.type = type;
1485         attr.config = config;
1486         if (extended_type && (type == PERF_TYPE_HARDWARE || type == PERF_TYPE_HW_CACHE)) {
1487                 assert(perf_pmus__supports_extended_type());
1488                 attr.config |= (u64)extended_type << PERF_PMU_TYPE_SHIFT;
1489         }
1490
1491         if (head_config) {
1492                 if (config_attr(&attr, head_config, parse_state->error,
1493                                 config_term_common))
1494                         return -EINVAL;
1495
1496                 if (get_config_terms(head_config, &config_terms))
1497                         return -ENOMEM;
1498         }
1499
1500         name = get_config_name(head_config);
1501         metric_id = get_config_metric_id(head_config);
1502         ret = __add_event(list, &parse_state->idx, &attr, /*init_attr*/true, name,
1503                         metric_id, pmu, &config_terms, /*auto_merge_stats=*/false,
1504                         /*cpu_list=*/NULL) ? 0 : -ENOMEM;
1505         free_config_terms(&config_terms);
1506         return ret;
1507 }
1508
1509 int parse_events_add_numeric(struct parse_events_state *parse_state,
1510                              struct list_head *list,
1511                              u32 type, u64 config,
1512                              struct list_head *head_config,
1513                              bool wildcard)
1514 {
1515         struct perf_pmu *pmu = NULL;
1516         bool found_supported = false;
1517
1518         /* Wildcards on numeric values are only supported by core PMUs. */
1519         if (wildcard && perf_pmus__supports_extended_type()) {
1520                 while ((pmu = perf_pmus__scan_core(pmu)) != NULL) {
1521                         int ret;
1522
1523                         found_supported = true;
1524                         if (parse_events__filter_pmu(parse_state, pmu))
1525                                 continue;
1526
1527                         ret = __parse_events_add_numeric(parse_state, list, pmu,
1528                                                          type, pmu->type,
1529                                                          config, head_config);
1530                         if (ret)
1531                                 return ret;
1532                 }
1533                 if (found_supported)
1534                         return 0;
1535         }
1536         return __parse_events_add_numeric(parse_state, list, perf_pmus__find_by_type(type),
1537                                         type, /*extended_type=*/0, config, head_config);
1538 }
1539
1540 int parse_events_add_tool(struct parse_events_state *parse_state,
1541                           struct list_head *list,
1542                           int tool_event)
1543 {
1544         return add_event_tool(list, &parse_state->idx, tool_event);
1545 }
1546
1547 static bool config_term_percore(struct list_head *config_terms)
1548 {
1549         struct evsel_config_term *term;
1550
1551         list_for_each_entry(term, config_terms, list) {
1552                 if (term->type == EVSEL__CONFIG_TERM_PERCORE)
1553                         return term->val.percore;
1554         }
1555
1556         return false;
1557 }
1558
1559 int parse_events_add_pmu(struct parse_events_state *parse_state,
1560                          struct list_head *list, char *name,
1561                          struct list_head *head_config,
1562                          bool auto_merge_stats)
1563 {
1564         struct perf_event_attr attr;
1565         struct perf_pmu_info info;
1566         struct perf_pmu *pmu;
1567         struct evsel *evsel;
1568         struct parse_events_error *err = parse_state->error;
1569         LIST_HEAD(config_terms);
1570
1571         pmu = parse_state->fake_pmu ?: perf_pmus__find(name);
1572
1573         if (verbose > 1 && !(pmu && pmu->selectable)) {
1574                 fprintf(stderr, "Attempting to add event pmu '%s' with '",
1575                         name);
1576                 if (head_config) {
1577                         struct parse_events_term *term;
1578
1579                         list_for_each_entry(term, head_config, list) {
1580                                 fprintf(stderr, "%s,", term->config);
1581                         }
1582                 }
1583                 fprintf(stderr, "' that may result in non-fatal errors\n");
1584         }
1585
1586         if (!pmu) {
1587                 char *err_str;
1588
1589                 if (asprintf(&err_str,
1590                                 "Cannot find PMU `%s'. Missing kernel support?",
1591                                 name) >= 0)
1592                         parse_events_error__handle(err, 0, err_str, NULL);
1593                 return -EINVAL;
1594         }
1595         if (head_config)
1596                 fix_raw(head_config, pmu);
1597
1598         if (pmu->default_config) {
1599                 memcpy(&attr, pmu->default_config,
1600                        sizeof(struct perf_event_attr));
1601         } else {
1602                 memset(&attr, 0, sizeof(attr));
1603         }
1604         attr.type = pmu->type;
1605
1606         if (!head_config) {
1607                 evsel = __add_event(list, &parse_state->idx, &attr,
1608                                     /*init_attr=*/true, /*name=*/NULL,
1609                                     /*metric_id=*/NULL, pmu,
1610                                     /*config_terms=*/NULL, auto_merge_stats,
1611                                     /*cpu_list=*/NULL);
1612                 return evsel ? 0 : -ENOMEM;
1613         }
1614
1615         if (!parse_state->fake_pmu && perf_pmu__check_alias(pmu, head_config, &info))
1616                 return -EINVAL;
1617
1618         if (verbose > 1) {
1619                 fprintf(stderr, "After aliases, add event pmu '%s' with '",
1620                         name);
1621                 if (head_config) {
1622                         struct parse_events_term *term;
1623
1624                         list_for_each_entry(term, head_config, list) {
1625                                 fprintf(stderr, "%s,", term->config);
1626                         }
1627                 }
1628                 fprintf(stderr, "' that may result in non-fatal errors\n");
1629         }
1630
1631         /*
1632          * Configure hardcoded terms first, no need to check
1633          * return value when called with fail == 0 ;)
1634          */
1635         if (config_attr(&attr, head_config, parse_state->error, config_term_pmu))
1636                 return -EINVAL;
1637
1638         if (get_config_terms(head_config, &config_terms))
1639                 return -ENOMEM;
1640
1641         /*
1642          * When using default config, record which bits of attr->config were
1643          * changed by the user.
1644          */
1645         if (pmu->default_config && get_config_chgs(pmu, head_config, &config_terms))
1646                 return -ENOMEM;
1647
1648         if (!parse_state->fake_pmu && perf_pmu__config(pmu, &attr, head_config, parse_state->error)) {
1649                 free_config_terms(&config_terms);
1650                 return -EINVAL;
1651         }
1652
1653         evsel = __add_event(list, &parse_state->idx, &attr, /*init_attr=*/true,
1654                             get_config_name(head_config),
1655                             get_config_metric_id(head_config), pmu,
1656                             &config_terms, auto_merge_stats, /*cpu_list=*/NULL);
1657         if (!evsel)
1658                 return -ENOMEM;
1659
1660         if (evsel->name)
1661                 evsel->use_config_name = true;
1662
1663         evsel->percore = config_term_percore(&evsel->config_terms);
1664
1665         if (parse_state->fake_pmu)
1666                 return 0;
1667
1668         free((char *)evsel->unit);
1669         evsel->unit = strdup(info.unit);
1670         evsel->scale = info.scale;
1671         evsel->per_pkg = info.per_pkg;
1672         evsel->snapshot = info.snapshot;
1673         return 0;
1674 }
1675
1676 int parse_events_multi_pmu_add(struct parse_events_state *parse_state,
1677                                char *str, struct list_head *head,
1678                                struct list_head **listp)
1679 {
1680         struct parse_events_term *term;
1681         struct list_head *list = NULL;
1682         struct list_head *orig_head = NULL;
1683         struct perf_pmu *pmu = NULL;
1684         int ok = 0;
1685         char *config;
1686
1687         *listp = NULL;
1688
1689         if (!head) {
1690                 head = malloc(sizeof(struct list_head));
1691                 if (!head)
1692                         goto out_err;
1693
1694                 INIT_LIST_HEAD(head);
1695         }
1696         config = strdup(str);
1697         if (!config)
1698                 goto out_err;
1699
1700         if (parse_events_term__num(&term,
1701                                    PARSE_EVENTS__TERM_TYPE_USER,
1702                                    config, 1, false, NULL,
1703                                         NULL) < 0) {
1704                 free(config);
1705                 goto out_err;
1706         }
1707         list_add_tail(&term->list, head);
1708
1709         /* Add it for all PMUs that support the alias */
1710         list = malloc(sizeof(struct list_head));
1711         if (!list)
1712                 goto out_err;
1713
1714         INIT_LIST_HEAD(list);
1715
1716         while ((pmu = perf_pmus__scan(pmu)) != NULL) {
1717                 struct perf_pmu_alias *alias;
1718                 bool auto_merge_stats;
1719
1720                 if (parse_events__filter_pmu(parse_state, pmu))
1721                         continue;
1722
1723                 auto_merge_stats = perf_pmu__auto_merge_stats(pmu);
1724
1725                 list_for_each_entry(alias, &pmu->aliases, list) {
1726                         if (!strcasecmp(alias->name, str)) {
1727                                 parse_events_copy_term_list(head, &orig_head);
1728                                 if (!parse_events_add_pmu(parse_state, list,
1729                                                           pmu->name, orig_head,
1730                                                           auto_merge_stats)) {
1731                                         pr_debug("%s -> %s/%s/\n", str,
1732                                                  pmu->name, alias->str);
1733                                         parse_state->wild_card_pmus = true;
1734                                         ok++;
1735                                 }
1736                                 parse_events_terms__delete(orig_head);
1737                         }
1738                 }
1739         }
1740
1741         if (parse_state->fake_pmu) {
1742                 if (!parse_events_add_pmu(parse_state, list, str, head,
1743                                           /*auto_merge_stats=*/true)) {
1744                         pr_debug("%s -> %s/%s/\n", str, "fake_pmu", str);
1745                         ok++;
1746                 }
1747         }
1748
1749 out_err:
1750         if (ok)
1751                 *listp = list;
1752         else
1753                 free(list);
1754
1755         parse_events_terms__delete(head);
1756         return ok ? 0 : -1;
1757 }
1758
1759 int parse_events__modifier_group(struct list_head *list,
1760                                  char *event_mod)
1761 {
1762         return parse_events__modifier_event(list, event_mod, true);
1763 }
1764
1765 void parse_events__set_leader(char *name, struct list_head *list)
1766 {
1767         struct evsel *leader;
1768
1769         if (list_empty(list)) {
1770                 WARN_ONCE(true, "WARNING: failed to set leader: empty list");
1771                 return;
1772         }
1773
1774         leader = list_first_entry(list, struct evsel, core.node);
1775         __perf_evlist__set_leader(list, &leader->core);
1776         leader->group_name = name;
1777 }
1778
1779 /* list_event is assumed to point to malloc'ed memory */
1780 void parse_events_update_lists(struct list_head *list_event,
1781                                struct list_head *list_all)
1782 {
1783         /*
1784          * Called for single event definition. Update the
1785          * 'all event' list, and reinit the 'single event'
1786          * list, for next event definition.
1787          */
1788         list_splice_tail(list_event, list_all);
1789         free(list_event);
1790 }
1791
1792 struct event_modifier {
1793         int eu;
1794         int ek;
1795         int eh;
1796         int eH;
1797         int eG;
1798         int eI;
1799         int precise;
1800         int precise_max;
1801         int exclude_GH;
1802         int sample_read;
1803         int pinned;
1804         int weak;
1805         int exclusive;
1806         int bpf_counter;
1807 };
1808
1809 static int get_event_modifier(struct event_modifier *mod, char *str,
1810                                struct evsel *evsel)
1811 {
1812         int eu = evsel ? evsel->core.attr.exclude_user : 0;
1813         int ek = evsel ? evsel->core.attr.exclude_kernel : 0;
1814         int eh = evsel ? evsel->core.attr.exclude_hv : 0;
1815         int eH = evsel ? evsel->core.attr.exclude_host : 0;
1816         int eG = evsel ? evsel->core.attr.exclude_guest : 0;
1817         int eI = evsel ? evsel->core.attr.exclude_idle : 0;
1818         int precise = evsel ? evsel->core.attr.precise_ip : 0;
1819         int precise_max = 0;
1820         int sample_read = 0;
1821         int pinned = evsel ? evsel->core.attr.pinned : 0;
1822         int exclusive = evsel ? evsel->core.attr.exclusive : 0;
1823
1824         int exclude = eu | ek | eh;
1825         int exclude_GH = evsel ? evsel->exclude_GH : 0;
1826         int weak = 0;
1827         int bpf_counter = 0;
1828
1829         memset(mod, 0, sizeof(*mod));
1830
1831         while (*str) {
1832                 if (*str == 'u') {
1833                         if (!exclude)
1834                                 exclude = eu = ek = eh = 1;
1835                         if (!exclude_GH && !perf_guest)
1836                                 eG = 1;
1837                         eu = 0;
1838                 } else if (*str == 'k') {
1839                         if (!exclude)
1840                                 exclude = eu = ek = eh = 1;
1841                         ek = 0;
1842                 } else if (*str == 'h') {
1843                         if (!exclude)
1844                                 exclude = eu = ek = eh = 1;
1845                         eh = 0;
1846                 } else if (*str == 'G') {
1847                         if (!exclude_GH)
1848                                 exclude_GH = eG = eH = 1;
1849                         eG = 0;
1850                 } else if (*str == 'H') {
1851                         if (!exclude_GH)
1852                                 exclude_GH = eG = eH = 1;
1853                         eH = 0;
1854                 } else if (*str == 'I') {
1855                         eI = 1;
1856                 } else if (*str == 'p') {
1857                         precise++;
1858                         /* use of precise requires exclude_guest */
1859                         if (!exclude_GH)
1860                                 eG = 1;
1861                 } else if (*str == 'P') {
1862                         precise_max = 1;
1863                 } else if (*str == 'S') {
1864                         sample_read = 1;
1865                 } else if (*str == 'D') {
1866                         pinned = 1;
1867                 } else if (*str == 'e') {
1868                         exclusive = 1;
1869                 } else if (*str == 'W') {
1870                         weak = 1;
1871                 } else if (*str == 'b') {
1872                         bpf_counter = 1;
1873                 } else
1874                         break;
1875
1876                 ++str;
1877         }
1878
1879         /*
1880          * precise ip:
1881          *
1882          *  0 - SAMPLE_IP can have arbitrary skid
1883          *  1 - SAMPLE_IP must have constant skid
1884          *  2 - SAMPLE_IP requested to have 0 skid
1885          *  3 - SAMPLE_IP must have 0 skid
1886          *
1887          *  See also PERF_RECORD_MISC_EXACT_IP
1888          */
1889         if (precise > 3)
1890                 return -EINVAL;
1891
1892         mod->eu = eu;
1893         mod->ek = ek;
1894         mod->eh = eh;
1895         mod->eH = eH;
1896         mod->eG = eG;
1897         mod->eI = eI;
1898         mod->precise = precise;
1899         mod->precise_max = precise_max;
1900         mod->exclude_GH = exclude_GH;
1901         mod->sample_read = sample_read;
1902         mod->pinned = pinned;
1903         mod->weak = weak;
1904         mod->bpf_counter = bpf_counter;
1905         mod->exclusive = exclusive;
1906
1907         return 0;
1908 }
1909
1910 /*
1911  * Basic modifier sanity check to validate it contains only one
1912  * instance of any modifier (apart from 'p') present.
1913  */
1914 static int check_modifier(char *str)
1915 {
1916         char *p = str;
1917
1918         /* The sizeof includes 0 byte as well. */
1919         if (strlen(str) > (sizeof("ukhGHpppPSDIWeb") - 1))
1920                 return -1;
1921
1922         while (*p) {
1923                 if (*p != 'p' && strchr(p + 1, *p))
1924                         return -1;
1925                 p++;
1926         }
1927
1928         return 0;
1929 }
1930
1931 int parse_events__modifier_event(struct list_head *list, char *str, bool add)
1932 {
1933         struct evsel *evsel;
1934         struct event_modifier mod;
1935
1936         if (str == NULL)
1937                 return 0;
1938
1939         if (check_modifier(str))
1940                 return -EINVAL;
1941
1942         if (!add && get_event_modifier(&mod, str, NULL))
1943                 return -EINVAL;
1944
1945         __evlist__for_each_entry(list, evsel) {
1946                 if (add && get_event_modifier(&mod, str, evsel))
1947                         return -EINVAL;
1948
1949                 evsel->core.attr.exclude_user   = mod.eu;
1950                 evsel->core.attr.exclude_kernel = mod.ek;
1951                 evsel->core.attr.exclude_hv     = mod.eh;
1952                 evsel->core.attr.precise_ip     = mod.precise;
1953                 evsel->core.attr.exclude_host   = mod.eH;
1954                 evsel->core.attr.exclude_guest  = mod.eG;
1955                 evsel->core.attr.exclude_idle   = mod.eI;
1956                 evsel->exclude_GH          = mod.exclude_GH;
1957                 evsel->sample_read         = mod.sample_read;
1958                 evsel->precise_max         = mod.precise_max;
1959                 evsel->weak_group          = mod.weak;
1960                 evsel->bpf_counter         = mod.bpf_counter;
1961
1962                 if (evsel__is_group_leader(evsel)) {
1963                         evsel->core.attr.pinned = mod.pinned;
1964                         evsel->core.attr.exclusive = mod.exclusive;
1965                 }
1966         }
1967
1968         return 0;
1969 }
1970
1971 int parse_events_name(struct list_head *list, const char *name)
1972 {
1973         struct evsel *evsel;
1974
1975         __evlist__for_each_entry(list, evsel) {
1976                 if (!evsel->name) {
1977                         evsel->name = strdup(name);
1978                         if (!evsel->name)
1979                                 return -ENOMEM;
1980                 }
1981         }
1982
1983         return 0;
1984 }
1985
1986 static int parse_events__scanner(const char *str,
1987                                  struct parse_events_state *parse_state)
1988 {
1989         YY_BUFFER_STATE buffer;
1990         void *scanner;
1991         int ret;
1992
1993         ret = parse_events_lex_init_extra(parse_state, &scanner);
1994         if (ret)
1995                 return ret;
1996
1997         buffer = parse_events__scan_string(str, scanner);
1998
1999 #ifdef PARSER_DEBUG
2000         parse_events_debug = 1;
2001         parse_events_set_debug(1, scanner);
2002 #endif
2003         ret = parse_events_parse(parse_state, scanner);
2004
2005         parse_events__flush_buffer(buffer, scanner);
2006         parse_events__delete_buffer(buffer, scanner);
2007         parse_events_lex_destroy(scanner);
2008         return ret;
2009 }
2010
2011 /*
2012  * parse event config string, return a list of event terms.
2013  */
2014 int parse_events_terms(struct list_head *terms, const char *str)
2015 {
2016         struct parse_events_state parse_state = {
2017                 .terms  = NULL,
2018                 .stoken = PE_START_TERMS,
2019         };
2020         int ret;
2021
2022         ret = parse_events__scanner(str, &parse_state);
2023
2024         if (!ret) {
2025                 list_splice(parse_state.terms, terms);
2026                 zfree(&parse_state.terms);
2027                 return 0;
2028         }
2029
2030         parse_events_terms__delete(parse_state.terms);
2031         return ret;
2032 }
2033
2034 static int evsel__compute_group_pmu_name(struct evsel *evsel,
2035                                           const struct list_head *head)
2036 {
2037         struct evsel *leader = evsel__leader(evsel);
2038         struct evsel *pos;
2039         const char *group_pmu_name;
2040         struct perf_pmu *pmu = evsel__find_pmu(evsel);
2041
2042         if (!pmu) {
2043                 /*
2044                  * For PERF_TYPE_HARDWARE and PERF_TYPE_HW_CACHE types the PMU
2045                  * is a core PMU, but in heterogeneous systems this is
2046                  * unknown. For now pick the first core PMU.
2047                  */
2048                 pmu = perf_pmus__scan_core(NULL);
2049         }
2050         if (!pmu) {
2051                 pr_debug("No PMU found for '%s'\n", evsel__name(evsel));
2052                 return -EINVAL;
2053         }
2054         group_pmu_name = pmu->name;
2055         /*
2056          * Software events may be in a group with other uncore PMU events. Use
2057          * the pmu_name of the first non-software event to avoid breaking the
2058          * software event out of the group.
2059          *
2060          * Aux event leaders, like intel_pt, expect a group with events from
2061          * other PMUs, so substitute the AUX event's PMU in this case.
2062          */
2063         if (perf_pmu__is_software(pmu) || evsel__is_aux_event(leader)) {
2064                 struct perf_pmu *leader_pmu = evsel__find_pmu(leader);
2065
2066                 if (!leader_pmu) {
2067                         /* As with determining pmu above. */
2068                         leader_pmu = perf_pmus__scan_core(NULL);
2069                 }
2070                 /*
2071                  * Starting with the leader, find the first event with a named
2072                  * non-software PMU. for_each_group_(member|evsel) isn't used as
2073                  * the list isn't yet sorted putting evsel's in the same group
2074                  * together.
2075                  */
2076                 if (leader_pmu && !perf_pmu__is_software(leader_pmu)) {
2077                         group_pmu_name = leader_pmu->name;
2078                 } else if (leader->core.nr_members > 1) {
2079                         list_for_each_entry(pos, head, core.node) {
2080                                 struct perf_pmu *pos_pmu;
2081
2082                                 if (pos == leader || evsel__leader(pos) != leader)
2083                                         continue;
2084                                 pos_pmu = evsel__find_pmu(pos);
2085                                 if (!pos_pmu) {
2086                                         /* As with determining pmu above. */
2087                                         pos_pmu = perf_pmus__scan_core(NULL);
2088                                 }
2089                                 if (pos_pmu && !perf_pmu__is_software(pos_pmu)) {
2090                                         group_pmu_name = pos_pmu->name;
2091                                         break;
2092                                 }
2093                         }
2094                 }
2095         }
2096         /* Assign the actual name taking care that the fake PMU lacks a name. */
2097         evsel->group_pmu_name = strdup(group_pmu_name ?: "fake");
2098         return evsel->group_pmu_name ? 0 : -ENOMEM;
2099 }
2100
2101 __weak int arch_evlist__cmp(const struct evsel *lhs, const struct evsel *rhs)
2102 {
2103         /* Order by insertion index. */
2104         return lhs->core.idx - rhs->core.idx;
2105 }
2106
2107 static int evlist__cmp(void *state, const struct list_head *l, const struct list_head *r)
2108 {
2109         const struct perf_evsel *lhs_core = container_of(l, struct perf_evsel, node);
2110         const struct evsel *lhs = container_of(lhs_core, struct evsel, core);
2111         const struct perf_evsel *rhs_core = container_of(r, struct perf_evsel, node);
2112         const struct evsel *rhs = container_of(rhs_core, struct evsel, core);
2113         int *leader_idx = state;
2114         int lhs_leader_idx = *leader_idx, rhs_leader_idx = *leader_idx, ret;
2115         const char *lhs_pmu_name, *rhs_pmu_name;
2116         bool lhs_has_group = false, rhs_has_group = false;
2117
2118         /*
2119          * First sort by grouping/leader. Read the leader idx only if the evsel
2120          * is part of a group, by default ungrouped events will be sorted
2121          * relative to grouped events based on where the first ungrouped event
2122          * occurs. If both events don't have a group we want to fall-through to
2123          * the arch specific sorting, that can reorder and fix things like
2124          * Intel's topdown events.
2125          */
2126         if (lhs_core->leader != lhs_core || lhs_core->nr_members > 1) {
2127                 lhs_has_group = true;
2128                 lhs_leader_idx = lhs_core->leader->idx;
2129         }
2130         if (rhs_core->leader != rhs_core || rhs_core->nr_members > 1) {
2131                 rhs_has_group = true;
2132                 rhs_leader_idx = rhs_core->leader->idx;
2133         }
2134
2135         if (lhs_leader_idx != rhs_leader_idx)
2136                 return lhs_leader_idx - rhs_leader_idx;
2137
2138         /* Group by PMU if there is a group. Groups can't span PMUs. */
2139         if (lhs_has_group && rhs_has_group) {
2140                 lhs_pmu_name = lhs->group_pmu_name;
2141                 rhs_pmu_name = rhs->group_pmu_name;
2142                 ret = strcmp(lhs_pmu_name, rhs_pmu_name);
2143                 if (ret)
2144                         return ret;
2145         }
2146
2147         /* Architecture specific sorting. */
2148         return arch_evlist__cmp(lhs, rhs);
2149 }
2150
2151 static int parse_events__sort_events_and_fix_groups(struct list_head *list)
2152 {
2153         int idx = 0, unsorted_idx = -1;
2154         struct evsel *pos, *cur_leader = NULL;
2155         struct perf_evsel *cur_leaders_grp = NULL;
2156         bool idx_changed = false;
2157         int orig_num_leaders = 0, num_leaders = 0;
2158         int ret;
2159
2160         /*
2161          * Compute index to insert ungrouped events at. Place them where the
2162          * first ungrouped event appears.
2163          */
2164         list_for_each_entry(pos, list, core.node) {
2165                 const struct evsel *pos_leader = evsel__leader(pos);
2166
2167                 ret = evsel__compute_group_pmu_name(pos, list);
2168                 if (ret)
2169                         return ret;
2170
2171                 if (pos == pos_leader)
2172                         orig_num_leaders++;
2173
2174                 /*
2175                  * Ensure indexes are sequential, in particular for multiple
2176                  * event lists being merged. The indexes are used to detect when
2177                  * the user order is modified.
2178                  */
2179                 pos->core.idx = idx++;
2180
2181                 if (unsorted_idx == -1 && pos == pos_leader && pos->core.nr_members < 2)
2182                         unsorted_idx = pos->core.idx;
2183         }
2184
2185         /* Sort events. */
2186         list_sort(&unsorted_idx, list, evlist__cmp);
2187
2188         /*
2189          * Recompute groups, splitting for PMUs and adding groups for events
2190          * that require them.
2191          */
2192         idx = 0;
2193         list_for_each_entry(pos, list, core.node) {
2194                 const struct evsel *pos_leader = evsel__leader(pos);
2195                 const char *pos_pmu_name = pos->group_pmu_name;
2196                 const char *cur_leader_pmu_name, *pos_leader_pmu_name;
2197                 bool force_grouped = arch_evsel__must_be_in_group(pos);
2198
2199                 /* Reset index and nr_members. */
2200                 if (pos->core.idx != idx)
2201                         idx_changed = true;
2202                 pos->core.idx = idx++;
2203                 pos->core.nr_members = 0;
2204
2205                 /*
2206                  * Set the group leader respecting the given groupings and that
2207                  * groups can't span PMUs.
2208                  */
2209                 if (!cur_leader)
2210                         cur_leader = pos;
2211
2212                 cur_leader_pmu_name = cur_leader->group_pmu_name;
2213                 if ((cur_leaders_grp != pos->core.leader && !force_grouped) ||
2214                     strcmp(cur_leader_pmu_name, pos_pmu_name)) {
2215                         /* Event is for a different group/PMU than last. */
2216                         cur_leader = pos;
2217                         /*
2218                          * Remember the leader's group before it is overwritten,
2219                          * so that later events match as being in the same
2220                          * group.
2221                          */
2222                         cur_leaders_grp = pos->core.leader;
2223                 }
2224                 pos_leader_pmu_name = pos_leader->group_pmu_name;
2225                 if (strcmp(pos_leader_pmu_name, pos_pmu_name) || force_grouped) {
2226                         /*
2227                          * Event's PMU differs from its leader's. Groups can't
2228                          * span PMUs, so update leader from the group/PMU
2229                          * tracker.
2230                          */
2231                         evsel__set_leader(pos, cur_leader);
2232                 }
2233         }
2234         list_for_each_entry(pos, list, core.node) {
2235                 struct evsel *pos_leader = evsel__leader(pos);
2236
2237                 if (pos == pos_leader)
2238                         num_leaders++;
2239                 pos_leader->core.nr_members++;
2240         }
2241         return (idx_changed || num_leaders != orig_num_leaders) ? 1 : 0;
2242 }
2243
2244 int __parse_events(struct evlist *evlist, const char *str, const char *pmu_filter,
2245                    struct parse_events_error *err, struct perf_pmu *fake_pmu,
2246                    bool warn_if_reordered)
2247 {
2248         struct parse_events_state parse_state = {
2249                 .list     = LIST_HEAD_INIT(parse_state.list),
2250                 .idx      = evlist->core.nr_entries,
2251                 .error    = err,
2252                 .evlist   = evlist,
2253                 .stoken   = PE_START_EVENTS,
2254                 .fake_pmu = fake_pmu,
2255                 .pmu_filter = pmu_filter,
2256                 .match_legacy_cache_terms = true,
2257         };
2258         int ret, ret2;
2259
2260         ret = parse_events__scanner(str, &parse_state);
2261
2262         if (!ret && list_empty(&parse_state.list)) {
2263                 WARN_ONCE(true, "WARNING: event parser found nothing\n");
2264                 return -1;
2265         }
2266
2267         ret2 = parse_events__sort_events_and_fix_groups(&parse_state.list);
2268         if (ret2 < 0)
2269                 return ret;
2270
2271         if (ret2 && warn_if_reordered && !parse_state.wild_card_pmus)
2272                 pr_warning("WARNING: events were regrouped to match PMUs\n");
2273
2274         /*
2275          * Add list to the evlist even with errors to allow callers to clean up.
2276          */
2277         evlist__splice_list_tail(evlist, &parse_state.list);
2278
2279         if (!ret) {
2280                 struct evsel *last;
2281
2282                 last = evlist__last(evlist);
2283                 last->cmdline_group_boundary = true;
2284
2285                 return 0;
2286         }
2287
2288         /*
2289          * There are 2 users - builtin-record and builtin-test objects.
2290          * Both call evlist__delete in case of error, so we dont
2291          * need to bother.
2292          */
2293         return ret;
2294 }
2295
2296 int parse_event(struct evlist *evlist, const char *str)
2297 {
2298         struct parse_events_error err;
2299         int ret;
2300
2301         parse_events_error__init(&err);
2302         ret = parse_events(evlist, str, &err);
2303         parse_events_error__exit(&err);
2304         return ret;
2305 }
2306
2307 void parse_events_error__init(struct parse_events_error *err)
2308 {
2309         bzero(err, sizeof(*err));
2310 }
2311
2312 void parse_events_error__exit(struct parse_events_error *err)
2313 {
2314         zfree(&err->str);
2315         zfree(&err->help);
2316         zfree(&err->first_str);
2317         zfree(&err->first_help);
2318 }
2319
2320 void parse_events_error__handle(struct parse_events_error *err, int idx,
2321                                 char *str, char *help)
2322 {
2323         if (WARN(!str || !err, "WARNING: failed to provide error string or struct\n"))
2324                 goto out_free;
2325         switch (err->num_errors) {
2326         case 0:
2327                 err->idx = idx;
2328                 err->str = str;
2329                 err->help = help;
2330                 break;
2331         case 1:
2332                 err->first_idx = err->idx;
2333                 err->idx = idx;
2334                 err->first_str = err->str;
2335                 err->str = str;
2336                 err->first_help = err->help;
2337                 err->help = help;
2338                 break;
2339         default:
2340                 pr_debug("Multiple errors dropping message: %s (%s)\n",
2341                         err->str, err->help);
2342                 free(err->str);
2343                 err->str = str;
2344                 free(err->help);
2345                 err->help = help;
2346                 break;
2347         }
2348         err->num_errors++;
2349         return;
2350
2351 out_free:
2352         free(str);
2353         free(help);
2354 }
2355
2356 #define MAX_WIDTH 1000
2357 static int get_term_width(void)
2358 {
2359         struct winsize ws;
2360
2361         get_term_dimensions(&ws);
2362         return ws.ws_col > MAX_WIDTH ? MAX_WIDTH : ws.ws_col;
2363 }
2364
2365 static void __parse_events_error__print(int err_idx, const char *err_str,
2366                                         const char *err_help, const char *event)
2367 {
2368         const char *str = "invalid or unsupported event: ";
2369         char _buf[MAX_WIDTH];
2370         char *buf = (char *) event;
2371         int idx = 0;
2372         if (err_str) {
2373                 /* -2 for extra '' in the final fprintf */
2374                 int width       = get_term_width() - 2;
2375                 int len_event   = strlen(event);
2376                 int len_str, max_len, cut = 0;
2377
2378                 /*
2379                  * Maximum error index indent, we will cut
2380                  * the event string if it's bigger.
2381                  */
2382                 int max_err_idx = 13;
2383
2384                 /*
2385                  * Let's be specific with the message when
2386                  * we have the precise error.
2387                  */
2388                 str     = "event syntax error: ";
2389                 len_str = strlen(str);
2390                 max_len = width - len_str;
2391
2392                 buf = _buf;
2393
2394                 /* We're cutting from the beginning. */
2395                 if (err_idx > max_err_idx)
2396                         cut = err_idx - max_err_idx;
2397
2398                 strncpy(buf, event + cut, max_len);
2399
2400                 /* Mark cut parts with '..' on both sides. */
2401                 if (cut)
2402                         buf[0] = buf[1] = '.';
2403
2404                 if ((len_event - cut) > max_len) {
2405                         buf[max_len - 1] = buf[max_len - 2] = '.';
2406                         buf[max_len] = 0;
2407                 }
2408
2409                 idx = len_str + err_idx - cut;
2410         }
2411
2412         fprintf(stderr, "%s'%s'\n", str, buf);
2413         if (idx) {
2414                 fprintf(stderr, "%*s\\___ %s\n", idx + 1, "", err_str);
2415                 if (err_help)
2416                         fprintf(stderr, "\n%s\n", err_help);
2417         }
2418 }
2419
2420 void parse_events_error__print(struct parse_events_error *err,
2421                                const char *event)
2422 {
2423         if (!err->num_errors)
2424                 return;
2425
2426         __parse_events_error__print(err->idx, err->str, err->help, event);
2427
2428         if (err->num_errors > 1) {
2429                 fputs("\nInitial error:\n", stderr);
2430                 __parse_events_error__print(err->first_idx, err->first_str,
2431                                         err->first_help, event);
2432         }
2433 }
2434
2435 #undef MAX_WIDTH
2436
2437 int parse_events_option(const struct option *opt, const char *str,
2438                         int unset __maybe_unused)
2439 {
2440         struct parse_events_option_args *args = opt->value;
2441         struct parse_events_error err;
2442         int ret;
2443
2444         parse_events_error__init(&err);
2445         ret = __parse_events(*args->evlistp, str, args->pmu_filter, &err,
2446                              /*fake_pmu=*/NULL, /*warn_if_reordered=*/true);
2447
2448         if (ret) {
2449                 parse_events_error__print(&err, str);
2450                 fprintf(stderr, "Run 'perf list' for a list of valid events\n");
2451         }
2452         parse_events_error__exit(&err);
2453
2454         return ret;
2455 }
2456
2457 int parse_events_option_new_evlist(const struct option *opt, const char *str, int unset)
2458 {
2459         struct parse_events_option_args *args = opt->value;
2460         int ret;
2461
2462         if (*args->evlistp == NULL) {
2463                 *args->evlistp = evlist__new();
2464
2465                 if (*args->evlistp == NULL) {
2466                         fprintf(stderr, "Not enough memory to create evlist\n");
2467                         return -1;
2468                 }
2469         }
2470         ret = parse_events_option(opt, str, unset);
2471         if (ret) {
2472                 evlist__delete(*args->evlistp);
2473                 *args->evlistp = NULL;
2474         }
2475
2476         return ret;
2477 }
2478
2479 static int
2480 foreach_evsel_in_last_glob(struct evlist *evlist,
2481                            int (*func)(struct evsel *evsel,
2482                                        const void *arg),
2483                            const void *arg)
2484 {
2485         struct evsel *last = NULL;
2486         int err;
2487
2488         /*
2489          * Don't return when list_empty, give func a chance to report
2490          * error when it found last == NULL.
2491          *
2492          * So no need to WARN here, let *func do this.
2493          */
2494         if (evlist->core.nr_entries > 0)
2495                 last = evlist__last(evlist);
2496
2497         do {
2498                 err = (*func)(last, arg);
2499                 if (err)
2500                         return -1;
2501                 if (!last)
2502                         return 0;
2503
2504                 if (last->core.node.prev == &evlist->core.entries)
2505                         return 0;
2506                 last = list_entry(last->core.node.prev, struct evsel, core.node);
2507         } while (!last->cmdline_group_boundary);
2508
2509         return 0;
2510 }
2511
2512 static int set_filter(struct evsel *evsel, const void *arg)
2513 {
2514         const char *str = arg;
2515         bool found = false;
2516         int nr_addr_filters = 0;
2517         struct perf_pmu *pmu = NULL;
2518
2519         if (evsel == NULL) {
2520                 fprintf(stderr,
2521                         "--filter option should follow a -e tracepoint or HW tracer option\n");
2522                 return -1;
2523         }
2524
2525         if (evsel->core.attr.type == PERF_TYPE_TRACEPOINT) {
2526                 if (evsel__append_tp_filter(evsel, str) < 0) {
2527                         fprintf(stderr,
2528                                 "not enough memory to hold filter string\n");
2529                         return -1;
2530                 }
2531
2532                 return 0;
2533         }
2534
2535         while ((pmu = perf_pmus__scan(pmu)) != NULL)
2536                 if (pmu->type == evsel->core.attr.type) {
2537                         found = true;
2538                         break;
2539                 }
2540
2541         if (found)
2542                 perf_pmu__scan_file(pmu, "nr_addr_filters",
2543                                     "%d", &nr_addr_filters);
2544
2545         if (!nr_addr_filters)
2546                 return perf_bpf_filter__parse(&evsel->bpf_filters, str);
2547
2548         if (evsel__append_addr_filter(evsel, str) < 0) {
2549                 fprintf(stderr,
2550                         "not enough memory to hold filter string\n");
2551                 return -1;
2552         }
2553
2554         return 0;
2555 }
2556
2557 int parse_filter(const struct option *opt, const char *str,
2558                  int unset __maybe_unused)
2559 {
2560         struct evlist *evlist = *(struct evlist **)opt->value;
2561
2562         return foreach_evsel_in_last_glob(evlist, set_filter,
2563                                           (const void *)str);
2564 }
2565
2566 static int add_exclude_perf_filter(struct evsel *evsel,
2567                                    const void *arg __maybe_unused)
2568 {
2569         char new_filter[64];
2570
2571         if (evsel == NULL || evsel->core.attr.type != PERF_TYPE_TRACEPOINT) {
2572                 fprintf(stderr,
2573                         "--exclude-perf option should follow a -e tracepoint option\n");
2574                 return -1;
2575         }
2576
2577         snprintf(new_filter, sizeof(new_filter), "common_pid != %d", getpid());
2578
2579         if (evsel__append_tp_filter(evsel, new_filter) < 0) {
2580                 fprintf(stderr,
2581                         "not enough memory to hold filter string\n");
2582                 return -1;
2583         }
2584
2585         return 0;
2586 }
2587
2588 int exclude_perf(const struct option *opt,
2589                  const char *arg __maybe_unused,
2590                  int unset __maybe_unused)
2591 {
2592         struct evlist *evlist = *(struct evlist **)opt->value;
2593
2594         return foreach_evsel_in_last_glob(evlist, add_exclude_perf_filter,
2595                                           NULL);
2596 }
2597
2598 int parse_events__is_hardcoded_term(struct parse_events_term *term)
2599 {
2600         return term->type_term != PARSE_EVENTS__TERM_TYPE_USER;
2601 }
2602
2603 static int new_term(struct parse_events_term **_term,
2604                     struct parse_events_term *temp,
2605                     char *str, u64 num)
2606 {
2607         struct parse_events_term *term;
2608
2609         term = malloc(sizeof(*term));
2610         if (!term)
2611                 return -ENOMEM;
2612
2613         *term = *temp;
2614         INIT_LIST_HEAD(&term->list);
2615         term->weak = false;
2616
2617         switch (term->type_val) {
2618         case PARSE_EVENTS__TERM_TYPE_NUM:
2619                 term->val.num = num;
2620                 break;
2621         case PARSE_EVENTS__TERM_TYPE_STR:
2622                 term->val.str = str;
2623                 break;
2624         default:
2625                 free(term);
2626                 return -EINVAL;
2627         }
2628
2629         *_term = term;
2630         return 0;
2631 }
2632
2633 int parse_events_term__num(struct parse_events_term **term,
2634                            int type_term, char *config, u64 num,
2635                            bool no_value,
2636                            void *loc_term_, void *loc_val_)
2637 {
2638         YYLTYPE *loc_term = loc_term_;
2639         YYLTYPE *loc_val = loc_val_;
2640
2641         struct parse_events_term temp = {
2642                 .type_val  = PARSE_EVENTS__TERM_TYPE_NUM,
2643                 .type_term = type_term,
2644                 .config    = config ? : strdup(config_term_names[type_term]),
2645                 .no_value  = no_value,
2646                 .err_term  = loc_term ? loc_term->first_column : 0,
2647                 .err_val   = loc_val  ? loc_val->first_column  : 0,
2648         };
2649
2650         return new_term(term, &temp, NULL, num);
2651 }
2652
2653 int parse_events_term__str(struct parse_events_term **term,
2654                            int type_term, char *config, char *str,
2655                            void *loc_term_, void *loc_val_)
2656 {
2657         YYLTYPE *loc_term = loc_term_;
2658         YYLTYPE *loc_val = loc_val_;
2659
2660         struct parse_events_term temp = {
2661                 .type_val  = PARSE_EVENTS__TERM_TYPE_STR,
2662                 .type_term = type_term,
2663                 .config    = config,
2664                 .err_term  = loc_term ? loc_term->first_column : 0,
2665                 .err_val   = loc_val  ? loc_val->first_column  : 0,
2666         };
2667
2668         return new_term(term, &temp, str, 0);
2669 }
2670
2671 int parse_events_term__term(struct parse_events_term **term,
2672                             int term_lhs, int term_rhs,
2673                             void *loc_term, void *loc_val)
2674 {
2675         return parse_events_term__str(term, term_lhs, NULL,
2676                                       strdup(config_term_names[term_rhs]),
2677                                       loc_term, loc_val);
2678 }
2679
2680 int parse_events_term__clone(struct parse_events_term **new,
2681                              struct parse_events_term *term)
2682 {
2683         char *str;
2684         struct parse_events_term temp = {
2685                 .type_val  = term->type_val,
2686                 .type_term = term->type_term,
2687                 .config    = NULL,
2688                 .err_term  = term->err_term,
2689                 .err_val   = term->err_val,
2690         };
2691
2692         if (term->config) {
2693                 temp.config = strdup(term->config);
2694                 if (!temp.config)
2695                         return -ENOMEM;
2696         }
2697         if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM)
2698                 return new_term(new, &temp, NULL, term->val.num);
2699
2700         str = strdup(term->val.str);
2701         if (!str)
2702                 return -ENOMEM;
2703         return new_term(new, &temp, str, 0);
2704 }
2705
2706 void parse_events_term__delete(struct parse_events_term *term)
2707 {
2708         if (term->array.nr_ranges)
2709                 zfree(&term->array.ranges);
2710
2711         if (term->type_val != PARSE_EVENTS__TERM_TYPE_NUM)
2712                 zfree(&term->val.str);
2713
2714         zfree(&term->config);
2715         free(term);
2716 }
2717
2718 int parse_events_copy_term_list(struct list_head *old,
2719                                  struct list_head **new)
2720 {
2721         struct parse_events_term *term, *n;
2722         int ret;
2723
2724         if (!old) {
2725                 *new = NULL;
2726                 return 0;
2727         }
2728
2729         *new = malloc(sizeof(struct list_head));
2730         if (!*new)
2731                 return -ENOMEM;
2732         INIT_LIST_HEAD(*new);
2733
2734         list_for_each_entry (term, old, list) {
2735                 ret = parse_events_term__clone(&n, term);
2736                 if (ret)
2737                         return ret;
2738                 list_add_tail(&n->list, *new);
2739         }
2740         return 0;
2741 }
2742
2743 void parse_events_terms__purge(struct list_head *terms)
2744 {
2745         struct parse_events_term *term, *h;
2746
2747         list_for_each_entry_safe(term, h, terms, list) {
2748                 list_del_init(&term->list);
2749                 parse_events_term__delete(term);
2750         }
2751 }
2752
2753 void parse_events_terms__delete(struct list_head *terms)
2754 {
2755         if (!terms)
2756                 return;
2757         parse_events_terms__purge(terms);
2758         free(terms);
2759 }
2760
2761 void parse_events__clear_array(struct parse_events_array *a)
2762 {
2763         zfree(&a->ranges);
2764 }
2765
2766 void parse_events_evlist_error(struct parse_events_state *parse_state,
2767                                int idx, const char *str)
2768 {
2769         if (!parse_state->error)
2770                 return;
2771
2772         parse_events_error__handle(parse_state->error, idx, strdup(str), NULL);
2773 }
2774
2775 static void config_terms_list(char *buf, size_t buf_sz)
2776 {
2777         int i;
2778         bool first = true;
2779
2780         buf[0] = '\0';
2781         for (i = 0; i < __PARSE_EVENTS__TERM_TYPE_NR; i++) {
2782                 const char *name = config_term_names[i];
2783
2784                 if (!config_term_avail(i, NULL))
2785                         continue;
2786                 if (!name)
2787                         continue;
2788                 if (name[0] == '<')
2789                         continue;
2790
2791                 if (strlen(buf) + strlen(name) + 2 >= buf_sz)
2792                         return;
2793
2794                 if (!first)
2795                         strcat(buf, ",");
2796                 else
2797                         first = false;
2798                 strcat(buf, name);
2799         }
2800 }
2801
2802 /*
2803  * Return string contains valid config terms of an event.
2804  * @additional_terms: For terms such as PMU sysfs terms.
2805  */
2806 char *parse_events_formats_error_string(char *additional_terms)
2807 {
2808         char *str;
2809         /* "no-overwrite" is the longest name */
2810         char static_terms[__PARSE_EVENTS__TERM_TYPE_NR *
2811                           (sizeof("no-overwrite") - 1)];
2812
2813         config_terms_list(static_terms, sizeof(static_terms));
2814         /* valid terms */
2815         if (additional_terms) {
2816                 if (asprintf(&str, "valid terms: %s,%s",
2817                              additional_terms, static_terms) < 0)
2818                         goto fail;
2819         } else {
2820                 if (asprintf(&str, "valid terms: %s", static_terms) < 0)
2821                         goto fail;
2822         }
2823         return str;
2824
2825 fail:
2826         return NULL;
2827 }