tools/perf/util/pmu.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/list.h>
   3 #include <linux/compiler.h>
   4 #include <linux/string.h>
   5 #include <linux/zalloc.h>
   6 #include <linux/ctype.h>
   7 #include <sys/types.h>
   8 #include <fcntl.h>
   9 #include <sys/stat.h>
  10 #include <unistd.h>
  11 #include <stdio.h>
  12 #include <stdbool.h>
  13 #include <dirent.h>
  14 #include <api/fs/fs.h>
  15 #include <locale.h>
  16 #include <fnmatch.h>
  17 #include <math.h>
  18 #include "debug.h"
  19 #include "evsel.h"
  20 #include "pmu.h"
  21 #include "pmus.h"
  22 #include <util/pmu-bison.h>
  23 #include <util/pmu-flex.h>
  24 #include "parse-events.h"
  25 #include "print-events.h"
  26 #include "header.h"
  27 #include "string2.h"
  28 #include "strbuf.h"
  29 #include "fncache.h"
  30 #include "util/evsel_config.h"
  31
  32 struct perf_pmu perf_pmu__fake = {
  33         .name = "fake",
  34 };
  35
  36 #define UNIT_MAX_LEN    31 /* max length for event unit name */
  37
  38 /**
  39  * struct perf_pmu_alias - An event either read from sysfs or builtin in
  40  * pmu-events.c, created by parsing the pmu-events json files.
  41  */
  42 struct perf_pmu_alias {
  43         /** @name: Name of the event like "mem-loads". */
  44         char *name;
  45         /** @desc: Optional short description of the event. */
  46         char *desc;
  47         /** @long_desc: Optional long description. */
  48         char *long_desc;
  49         /**
  50          * @topic: Optional topic such as cache or pipeline, particularly for
  51          * json events.
  52          */
  53         char *topic;
  54         /** @terms: Owned list of the original parsed parameters. */
  55         struct list_head terms;
  56         /** @list: List element of struct perf_pmu aliases. */
  57         struct list_head list;
  58         /**
  59          * @pmu_name: The name copied from the json struct pmu_event. This can
  60          * differ from the PMU name as it won't have suffixes.
  61          */
  62         char *pmu_name;
  63         /** @unit: Units for the event, such as bytes or cache lines. */
  64         char unit[UNIT_MAX_LEN+1];
  65         /** @scale: Value to scale read counter values by. */
  66         double scale;
  67         /**
  68          * @per_pkg: Does the file
  69          * <sysfs>/bus/event_source/devices/<pmu_name>/events/<name>.per-pkg or
  70          * equivalent json value exist and have the value 1.
  71          */
  72         bool per_pkg;
  73         /**
  74          * @snapshot: Does the file
  75          * <sysfs>/bus/event_source/devices/<pmu_name>/events/<name>.snapshot
  76          * exist and have the value 1.
  77          */
  78         bool snapshot;
  79         /**
  80          * @deprecated: Is the event hidden and so not shown in perf list by
  81          * default.
  82          */
  83         bool deprecated;
  84         /** @from_sysfs: Was the alias from sysfs or a json event? */
  85         bool from_sysfs;
  86         /** @info_loaded: Have the scale, unit and other values been read from disk? */
  87         bool info_loaded;
  88 };
  89
  90 /**
  91  * struct perf_pmu_format - Values from a format file read from
  92  * <sysfs>/devices/cpu/format/ held in struct perf_pmu.
  93  *
  94  * For example, the contents of <sysfs>/devices/cpu/format/event may be
  95  * "config:0-7" and will be represented here as name="event",
  96  * value=PERF_PMU_FORMAT_VALUE_CONFIG and bits 0 to 7 will be set.
  97  */
  98 struct perf_pmu_format {
  99         /** @list: Element on list within struct perf_pmu. */
 100         struct list_head list;
 101         /** @bits: Which config bits are set by this format value. */
 102         DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS);
 103         /** @name: The modifier/file name. */
 104         char *name;
 105         /**
 106          * @value : Which config value the format relates to. Supported values
 107          * are from PERF_PMU_FORMAT_VALUE_CONFIG to
 108          * PERF_PMU_FORMAT_VALUE_CONFIG_END.
 109          */
 110         u16 value;
 111         /** @loaded: Has the contents been loaded/parsed. */
 112         bool loaded;
 113 };
 114
 115 static int pmu_aliases_parse(struct perf_pmu *pmu);
 116
 117 static struct perf_pmu_format *perf_pmu__new_format(struct list_head *list, char *name)
 118 {
 119         struct perf_pmu_format *format;
 120
 121         format = zalloc(sizeof(*format));
 122         if (!format)
 123                 return NULL;
 124
 125         format->name = strdup(name);
 126         if (!format->name) {
 127                 free(format);
 128                 return NULL;
 129         }
 130         list_add_tail(&format->list, list);
 131         return format;
 132 }
 133
 134 /* Called at the end of parsing a format. */
 135 void perf_pmu_format__set_value(void *vformat, int config, unsigned long *bits)
 136 {
 137         struct perf_pmu_format *format = vformat;
 138
 139         format->value = config;
 140         memcpy(format->bits, bits, sizeof(format->bits));
 141 }
 142
 143 static void __perf_pmu_format__load(struct perf_pmu_format *format, FILE *file)
 144 {
 145         void *scanner;
 146         int ret;
 147
 148         ret = perf_pmu_lex_init(&scanner);
 149         if (ret)
 150                 return;
 151
 152         perf_pmu_set_in(file, scanner);
 153         ret = perf_pmu_parse(format, scanner);
 154         perf_pmu_lex_destroy(scanner);
 155         format->loaded = true;
 156 }
 157
 158 static void perf_pmu_format__load(struct perf_pmu *pmu, struct perf_pmu_format *format)
 159 {
 160         char path[PATH_MAX];
 161         FILE *file = NULL;
 162
 163         if (format->loaded)
 164                 return;
 165
 166         if (!perf_pmu__pathname_scnprintf(path, sizeof(path), pmu->name, "format"))
 167                 return;
 168
 169         assert(strlen(path) + strlen(format->name) + 2 < sizeof(path));
 170         strcat(path, "/");
 171         strcat(path, format->name);
 172
 173         file = fopen(path, "r");
 174         if (!file)
 175                 return;
 176         __perf_pmu_format__load(format, file);
 177         fclose(file);
 178 }
 179
 180 /*
 181  * Parse & process all the sysfs attributes located under
 182  * the directory specified in 'dir' parameter.
 183  */
 184 int perf_pmu__format_parse(struct perf_pmu *pmu, int dirfd, bool eager_load)
 185 {
 186         struct dirent *evt_ent;
 187         DIR *format_dir;
 188         int ret = 0;
 189
 190         format_dir = fdopendir(dirfd);
 191         if (!format_dir)
 192                 return -EINVAL;
 193
 194         while ((evt_ent = readdir(format_dir)) != NULL) {
 195                 struct perf_pmu_format *format;
 196                 char *name = evt_ent->d_name;
 197
 198                 if (!strcmp(name, ".") || !strcmp(name, ".."))
 199                         continue;
 200
 201                 format = perf_pmu__new_format(&pmu->format, name);
 202                 if (!format) {
 203                         ret = -ENOMEM;
 204                         break;
 205                 }
 206
 207                 if (eager_load) {
 208                         FILE *file;
 209                         int fd = openat(dirfd, name, O_RDONLY);
 210
 211                         if (fd < 0) {
 212                                 ret = -errno;
 213                                 break;
 214                         }
 215                         file = fdopen(fd, "r");
 216                         if (!file) {
 217                                 close(fd);
 218                                 break;
 219                         }
 220                         __perf_pmu_format__load(format, file);
 221                         fclose(file);
 222                 }
 223         }
 224
 225         closedir(format_dir);
 226         return ret;
 227 }
 228
 229 /*
 230  * Reading/parsing the default pmu format definition, which should be
 231  * located at:
 232  * /sys/bus/event_source/devices/<dev>/format as sysfs group attributes.
 233  */
 234 static int pmu_format(struct perf_pmu *pmu, int dirfd, const char *name)
 235 {
 236         int fd;
 237
 238         fd = perf_pmu__pathname_fd(dirfd, name, "format", O_DIRECTORY);
 239         if (fd < 0)
 240                 return 0;
 241
 242         /* it'll close the fd */
 243         if (perf_pmu__format_parse(pmu, fd, /*eager_load=*/false))
 244                 return -1;
 245
 246         return 0;
 247 }
 248
 249 int perf_pmu__convert_scale(const char *scale, char **end, double *sval)
 250 {
 251         char *lc;
 252         int ret = 0;
 253
 254         /*
 255          * save current locale
 256          */
 257         lc = setlocale(LC_NUMERIC, NULL);
 258
 259         /*
 260          * The lc string may be allocated in static storage,
 261          * so get a dynamic copy to make it survive setlocale
 262          * call below.
 263          */
 264         lc = strdup(lc);
 265         if (!lc) {
 266                 ret = -ENOMEM;
 267                 goto out;
 268         }
 269
 270         /*
 271          * force to C locale to ensure kernel
 272          * scale string is converted correctly.
 273          * kernel uses default C locale.
 274          */
 275         setlocale(LC_NUMERIC, "C");
 276
 277         *sval = strtod(scale, end);
 278
 279 out:
 280         /* restore locale */
 281         setlocale(LC_NUMERIC, lc);
 282         free(lc);
 283         return ret;
 284 }
 285
 286 static int perf_pmu__parse_scale(struct perf_pmu *pmu, struct perf_pmu_alias *alias)
 287 {
 288         struct stat st;
 289         ssize_t sret;
 290         size_t len;
 291         char scale[128];
 292         int fd, ret = -1;
 293         char path[PATH_MAX];
 294
 295         len = perf_pmu__event_source_devices_scnprintf(path, sizeof(path));
 296         if (!len)
 297                 return 0;
 298         scnprintf(path + len, sizeof(path) - len, "%s/%s.scale", pmu->name, alias->name);
 299
 300         fd = open(path, O_RDONLY);
 301         if (fd == -1)
 302                 return -1;
 303
 304         if (fstat(fd, &st) < 0)
 305                 goto error;
 306
 307         sret = read(fd, scale, sizeof(scale)-1);
 308         if (sret < 0)
 309                 goto error;
 310
 311         if (scale[sret - 1] == '\n')
 312                 scale[sret - 1] = '\0';
 313         else
 314                 scale[sret] = '\0';
 315
 316         ret = perf_pmu__convert_scale(scale, NULL, &alias->scale);
 317 error:
 318         close(fd);
 319         return ret;
 320 }
 321
 322 static int perf_pmu__parse_unit(struct perf_pmu *pmu, struct perf_pmu_alias *alias)
 323 {
 324         char path[PATH_MAX];
 325         size_t len;
 326         ssize_t sret;
 327         int fd;
 328
 329
 330         len = perf_pmu__event_source_devices_scnprintf(path, sizeof(path));
 331         if (!len)
 332                 return 0;
 333         scnprintf(path + len, sizeof(path) - len, "%s/%s.unit", pmu->name, alias->name);
 334
 335         fd = open(path, O_RDONLY);
 336         if (fd == -1)
 337                 return -1;
 338
 339         sret = read(fd, alias->unit, UNIT_MAX_LEN);
 340         if (sret < 0)
 341                 goto error;
 342
 343         close(fd);
 344
 345         if (alias->unit[sret - 1] == '\n')
 346                 alias->unit[sret - 1] = '\0';
 347         else
 348                 alias->unit[sret] = '\0';
 349
 350         return 0;
 351 error:
 352         close(fd);
 353         alias->unit[0] = '\0';
 354         return -1;
 355 }
 356
 357 static int
 358 perf_pmu__parse_per_pkg(struct perf_pmu *pmu, struct perf_pmu_alias *alias)
 359 {
 360         char path[PATH_MAX];
 361         size_t len;
 362         int fd;
 363
 364         len = perf_pmu__event_source_devices_scnprintf(path, sizeof(path));
 365         if (!len)
 366                 return 0;
 367         scnprintf(path + len, sizeof(path) - len, "%s/%s.per-pkg", pmu->name, alias->name);
 368
 369         fd = open(path, O_RDONLY);
 370         if (fd == -1)
 371                 return -1;
 372
 373         close(fd);
 374
 375         alias->per_pkg = true;
 376         return 0;
 377 }
 378
 379 static int perf_pmu__parse_snapshot(struct perf_pmu *pmu, struct perf_pmu_alias *alias)
 380 {
 381         char path[PATH_MAX];
 382         size_t len;
 383         int fd;
 384
 385         len = perf_pmu__event_source_devices_scnprintf(path, sizeof(path));
 386         if (!len)
 387                 return 0;
 388         scnprintf(path + len, sizeof(path) - len, "%s/%s.snapshot", pmu->name, alias->name);
 389
 390         fd = open(path, O_RDONLY);
 391         if (fd == -1)
 392                 return -1;
 393
 394         alias->snapshot = true;
 395         close(fd);
 396         return 0;
 397 }
 398
 399 /* Delete an alias entry. */
 400 static void perf_pmu_free_alias(struct perf_pmu_alias *newalias)
 401 {
 402         zfree(&newalias->name);
 403         zfree(&newalias->desc);
 404         zfree(&newalias->long_desc);
 405         zfree(&newalias->topic);
 406         zfree(&newalias->pmu_name);
 407         parse_events_terms__purge(&newalias->terms);
 408         free(newalias);
 409 }
 410
 411 static void perf_pmu__del_aliases(struct perf_pmu *pmu)
 412 {
 413         struct perf_pmu_alias *alias, *tmp;
 414
 415         list_for_each_entry_safe(alias, tmp, &pmu->aliases, list) {
 416                 list_del(&alias->list);
 417                 perf_pmu_free_alias(alias);
 418         }
 419 }
 420
 421 static struct perf_pmu_alias *perf_pmu__find_alias(struct perf_pmu *pmu,
 422                                                    const char *name,
 423                                                    bool load)
 424 {
 425         struct perf_pmu_alias *alias;
 426
 427         if (load && !pmu->sysfs_aliases_loaded)
 428                 pmu_aliases_parse(pmu);
 429
 430         list_for_each_entry(alias, &pmu->aliases, list) {
 431                 if (!strcasecmp(alias->name, name))
 432                         return alias;
 433         }
 434         return NULL;
 435 }
 436
 437 static bool assign_str(const char *name, const char *field, char **old_str,
 438                                 const char *new_str)
 439 {
 440         if (!*old_str && new_str) {
 441                 *old_str = strdup(new_str);
 442                 return true;
 443         }
 444
 445         if (!new_str || !strcasecmp(*old_str, new_str))
 446                 return false; /* Nothing to update. */
 447
 448         pr_debug("alias %s differs in field '%s' ('%s' != '%s')\n",
 449                 name, field, *old_str, new_str);
 450         zfree(old_str);
 451         *old_str = strdup(new_str);
 452         return true;
 453 }
 454
 455 static void read_alias_info(struct perf_pmu *pmu, struct perf_pmu_alias *alias)
 456 {
 457         if (!alias->from_sysfs || alias->info_loaded)
 458                 return;
 459
 460         /*
 461          * load unit name and scale if available
 462          */
 463         perf_pmu__parse_unit(pmu, alias);
 464         perf_pmu__parse_scale(pmu, alias);
 465         perf_pmu__parse_per_pkg(pmu, alias);
 466         perf_pmu__parse_snapshot(pmu, alias);
 467 }
 468
 469 struct update_alias_data {
 470         struct perf_pmu *pmu;
 471         struct perf_pmu_alias *alias;
 472 };
 473
 474 static int update_alias(const struct pmu_event *pe,
 475                         const struct pmu_events_table *table __maybe_unused,
 476                         void *vdata)
 477 {
 478         struct update_alias_data *data = vdata;
 479         int ret = 0;
 480
 481         read_alias_info(data->pmu, data->alias);
 482         assign_str(pe->name, "desc", &data->alias->desc, pe->desc);
 483         assign_str(pe->name, "long_desc", &data->alias->long_desc, pe->long_desc);
 484         assign_str(pe->name, "topic", &data->alias->topic, pe->topic);
 485         data->alias->per_pkg = pe->perpkg;
 486         if (pe->event) {
 487                 parse_events_terms__purge(&data->alias->terms);
 488                 ret = parse_events_terms(&data->alias->terms, pe->event, /*input=*/NULL);
 489         }
 490         if (!ret && pe->unit) {
 491                 char *unit;
 492
 493                 ret = perf_pmu__convert_scale(pe->unit, &unit, &data->alias->scale);
 494                 if (!ret)
 495                         snprintf(data->alias->unit, sizeof(data->alias->unit), "%s", unit);
 496         }
 497         return ret;
 498 }
 499
 500 static int perf_pmu__new_alias(struct perf_pmu *pmu, const char *name,
 501                                 const char *desc, const char *val, FILE *val_fd,
 502                                 const struct pmu_event *pe)
 503 {
 504         struct perf_pmu_alias *alias;
 505         int ret;
 506         const char *long_desc = NULL, *topic = NULL, *unit = NULL, *pmu_name = NULL;
 507         bool deprecated = false, perpkg = false;
 508
 509         if (perf_pmu__find_alias(pmu, name, /*load=*/ false)) {
 510                 /* Alias was already created/loaded. */
 511                 return 0;
 512         }
 513
 514         if (pe) {
 515                 long_desc = pe->long_desc;
 516                 topic = pe->topic;
 517                 unit = pe->unit;
 518                 perpkg = pe->perpkg;
 519                 deprecated = pe->deprecated;
 520                 pmu_name = pe->pmu;
 521         }
 522
 523         alias = malloc(sizeof(*alias));
 524         if (!alias)
 525                 return -ENOMEM;
 526
 527         INIT_LIST_HEAD(&alias->terms);
 528         alias->scale = 1.0;
 529         alias->unit[0] = '\0';
 530         alias->per_pkg = perpkg;
 531         alias->snapshot = false;
 532         alias->deprecated = deprecated;
 533
 534         ret = parse_events_terms(&alias->terms, val, val_fd);
 535         if (ret) {
 536                 pr_err("Cannot parse alias %s: %d\n", val, ret);
 537                 free(alias);
 538                 return ret;
 539         }
 540
 541         alias->name = strdup(name);
 542         alias->desc = desc ? strdup(desc) : NULL;
 543         alias->long_desc = long_desc ? strdup(long_desc) :
 544                                 desc ? strdup(desc) : NULL;
 545         alias->topic = topic ? strdup(topic) : NULL;
 546         alias->pmu_name = pmu_name ? strdup(pmu_name) : NULL;
 547         if (unit) {
 548                 if (perf_pmu__convert_scale(unit, (char **)&unit, &alias->scale) < 0) {
 549                         perf_pmu_free_alias(alias);
 550                         return -1;
 551                 }
 552                 snprintf(alias->unit, sizeof(alias->unit), "%s", unit);
 553         }
 554         if (!pe) {
 555                 /* Update an event from sysfs with json data. */
 556                 struct update_alias_data data = {
 557                         .pmu = pmu,
 558                         .alias = alias,
 559                 };
 560
 561                 alias->from_sysfs = true;
 562                 if (pmu->events_table) {
 563                         if (pmu_events_table__find_event(pmu->events_table, pmu, name,
 564                                                          update_alias, &data) == 0)
 565                                 pmu->loaded_json_aliases++;
 566                 }
 567         }
 568
 569         if (!pe)
 570                 pmu->sysfs_aliases++;
 571         else
 572                 pmu->loaded_json_aliases++;
 573         list_add_tail(&alias->list, &pmu->aliases);
 574         return 0;
 575 }
 576
 577 static inline bool pmu_alias_info_file(char *name)
 578 {
 579         size_t len;
 580
 581         len = strlen(name);
 582         if (len > 5 && !strcmp(name + len - 5, ".unit"))
 583                 return true;
 584         if (len > 6 && !strcmp(name + len - 6, ".scale"))
 585                 return true;
 586         if (len > 8 && !strcmp(name + len - 8, ".per-pkg"))
 587                 return true;
 588         if (len > 9 && !strcmp(name + len - 9, ".snapshot"))
 589                 return true;
 590
 591         return false;
 592 }
 593
 594 /*
 595  * Reading the pmu event aliases definition, which should be located at:
 596  * /sys/bus/event_source/devices/<dev>/events as sysfs group attributes.
 597  */
 598 static int pmu_aliases_parse(struct perf_pmu *pmu)
 599 {
 600         char path[PATH_MAX];
 601         struct dirent *evt_ent;
 602         DIR *event_dir;
 603         size_t len;
 604         int fd, dir_fd;
 605
 606         len = perf_pmu__event_source_devices_scnprintf(path, sizeof(path));
 607         if (!len)
 608                 return 0;
 609         scnprintf(path + len, sizeof(path) - len, "%s/events", pmu->name);
 610
 611         dir_fd = open(path, O_DIRECTORY);
 612         if (dir_fd == -1) {
 613                 pmu->sysfs_aliases_loaded = true;
 614                 return 0;
 615         }
 616
 617         event_dir = fdopendir(dir_fd);
 618         if (!event_dir){
 619                 close (dir_fd);
 620                 return -EINVAL;
 621         }
 622
 623         while ((evt_ent = readdir(event_dir))) {
 624                 char *name = evt_ent->d_name;
 625                 FILE *file;
 626
 627                 if (!strcmp(name, ".") || !strcmp(name, ".."))
 628                         continue;
 629
 630                 /*
 631                  * skip info files parsed in perf_pmu__new_alias()
 632                  */
 633                 if (pmu_alias_info_file(name))
 634                         continue;
 635
 636                 fd = openat(dir_fd, name, O_RDONLY);
 637                 if (fd == -1) {
 638                         pr_debug("Cannot open %s\n", name);
 639                         continue;
 640                 }
 641                 file = fdopen(fd, "r");
 642                 if (!file) {
 643                         close(fd);
 644                         continue;
 645                 }
 646
 647                 if (perf_pmu__new_alias(pmu, name, /*desc=*/ NULL,
 648                                         /*val=*/ NULL, file, /*pe=*/ NULL) < 0)
 649                         pr_debug("Cannot set up %s\n", name);
 650                 fclose(file);
 651         }
 652
 653         closedir(event_dir);
 654         close (dir_fd);
 655         pmu->sysfs_aliases_loaded = true;
 656         return 0;
 657 }
 658
 659 static int pmu_alias_terms(struct perf_pmu_alias *alias,
 660                            struct list_head *terms)
 661 {
 662         struct parse_events_term *term, *cloned;
 663         LIST_HEAD(list);
 664         int ret;
 665
 666         list_for_each_entry(term, &alias->terms, list) {
 667                 ret = parse_events_term__clone(&cloned, term);
 668                 if (ret) {
 669                         parse_events_terms__purge(&list);
 670                         return ret;
 671                 }
 672                 /*
 673                  * Weak terms don't override command line options,
 674                  * which we don't want for implicit terms in aliases.
 675                  */
 676                 cloned->weak = true;
 677                 list_add_tail(&cloned->list, &list);
 678         }
 679         list_splice(&list, terms);
 680         return 0;
 681 }
 682
 683 /*
 684  * Uncore PMUs have a "cpumask" file under sysfs. CPU PMUs (e.g. on arm/arm64)
 685  * may have a "cpus" file.
 686  */
 687 static struct perf_cpu_map *pmu_cpumask(int dirfd, const char *name, bool is_core)
 688 {
 689         struct perf_cpu_map *cpus;
 690         const char *templates[] = {
 691                 "cpumask",
 692                 "cpus",
 693                 NULL
 694         };
 695         const char **template;
 696         char pmu_name[PATH_MAX];
 697         struct perf_pmu pmu = {.name = pmu_name};
 698         FILE *file;
 699
 700         strlcpy(pmu_name, name, sizeof(pmu_name));
 701         for (template = templates; *template; template++) {
 702                 file = perf_pmu__open_file_at(&pmu, dirfd, *template);
 703                 if (!file)
 704                         continue;
 705                 cpus = perf_cpu_map__read(file);
 706                 fclose(file);
 707                 if (cpus)
 708                         return cpus;
 709         }
 710
 711         /* Nothing found, for core PMUs assume this means all CPUs. */
 712         return is_core ? perf_cpu_map__get(cpu_map__online()) : NULL;
 713 }
 714
 715 static bool pmu_is_uncore(int dirfd, const char *name)
 716 {
 717         int fd;
 718
 719         fd = perf_pmu__pathname_fd(dirfd, name, "cpumask", O_PATH);
 720         if (fd < 0)
 721                 return false;
 722
 723         close(fd);
 724         return true;
 725 }
 726
 727 static char *pmu_id(const char *name)
 728 {
 729         char path[PATH_MAX], *str;
 730         size_t len;
 731
 732         perf_pmu__pathname_scnprintf(path, sizeof(path), name, "identifier");
 733
 734         if (filename__read_str(path, &str, &len) < 0)
 735                 return NULL;
 736
 737         str[len - 1] = 0; /* remove line feed */
 738
 739         return str;
 740 }
 741
 742 /**
 743  * is_sysfs_pmu_core() - PMU CORE devices have different name other than cpu in
 744  *         sysfs on some platforms like ARM or Intel hybrid. Looking for
 745  *         possible the cpus file in sysfs files to identify whether this is a
 746  *         core device.
 747  * @name: The PMU name such as "cpu_atom".
 748  */
 749 static int is_sysfs_pmu_core(const char *name)
 750 {
 751         char path[PATH_MAX];
 752
 753         if (!perf_pmu__pathname_scnprintf(path, sizeof(path), name, "cpus"))
 754                 return 0;
 755         return file_available(path);
 756 }
 757
 758 char *perf_pmu__getcpuid(struct perf_pmu *pmu)
 759 {
 760         char *cpuid;
 761         static bool printed;
 762
 763         cpuid = getenv("PERF_CPUID");
 764         if (cpuid)
 765                 cpuid = strdup(cpuid);
 766         if (!cpuid)
 767                 cpuid = get_cpuid_str(pmu);
 768         if (!cpuid)
 769                 return NULL;
 770
 771         if (!printed) {
 772                 pr_debug("Using CPUID %s\n", cpuid);
 773                 printed = true;
 774         }
 775         return cpuid;
 776 }
 777
 778 __weak const struct pmu_events_table *pmu_events_table__find(void)
 779 {
 780         return perf_pmu__find_events_table(NULL);
 781 }
 782
 783 __weak const struct pmu_metrics_table *pmu_metrics_table__find(void)
 784 {
 785         return perf_pmu__find_metrics_table(NULL);
 786 }
 787
 788 /**
 789  * perf_pmu__match_ignoring_suffix - Does the pmu_name match tok ignoring any
 790  *                                   trailing suffix? The Suffix must be in form
 791  *                                   tok_{digits}, or tok{digits}.
 792  * @pmu_name: The pmu_name with possible suffix.
 793  * @tok: The possible match to pmu_name without suffix.
 794  */
 795 static bool perf_pmu__match_ignoring_suffix(const char *pmu_name, const char *tok)
 796 {
 797         const char *p;
 798
 799         if (strncmp(pmu_name, tok, strlen(tok)))
 800                 return false;
 801
 802         p = pmu_name + strlen(tok);
 803         if (*p == 0)
 804                 return true;
 805
 806         if (*p == '_')
 807                 ++p;
 808
 809         /* Ensure we end in a number */
 810         while (1) {
 811                 if (!isdigit(*p))
 812                         return false;
 813                 if (*(++p) == 0)
 814                         break;
 815         }
 816
 817         return true;
 818 }
 819
 820 /**
 821  * pmu_uncore_alias_match - does name match the PMU name?
 822  * @pmu_name: the json struct pmu_event name. This may lack a suffix (which
 823  *            matches) or be of the form "socket,pmuname" which will match
 824  *            "socketX_pmunameY".
 825  * @name: a real full PMU name as from sysfs.
 826  */
 827 static bool pmu_uncore_alias_match(const char *pmu_name, const char *name)
 828 {
 829         char *tmp = NULL, *tok, *str;
 830         bool res;
 831
 832         if (strchr(pmu_name, ',') == NULL)
 833                 return perf_pmu__match_ignoring_suffix(name, pmu_name);
 834
 835         str = strdup(pmu_name);
 836         if (!str)
 837                 return false;
 838
 839         /*
 840          * uncore alias may be from different PMU with common prefix
 841          */
 842         tok = strtok_r(str, ",", &tmp);
 843         if (strncmp(pmu_name, tok, strlen(tok))) {
 844                 res = false;
 845                 goto out;
 846         }
 847
 848         /*
 849          * Match more complex aliases where the alias name is a comma-delimited
 850          * list of tokens, orderly contained in the matching PMU name.
 851          *
 852          * Example: For alias "socket,pmuname" and PMU "socketX_pmunameY", we
 853          *          match "socket" in "socketX_pmunameY" and then "pmuname" in
 854          *          "pmunameY".
 855          */
 856         while (1) {
 857                 char *next_tok = strtok_r(NULL, ",", &tmp);
 858
 859                 name = strstr(name, tok);
 860                 if (!name ||
 861                     (!next_tok && !perf_pmu__match_ignoring_suffix(name, tok))) {
 862                         res = false;
 863                         goto out;
 864                 }
 865                 if (!next_tok)
 866                         break;
 867                 tok = next_tok;
 868                 name += strlen(tok);
 869         }
 870
 871         res = true;
 872 out:
 873         free(str);
 874         return res;
 875 }
 876
 877 static int pmu_add_cpu_aliases_map_callback(const struct pmu_event *pe,
 878                                         const struct pmu_events_table *table __maybe_unused,
 879                                         void *vdata)
 880 {
 881         struct perf_pmu *pmu = vdata;
 882
 883         perf_pmu__new_alias(pmu, pe->name, pe->desc, pe->event, /*val_fd=*/ NULL, pe);
 884         return 0;
 885 }
 886
 887 /*
 888  * From the pmu_events_table, find the events that correspond to the given
 889  * PMU and add them to the list 'head'.
 890  */
 891 void pmu_add_cpu_aliases_table(struct perf_pmu *pmu, const struct pmu_events_table *table)
 892 {
 893         pmu_events_table__for_each_event(table, pmu, pmu_add_cpu_aliases_map_callback, pmu);
 894 }
 895
 896 static void pmu_add_cpu_aliases(struct perf_pmu *pmu)
 897 {
 898         if (!pmu->events_table)
 899                 return;
 900
 901         if (pmu->cpu_aliases_added)
 902                 return;
 903
 904         pmu_add_cpu_aliases_table(pmu, pmu->events_table);
 905         pmu->cpu_aliases_added = true;
 906 }
 907
 908 static int pmu_add_sys_aliases_iter_fn(const struct pmu_event *pe,
 909                                        const struct pmu_events_table *table __maybe_unused,
 910                                        void *vdata)
 911 {
 912         struct perf_pmu *pmu = vdata;
 913
 914         if (!pe->compat || !pe->pmu)
 915                 return 0;
 916
 917         if (!strcmp(pmu->id, pe->compat) &&
 918             pmu_uncore_alias_match(pe->pmu, pmu->name)) {
 919                 perf_pmu__new_alias(pmu,
 920                                 pe->name,
 921                                 pe->desc,
 922                                 pe->event,
 923                                 /*val_fd=*/ NULL,
 924                                 pe);
 925         }
 926
 927         return 0;
 928 }
 929
 930 void pmu_add_sys_aliases(struct perf_pmu *pmu)
 931 {
 932         if (!pmu->id)
 933                 return;
 934
 935         pmu_for_each_sys_event(pmu_add_sys_aliases_iter_fn, pmu);
 936 }
 937
 938 struct perf_event_attr * __weak
 939 perf_pmu__get_default_config(struct perf_pmu *pmu __maybe_unused)
 940 {
 941         return NULL;
 942 }
 943
 944 const char * __weak
 945 pmu_find_real_name(const char *name)
 946 {
 947         return name;
 948 }
 949
 950 const char * __weak
 951 pmu_find_alias_name(const char *name __maybe_unused)
 952 {
 953         return NULL;
 954 }
 955
 956 static int pmu_max_precise(int dirfd, struct perf_pmu *pmu)
 957 {
 958         int max_precise = -1;
 959
 960         perf_pmu__scan_file_at(pmu, dirfd, "caps/max_precise", "%d", &max_precise);
 961         return max_precise;
 962 }
 963
 964 struct perf_pmu *perf_pmu__lookup(struct list_head *pmus, int dirfd, const char *lookup_name)
 965 {
 966         struct perf_pmu *pmu;
 967         __u32 type;
 968         const char *name = pmu_find_real_name(lookup_name);
 969         const char *alias_name;
 970
 971         pmu = zalloc(sizeof(*pmu));
 972         if (!pmu)
 973                 return NULL;
 974
 975         pmu->name = strdup(name);
 976         if (!pmu->name)
 977                 goto err;
 978
 979         /*
 980          * Read type early to fail fast if a lookup name isn't a PMU. Ensure
 981          * that type value is successfully assigned (return 1).
 982          */
 983         if (perf_pmu__scan_file_at(pmu, dirfd, "type", "%u", &type) != 1)
 984                 goto err;
 985
 986         INIT_LIST_HEAD(&pmu->format);
 987         INIT_LIST_HEAD(&pmu->aliases);
 988         INIT_LIST_HEAD(&pmu->caps);
 989
 990         /*
 991          * The pmu data we store & need consists of the pmu
 992          * type value and format definitions. Load both right
 993          * now.
 994          */
 995         if (pmu_format(pmu, dirfd, name)) {
 996                 free(pmu);
 997                 return NULL;
 998         }
 999         pmu->is_core = is_pmu_core(name);
1000         pmu->cpus = pmu_cpumask(dirfd, name, pmu->is_core);
1001
1002         alias_name = pmu_find_alias_name(name);
1003         if (alias_name) {
1004                 pmu->alias_name = strdup(alias_name);
1005                 if (!pmu->alias_name)
1006                         goto err;
1007         }
1008
1009         pmu->type = type;
1010         pmu->is_uncore = pmu_is_uncore(dirfd, name);
1011         if (pmu->is_uncore)
1012                 pmu->id = pmu_id(name);
1013         pmu->max_precise = pmu_max_precise(dirfd, pmu);
1014         pmu->events_table = perf_pmu__find_events_table(pmu);
1015         pmu_add_sys_aliases(pmu);
1016         list_add_tail(&pmu->list, pmus);
1017
1018         pmu->default_config = perf_pmu__get_default_config(pmu);
1019
1020         return pmu;
1021 err:
1022         zfree(&pmu->name);
1023         free(pmu);
1024         return NULL;
1025 }
1026
1027 /* Creates the PMU when sysfs scanning fails. */
1028 struct perf_pmu *perf_pmu__create_placeholder_core_pmu(struct list_head *core_pmus)
1029 {
1030         struct perf_pmu *pmu = zalloc(sizeof(*pmu));
1031
1032         if (!pmu)
1033                 return NULL;
1034
1035         pmu->name = strdup("cpu");
1036         if (!pmu->name) {
1037                 free(pmu);
1038                 return NULL;
1039         }
1040
1041         pmu->is_core = true;
1042         pmu->type = PERF_TYPE_RAW;
1043         pmu->cpus = cpu_map__online();
1044
1045         INIT_LIST_HEAD(&pmu->format);
1046         INIT_LIST_HEAD(&pmu->aliases);
1047         INIT_LIST_HEAD(&pmu->caps);
1048         list_add_tail(&pmu->list, core_pmus);
1049         return pmu;
1050 }
1051
1052 void perf_pmu__warn_invalid_formats(struct perf_pmu *pmu)
1053 {
1054         struct perf_pmu_format *format;
1055
1056         if (pmu->formats_checked)
1057                 return;
1058
1059         pmu->formats_checked = true;
1060
1061         /* fake pmu doesn't have format list */
1062         if (pmu == &perf_pmu__fake)
1063                 return;
1064
1065         list_for_each_entry(format, &pmu->format, list) {
1066                 perf_pmu_format__load(pmu, format);
1067                 if (format->value >= PERF_PMU_FORMAT_VALUE_CONFIG_END) {
1068                         pr_warning("WARNING: '%s' format '%s' requires 'perf_event_attr::config%d'"
1069                                    "which is not supported by this version of perf!\n",
1070                                    pmu->name, format->name, format->value);
1071                         return;
1072                 }
1073         }
1074 }
1075
1076 bool evsel__is_aux_event(const struct evsel *evsel)
1077 {
1078         struct perf_pmu *pmu = evsel__find_pmu(evsel);
1079
1080         return pmu && pmu->auxtrace;
1081 }
1082
1083 /*
1084  * Set @config_name to @val as long as the user hasn't already set or cleared it
1085  * by passing a config term on the command line.
1086  *
1087  * @val is the value to put into the bits specified by @config_name rather than
1088  * the bit pattern. It is shifted into position by this function, so to set
1089  * something to true, pass 1 for val rather than a pre shifted value.
1090  */
1091 #define field_prep(_mask, _val) (((_val) << (ffsll(_mask) - 1)) & (_mask))
1092 void evsel__set_config_if_unset(struct perf_pmu *pmu, struct evsel *evsel,
1093                                 const char *config_name, u64 val)
1094 {
1095         u64 user_bits = 0, bits;
1096         struct evsel_config_term *term = evsel__get_config_term(evsel, CFG_CHG);
1097
1098         if (term)
1099                 user_bits = term->val.cfg_chg;
1100
1101         bits = perf_pmu__format_bits(pmu, config_name);
1102
1103         /* Do nothing if the user changed the value */
1104         if (bits & user_bits)
1105                 return;
1106
1107         /* Otherwise replace it */
1108         evsel->core.attr.config &= ~bits;
1109         evsel->core.attr.config |= field_prep(bits, val);
1110 }
1111
1112 static struct perf_pmu_format *
1113 pmu_find_format(struct list_head *formats, const char *name)
1114 {
1115         struct perf_pmu_format *format;
1116
1117         list_for_each_entry(format, formats, list)
1118                 if (!strcmp(format->name, name))
1119                         return format;
1120
1121         return NULL;
1122 }
1123
1124 __u64 perf_pmu__format_bits(struct perf_pmu *pmu, const char *name)
1125 {
1126         struct perf_pmu_format *format = pmu_find_format(&pmu->format, name);
1127         __u64 bits = 0;
1128         int fbit;
1129
1130         if (!format)
1131                 return 0;
1132
1133         for_each_set_bit(fbit, format->bits, PERF_PMU_FORMAT_BITS)
1134                 bits |= 1ULL << fbit;
1135
1136         return bits;
1137 }
1138
1139 int perf_pmu__format_type(struct perf_pmu *pmu, const char *name)
1140 {
1141         struct perf_pmu_format *format = pmu_find_format(&pmu->format, name);
1142
1143         if (!format)
1144                 return -1;
1145
1146         perf_pmu_format__load(pmu, format);
1147         return format->value;
1148 }
1149
1150 /*
1151  * Sets value based on the format definition (format parameter)
1152  * and unformatted value (value parameter).
1153  */
1154 static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v,
1155                              bool zero)
1156 {
1157         unsigned long fbit, vbit;
1158
1159         for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) {
1160
1161                 if (!test_bit(fbit, format))
1162                         continue;
1163
1164                 if (value & (1llu << vbit++))
1165                         *v |= (1llu << fbit);
1166                 else if (zero)
1167                         *v &= ~(1llu << fbit);
1168         }
1169 }
1170
1171 static __u64 pmu_format_max_value(const unsigned long *format)
1172 {
1173         int w;
1174
1175         w = bitmap_weight(format, PERF_PMU_FORMAT_BITS);
1176         if (!w)
1177                 return 0;
1178         if (w < 64)
1179                 return (1ULL << w) - 1;
1180         return -1;
1181 }
1182
1183 /*
1184  * Term is a string term, and might be a param-term. Try to look up it's value
1185  * in the remaining terms.
1186  * - We have a term like "base-or-format-term=param-term",
1187  * - We need to find the value supplied for "param-term" (with param-term named
1188  *   in a config string) later on in the term list.
1189  */
1190 static int pmu_resolve_param_term(struct parse_events_term *term,
1191                                   struct list_head *head_terms,
1192                                   __u64 *value)
1193 {
1194         struct parse_events_term *t;
1195
1196         list_for_each_entry(t, head_terms, list) {
1197                 if (t->type_val == PARSE_EVENTS__TERM_TYPE_NUM &&
1198                     t->config && !strcmp(t->config, term->config)) {
1199                         t->used = true;
1200                         *value = t->val.num;
1201                         return 0;
1202                 }
1203         }
1204
1205         if (verbose > 0)
1206                 printf("Required parameter '%s' not specified\n", term->config);
1207
1208         return -1;
1209 }
1210
1211 static char *pmu_formats_string(struct list_head *formats)
1212 {
1213         struct perf_pmu_format *format;
1214         char *str = NULL;
1215         struct strbuf buf = STRBUF_INIT;
1216         unsigned int i = 0;
1217
1218         if (!formats)
1219                 return NULL;
1220
1221         /* sysfs exported terms */
1222         list_for_each_entry(format, formats, list)
1223                 if (strbuf_addf(&buf, i++ ? ",%s" : "%s", format->name) < 0)
1224                         goto error;
1225
1226         str = strbuf_detach(&buf, NULL);
1227 error:
1228         strbuf_release(&buf);
1229
1230         return str;
1231 }
1232
1233 /*
1234  * Setup one of config[12] attr members based on the
1235  * user input data - term parameter.
1236  */
1237 static int pmu_config_term(struct perf_pmu *pmu,
1238                            struct perf_event_attr *attr,
1239                            struct parse_events_term *term,
1240                            struct list_head *head_terms,
1241                            bool zero, struct parse_events_error *err)
1242 {
1243         struct perf_pmu_format *format;
1244         __u64 *vp;
1245         __u64 val, max_val;
1246
1247         /*
1248          * If this is a parameter we've already used for parameterized-eval,
1249          * skip it in normal eval.
1250          */
1251         if (term->used)
1252                 return 0;
1253
1254         /*
1255          * Hardcoded terms should be already in, so nothing
1256          * to be done for them.
1257          */
1258         if (parse_events__is_hardcoded_term(term))
1259                 return 0;
1260
1261         format = pmu_find_format(&pmu->format, term->config);
1262         if (!format) {
1263                 char *pmu_term = pmu_formats_string(&pmu->format);
1264                 char *unknown_term;
1265                 char *help_msg;
1266
1267                 if (asprintf(&unknown_term,
1268                                 "unknown term '%s' for pmu '%s'",
1269                                 term->config, pmu->name) < 0)
1270                         unknown_term = NULL;
1271                 help_msg = parse_events_formats_error_string(pmu_term);
1272                 if (err) {
1273                         parse_events_error__handle(err, term->err_term,
1274                                                    unknown_term,
1275                                                    help_msg);
1276                 } else {
1277                         pr_debug("%s (%s)\n", unknown_term, help_msg);
1278                         free(unknown_term);
1279                 }
1280                 free(pmu_term);
1281                 return -EINVAL;
1282         }
1283         perf_pmu_format__load(pmu, format);
1284         switch (format->value) {
1285         case PERF_PMU_FORMAT_VALUE_CONFIG:
1286                 vp = &attr->config;
1287                 break;
1288         case PERF_PMU_FORMAT_VALUE_CONFIG1:
1289                 vp = &attr->config1;
1290                 break;
1291         case PERF_PMU_FORMAT_VALUE_CONFIG2:
1292                 vp = &attr->config2;
1293                 break;
1294         case PERF_PMU_FORMAT_VALUE_CONFIG3:
1295                 vp = &attr->config3;
1296                 break;
1297         default:
1298                 return -EINVAL;
1299         }
1300
1301         /*
1302          * Either directly use a numeric term, or try to translate string terms
1303          * using event parameters.
1304          */
1305         if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
1306                 if (term->no_value &&
1307                     bitmap_weight(format->bits, PERF_PMU_FORMAT_BITS) > 1) {
1308                         if (err) {
1309                                 parse_events_error__handle(err, term->err_val,
1310                                            strdup("no value assigned for term"),
1311                                            NULL);
1312                         }
1313                         return -EINVAL;
1314                 }
1315
1316                 val = term->val.num;
1317         } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) {
1318                 if (strcmp(term->val.str, "?")) {
1319                         if (verbose > 0) {
1320                                 pr_info("Invalid sysfs entry %s=%s\n",
1321                                                 term->config, term->val.str);
1322                         }
1323                         if (err) {
1324                                 parse_events_error__handle(err, term->err_val,
1325                                         strdup("expected numeric value"),
1326                                         NULL);
1327                         }
1328                         return -EINVAL;
1329                 }
1330
1331                 if (pmu_resolve_param_term(term, head_terms, &val))
1332                         return -EINVAL;
1333         } else
1334                 return -EINVAL;
1335
1336         max_val = pmu_format_max_value(format->bits);
1337         if (val > max_val) {
1338                 if (err) {
1339                         char *err_str;
1340
1341                         parse_events_error__handle(err, term->err_val,
1342                                 asprintf(&err_str,
1343                                     "value too big for format, maximum is %llu",
1344                                     (unsigned long long)max_val) < 0
1345                                     ? strdup("value too big for format")
1346                                     : err_str,
1347                                     NULL);
1348                         return -EINVAL;
1349                 }
1350                 /*
1351                  * Assume we don't care if !err, in which case the value will be
1352                  * silently truncated.
1353                  */
1354         }
1355
1356         pmu_format_value(format->bits, val, vp, zero);
1357         return 0;
1358 }
1359
1360 int perf_pmu__config_terms(struct perf_pmu *pmu,
1361                            struct perf_event_attr *attr,
1362                            struct list_head *head_terms,
1363                            bool zero, struct parse_events_error *err)
1364 {
1365         struct parse_events_term *term;
1366
1367         list_for_each_entry(term, head_terms, list) {
1368                 if (pmu_config_term(pmu, attr, term, head_terms, zero, err))
1369                         return -EINVAL;
1370         }
1371
1372         return 0;
1373 }
1374
1375 /*
1376  * Configures event's 'attr' parameter based on the:
1377  * 1) users input - specified in terms parameter
1378  * 2) pmu format definitions - specified by pmu parameter
1379  */
1380 int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr,
1381                      struct list_head *head_terms,
1382                      struct parse_events_error *err)
1383 {
1384         bool zero = !!pmu->default_config;
1385
1386         return perf_pmu__config_terms(pmu, attr, head_terms, zero, err);
1387 }
1388
1389 static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu,
1390                                              struct parse_events_term *term)
1391 {
1392         struct perf_pmu_alias *alias;
1393         const char *name;
1394
1395         if (parse_events__is_hardcoded_term(term))
1396                 return NULL;
1397
1398         if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
1399                 if (!term->no_value)
1400                         return NULL;
1401                 if (pmu_find_format(&pmu->format, term->config))
1402                         return NULL;
1403                 name = term->config;
1404
1405         } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) {
1406                 if (strcasecmp(term->config, "event"))
1407                         return NULL;
1408                 name = term->val.str;
1409         } else {
1410                 return NULL;
1411         }
1412
1413         alias = perf_pmu__find_alias(pmu, name, /*load=*/ true);
1414         if (alias || pmu->cpu_aliases_added)
1415                 return alias;
1416
1417         /* Alias doesn't exist, try to get it from the json events. */
1418         if (pmu->events_table &&
1419             pmu_events_table__find_event(pmu->events_table, pmu, name,
1420                                          pmu_add_cpu_aliases_map_callback,
1421                                          pmu) == 0) {
1422                 alias = perf_pmu__find_alias(pmu, name, /*load=*/ false);
1423         }
1424         return alias;
1425 }
1426
1427
1428 static int check_info_data(struct perf_pmu *pmu,
1429                            struct perf_pmu_alias *alias,
1430                            struct perf_pmu_info *info,
1431                            struct parse_events_error *err,
1432                            int column)
1433 {
1434         read_alias_info(pmu, alias);
1435         /*
1436          * Only one term in event definition can
1437          * define unit, scale and snapshot, fail
1438          * if there's more than one.
1439          */
1440         if (info->unit && alias->unit[0]) {
1441                 parse_events_error__handle(err, column,
1442                                         strdup("Attempt to set event's unit twice"),
1443                                         NULL);
1444                 return -EINVAL;
1445         }
1446         if (info->scale && alias->scale) {
1447                 parse_events_error__handle(err, column,
1448                                         strdup("Attempt to set event's scale twice"),
1449                                         NULL);
1450                 return -EINVAL;
1451         }
1452         if (info->snapshot && alias->snapshot) {
1453                 parse_events_error__handle(err, column,
1454                                         strdup("Attempt to set event snapshot twice"),
1455                                         NULL);
1456                 return -EINVAL;
1457         }
1458
1459         if (alias->unit[0])
1460                 info->unit = alias->unit;
1461
1462         if (alias->scale)
1463                 info->scale = alias->scale;
1464
1465         if (alias->snapshot)
1466                 info->snapshot = alias->snapshot;
1467
1468         return 0;
1469 }
1470
1471 /*
1472  * Find alias in the terms list and replace it with the terms
1473  * defined for the alias
1474  */
1475 int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms,
1476                           struct perf_pmu_info *info, struct parse_events_error *err)
1477 {
1478         struct parse_events_term *term, *h;
1479         struct perf_pmu_alias *alias;
1480         int ret;
1481
1482         info->per_pkg = false;
1483
1484         /*
1485          * Mark unit and scale as not set
1486          * (different from default values, see below)
1487          */
1488         info->unit     = NULL;
1489         info->scale    = 0.0;
1490         info->snapshot = false;
1491
1492         list_for_each_entry_safe(term, h, head_terms, list) {
1493                 alias = pmu_find_alias(pmu, term);
1494                 if (!alias)
1495                         continue;
1496                 ret = pmu_alias_terms(alias, &term->list);
1497                 if (ret) {
1498                         parse_events_error__handle(err, term->err_term,
1499                                                 strdup("Failure to duplicate terms"),
1500                                                 NULL);
1501                         return ret;
1502                 }
1503
1504                 ret = check_info_data(pmu, alias, info, err, term->err_term);
1505                 if (ret)
1506                         return ret;
1507
1508                 if (alias->per_pkg)
1509                         info->per_pkg = true;
1510
1511                 list_del_init(&term->list);
1512                 parse_events_term__delete(term);
1513         }
1514
1515         /*
1516          * if no unit or scale found in aliases, then
1517          * set defaults as for evsel
1518          * unit cannot left to NULL
1519          */
1520         if (info->unit == NULL)
1521                 info->unit   = "";
1522
1523         if (info->scale == 0.0)
1524                 info->scale  = 1.0;
1525
1526         return 0;
1527 }
1528
1529 struct find_event_args {
1530         const char *event;
1531         void *state;
1532         pmu_event_callback cb;
1533 };
1534
1535 static int find_event_callback(void *state, struct pmu_event_info *info)
1536 {
1537         struct find_event_args *args = state;
1538
1539         if (!strcmp(args->event, info->name))
1540                 return args->cb(args->state, info);
1541
1542         return 0;
1543 }
1544
1545 int perf_pmu__find_event(struct perf_pmu *pmu, const char *event, void *state, pmu_event_callback cb)
1546 {
1547         struct find_event_args args = {
1548                 .event = event,
1549                 .state = state,
1550                 .cb = cb,
1551         };
1552
1553         /* Sub-optimal, but function is only used by tests. */
1554         return perf_pmu__for_each_event(pmu, /*skip_duplicate_pmus=*/ false,
1555                                         &args, find_event_callback);
1556 }
1557
1558 static void perf_pmu__del_formats(struct list_head *formats)
1559 {
1560         struct perf_pmu_format *fmt, *tmp;
1561
1562         list_for_each_entry_safe(fmt, tmp, formats, list) {
1563                 list_del(&fmt->list);
1564                 zfree(&fmt->name);
1565                 free(fmt);
1566         }
1567 }
1568
1569 bool perf_pmu__has_format(const struct perf_pmu *pmu, const char *name)
1570 {
1571         struct perf_pmu_format *format;
1572
1573         list_for_each_entry(format, &pmu->format, list) {
1574                 if (!strcmp(format->name, name))
1575                         return true;
1576         }
1577         return false;
1578 }
1579
1580 bool is_pmu_core(const char *name)
1581 {
1582         return !strcmp(name, "cpu") || !strcmp(name, "cpum_cf") || is_sysfs_pmu_core(name);
1583 }
1584
1585 bool perf_pmu__supports_legacy_cache(const struct perf_pmu *pmu)
1586 {
1587         return pmu->is_core;
1588 }
1589
1590 bool perf_pmu__auto_merge_stats(const struct perf_pmu *pmu)
1591 {
1592         return !pmu->is_core || perf_pmus__num_core_pmus() == 1;
1593 }
1594
1595 bool perf_pmu__have_event(struct perf_pmu *pmu, const char *name)
1596 {
1597         if (perf_pmu__find_alias(pmu, name, /*load=*/ true) != NULL)
1598                 return true;
1599         if (pmu->cpu_aliases_added || !pmu->events_table)
1600                 return false;
1601         return pmu_events_table__find_event(pmu->events_table, pmu, name, NULL, NULL) == 0;
1602 }
1603
1604 size_t perf_pmu__num_events(struct perf_pmu *pmu)
1605 {
1606         size_t nr;
1607
1608         if (!pmu->sysfs_aliases_loaded)
1609                 pmu_aliases_parse(pmu);
1610
1611         nr = pmu->sysfs_aliases;
1612
1613         if (pmu->cpu_aliases_added)
1614                  nr += pmu->loaded_json_aliases;
1615         else if (pmu->events_table)
1616                 nr += pmu_events_table__num_events(pmu->events_table, pmu) - pmu->loaded_json_aliases;
1617
1618         return pmu->selectable ? nr + 1 : nr;
1619 }
1620
1621 static int sub_non_neg(int a, int b)
1622 {
1623         if (b > a)
1624                 return 0;
1625         return a - b;
1626 }
1627
1628 static char *format_alias(char *buf, int len, const struct perf_pmu *pmu,
1629                           const struct perf_pmu_alias *alias, bool skip_duplicate_pmus)
1630 {
1631         struct parse_events_term *term;
1632         int pmu_name_len = skip_duplicate_pmus
1633                 ? pmu_name_len_no_suffix(pmu->name, /*num=*/NULL)
1634                 : (int)strlen(pmu->name);
1635         int used = snprintf(buf, len, "%.*s/%s", pmu_name_len, pmu->name, alias->name);
1636
1637         list_for_each_entry(term, &alias->terms, list) {
1638                 if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR)
1639                         used += snprintf(buf + used, sub_non_neg(len, used),
1640                                         ",%s=%s", term->config,
1641                                         term->val.str);
1642         }
1643
1644         if (sub_non_neg(len, used) > 0) {
1645                 buf[used] = '/';
1646                 used++;
1647         }
1648         if (sub_non_neg(len, used) > 0) {
1649                 buf[used] = '\0';
1650                 used++;
1651         } else
1652                 buf[len - 1] = '\0';
1653
1654         return buf;
1655 }
1656
1657 int perf_pmu__for_each_event(struct perf_pmu *pmu, bool skip_duplicate_pmus,
1658                              void *state, pmu_event_callback cb)
1659 {
1660         char buf[1024];
1661         struct perf_pmu_alias *event;
1662         struct pmu_event_info info = {
1663                 .pmu = pmu,
1664         };
1665         int ret = 0;
1666         struct strbuf sb;
1667
1668         strbuf_init(&sb, /*hint=*/ 0);
1669         pmu_add_cpu_aliases(pmu);
1670         list_for_each_entry(event, &pmu->aliases, list) {
1671                 size_t buf_used;
1672
1673                 info.pmu_name = event->pmu_name ?: pmu->name;
1674                 info.alias = NULL;
1675                 if (event->desc) {
1676                         info.name = event->name;
1677                         buf_used = 0;
1678                 } else {
1679                         info.name = format_alias(buf, sizeof(buf), pmu, event,
1680                                                  skip_duplicate_pmus);
1681                         if (pmu->is_core) {
1682                                 info.alias = info.name;
1683                                 info.name = event->name;
1684                         }
1685                         buf_used = strlen(buf) + 1;
1686                 }
1687                 info.scale_unit = NULL;
1688                 if (strlen(event->unit) || event->scale != 1.0) {
1689                         info.scale_unit = buf + buf_used;
1690                         buf_used += snprintf(buf + buf_used, sizeof(buf) - buf_used,
1691                                         "%G%s", event->scale, event->unit) + 1;
1692                 }
1693                 info.desc = event->desc;
1694                 info.long_desc = event->long_desc;
1695                 info.encoding_desc = buf + buf_used;
1696                 parse_events_term__to_strbuf(&event->terms, &sb);
1697                 buf_used += snprintf(buf + buf_used, sizeof(buf) - buf_used,
1698                                 "%s/%s/", info.pmu_name, sb.buf) + 1;
1699                 info.topic = event->topic;
1700                 info.str = sb.buf;
1701                 info.deprecated = event->deprecated;
1702                 ret = cb(state, &info);
1703                 if (ret)
1704                         goto out;
1705                 strbuf_setlen(&sb, /*len=*/ 0);
1706         }
1707         if (pmu->selectable) {
1708                 info.name = buf;
1709                 snprintf(buf, sizeof(buf), "%s//", pmu->name);
1710                 info.alias = NULL;
1711                 info.scale_unit = NULL;
1712                 info.desc = NULL;
1713                 info.long_desc = NULL;
1714                 info.encoding_desc = NULL;
1715                 info.topic = NULL;
1716                 info.pmu_name = pmu->name;
1717                 info.deprecated = false;
1718                 ret = cb(state, &info);
1719         }
1720 out:
1721         strbuf_release(&sb);
1722         return ret;
1723 }
1724
1725 bool pmu__name_match(const struct perf_pmu *pmu, const char *pmu_name)
1726 {
1727         return !strcmp(pmu->name, pmu_name) ||
1728                 (pmu->is_uncore && pmu_uncore_alias_match(pmu_name, pmu->name)) ||
1729                 /*
1730                  * jevents and tests use default_core as a marker for any core
1731                  * PMU as the PMU name varies across architectures.
1732                  */
1733                 (pmu->is_core && !strcmp(pmu_name, "default_core"));
1734 }
1735
1736 bool perf_pmu__is_software(const struct perf_pmu *pmu)
1737 {
1738         if (pmu->is_core || pmu->is_uncore || pmu->auxtrace)
1739                 return false;
1740         switch (pmu->type) {
1741         case PERF_TYPE_HARDWARE:        return false;
1742         case PERF_TYPE_SOFTWARE:        return true;
1743         case PERF_TYPE_TRACEPOINT:      return true;
1744         case PERF_TYPE_HW_CACHE:        return false;
1745         case PERF_TYPE_RAW:             return false;
1746         case PERF_TYPE_BREAKPOINT:      return true;
1747         default: break;
1748         }
1749         return !strcmp(pmu->name, "kprobe") || !strcmp(pmu->name, "uprobe");
1750 }
1751
1752 FILE *perf_pmu__open_file(struct perf_pmu *pmu, const char *name)
1753 {
1754         char path[PATH_MAX];
1755
1756         if (!perf_pmu__pathname_scnprintf(path, sizeof(path), pmu->name, name) ||
1757             !file_available(path))
1758                 return NULL;
1759
1760         return fopen(path, "r");
1761 }
1762
1763 FILE *perf_pmu__open_file_at(struct perf_pmu *pmu, int dirfd, const char *name)
1764 {
1765         int fd;
1766
1767         fd = perf_pmu__pathname_fd(dirfd, pmu->name, name, O_RDONLY);
1768         if (fd < 0)
1769                 return NULL;
1770
1771         return fdopen(fd, "r");
1772 }
1773
1774 int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt,
1775                         ...)
1776 {
1777         va_list args;
1778         FILE *file;
1779         int ret = EOF;
1780
1781         va_start(args, fmt);
1782         file = perf_pmu__open_file(pmu, name);
1783         if (file) {
1784                 ret = vfscanf(file, fmt, args);
1785                 fclose(file);
1786         }
1787         va_end(args);
1788         return ret;
1789 }
1790
1791 int perf_pmu__scan_file_at(struct perf_pmu *pmu, int dirfd, const char *name,
1792                            const char *fmt, ...)
1793 {
1794         va_list args;
1795         FILE *file;
1796         int ret = EOF;
1797
1798         va_start(args, fmt);
1799         file = perf_pmu__open_file_at(pmu, dirfd, name);
1800         if (file) {
1801                 ret = vfscanf(file, fmt, args);
1802                 fclose(file);
1803         }
1804         va_end(args);
1805         return ret;
1806 }
1807
1808 bool perf_pmu__file_exists(struct perf_pmu *pmu, const char *name)
1809 {
1810         char path[PATH_MAX];
1811
1812         if (!perf_pmu__pathname_scnprintf(path, sizeof(path), pmu->name, name))
1813                 return false;
1814
1815         return file_available(path);
1816 }
1817
1818 static int perf_pmu__new_caps(struct list_head *list, char *name, char *value)
1819 {
1820         struct perf_pmu_caps *caps = zalloc(sizeof(*caps));
1821
1822         if (!caps)
1823                 return -ENOMEM;
1824
1825         caps->name = strdup(name);
1826         if (!caps->name)
1827                 goto free_caps;
1828         caps->value = strndup(value, strlen(value) - 1);
1829         if (!caps->value)
1830                 goto free_name;
1831         list_add_tail(&caps->list, list);
1832         return 0;
1833
1834 free_name:
1835         zfree(&caps->name);
1836 free_caps:
1837         free(caps);
1838
1839         return -ENOMEM;
1840 }
1841
1842 static void perf_pmu__del_caps(struct perf_pmu *pmu)
1843 {
1844         struct perf_pmu_caps *caps, *tmp;
1845
1846         list_for_each_entry_safe(caps, tmp, &pmu->caps, list) {
1847                 list_del(&caps->list);
1848                 zfree(&caps->name);
1849                 zfree(&caps->value);
1850                 free(caps);
1851         }
1852 }
1853
1854 /*
1855  * Reading/parsing the given pmu capabilities, which should be located at:
1856  * /sys/bus/event_source/devices/<dev>/caps as sysfs group attributes.
1857  * Return the number of capabilities
1858  */
1859 int perf_pmu__caps_parse(struct perf_pmu *pmu)
1860 {
1861         struct stat st;
1862         char caps_path[PATH_MAX];
1863         DIR *caps_dir;
1864         struct dirent *evt_ent;
1865         int caps_fd;
1866
1867         if (pmu->caps_initialized)
1868                 return pmu->nr_caps;
1869
1870         pmu->nr_caps = 0;
1871
1872         if (!perf_pmu__pathname_scnprintf(caps_path, sizeof(caps_path), pmu->name, "caps"))
1873                 return -1;
1874
1875         if (stat(caps_path, &st) < 0) {
1876                 pmu->caps_initialized = true;
1877                 return 0;       /* no error if caps does not exist */
1878         }
1879
1880         caps_dir = opendir(caps_path);
1881         if (!caps_dir)
1882                 return -EINVAL;
1883
1884         caps_fd = dirfd(caps_dir);
1885
1886         while ((evt_ent = readdir(caps_dir)) != NULL) {
1887                 char *name = evt_ent->d_name;
1888                 char value[128];
1889                 FILE *file;
1890                 int fd;
1891
1892                 if (!strcmp(name, ".") || !strcmp(name, ".."))
1893                         continue;
1894
1895                 fd = openat(caps_fd, name, O_RDONLY);
1896                 if (fd == -1)
1897                         continue;
1898                 file = fdopen(fd, "r");
1899                 if (!file) {
1900                         close(fd);
1901                         continue;
1902                 }
1903
1904                 if (!fgets(value, sizeof(value), file) ||
1905                     (perf_pmu__new_caps(&pmu->caps, name, value) < 0)) {
1906                         fclose(file);
1907                         continue;
1908                 }
1909
1910                 pmu->nr_caps++;
1911                 fclose(file);
1912         }
1913
1914         closedir(caps_dir);
1915
1916         pmu->caps_initialized = true;
1917         return pmu->nr_caps;
1918 }
1919
1920 static void perf_pmu__compute_config_masks(struct perf_pmu *pmu)
1921 {
1922         struct perf_pmu_format *format;
1923
1924         if (pmu->config_masks_computed)
1925                 return;
1926
1927         list_for_each_entry(format, &pmu->format, list) {
1928                 unsigned int i;
1929                 __u64 *mask;
1930
1931                 if (format->value >= PERF_PMU_FORMAT_VALUE_CONFIG_END)
1932                         continue;
1933
1934                 pmu->config_masks_present = true;
1935                 mask = &pmu->config_masks[format->value];
1936
1937                 for_each_set_bit(i, format->bits, PERF_PMU_FORMAT_BITS)
1938                         *mask |= 1ULL << i;
1939         }
1940         pmu->config_masks_computed = true;
1941 }
1942
1943 void perf_pmu__warn_invalid_config(struct perf_pmu *pmu, __u64 config,
1944                                    const char *name, int config_num,
1945                                    const char *config_name)
1946 {
1947         __u64 bits;
1948         char buf[100];
1949
1950         perf_pmu__compute_config_masks(pmu);
1951
1952         /*
1953          * Kernel doesn't export any valid format bits.
1954          */
1955         if (!pmu->config_masks_present)
1956                 return;
1957
1958         bits = config & ~pmu->config_masks[config_num];
1959         if (bits == 0)
1960                 return;
1961
1962         bitmap_scnprintf((unsigned long *)&bits, sizeof(bits) * 8, buf, sizeof(buf));
1963
1964         pr_warning("WARNING: event '%s' not valid (bits %s of %s "
1965                    "'%llx' not supported by kernel)!\n",
1966                    name ?: "N/A", buf, config_name, config);
1967 }
1968
1969 int perf_pmu__match(const char *pattern, const char *name, const char *tok)
1970 {
1971         if (!name)
1972                 return -1;
1973
1974         if (fnmatch(pattern, name, 0))
1975                 return -1;
1976
1977         if (tok && !perf_pmu__match_ignoring_suffix(name, tok))
1978                 return -1;
1979
1980         return 0;
1981 }
1982
1983 double __weak perf_pmu__cpu_slots_per_cycle(void)
1984 {
1985         return NAN;
1986 }
1987
1988 int perf_pmu__event_source_devices_scnprintf(char *pathname, size_t size)
1989 {
1990         const char *sysfs = sysfs__mountpoint();
1991
1992         if (!sysfs)
1993                 return 0;
1994         return scnprintf(pathname, size, "%s/bus/event_source/devices/", sysfs);
1995 }
1996
1997 int perf_pmu__event_source_devices_fd(void)
1998 {
1999         char path[PATH_MAX];
2000         const char *sysfs = sysfs__mountpoint();
2001
2002         if (!sysfs)
2003                 return -1;
2004
2005         scnprintf(path, sizeof(path), "%s/bus/event_source/devices/", sysfs);
2006         return open(path, O_DIRECTORY);
2007 }
2008
2009 /*
2010  * Fill 'buf' with the path to a file or folder in 'pmu_name' in
2011  * sysfs. For example if pmu_name = "cs_etm" and 'filename' = "format"
2012  * then pathname will be filled with
2013  * "/sys/bus/event_source/devices/cs_etm/format"
2014  *
2015  * Return 0 if the sysfs mountpoint couldn't be found, if no characters were
2016  * written or if the buffer size is exceeded.
2017  */
2018 int perf_pmu__pathname_scnprintf(char *buf, size_t size,
2019                                  const char *pmu_name, const char *filename)
2020 {
2021         size_t len;
2022
2023         len = perf_pmu__event_source_devices_scnprintf(buf, size);
2024         if (!len || (len + strlen(pmu_name) + strlen(filename) + 1)  >= size)
2025                 return 0;
2026
2027         return scnprintf(buf + len, size - len, "%s/%s", pmu_name, filename);
2028 }
2029
2030 int perf_pmu__pathname_fd(int dirfd, const char *pmu_name, const char *filename, int flags)
2031 {
2032         char path[PATH_MAX];
2033
2034         scnprintf(path, sizeof(path), "%s/%s", pmu_name, filename);
2035         return openat(dirfd, path, flags);
2036 }
2037
2038 void perf_pmu__delete(struct perf_pmu *pmu)
2039 {
2040         perf_pmu__del_formats(&pmu->format);
2041         perf_pmu__del_aliases(pmu);
2042         perf_pmu__del_caps(pmu);
2043
2044         perf_cpu_map__put(pmu->cpus);
2045
2046         zfree(&pmu->default_config);
2047         zfree(&pmu->name);
2048         zfree(&pmu->alias_name);
2049         zfree(&pmu->id);
2050         free(pmu);
2051 }
2052
2053 struct perf_pmu *pmu__find_core_pmu(void)
2054 {
2055         struct perf_pmu *pmu = NULL;
2056
2057         while ((pmu = perf_pmus__scan_core(pmu))) {
2058                 /*
2059                  * The cpumap should cover all CPUs. Otherwise, some CPUs may
2060                  * not support some events or have different event IDs.
2061                  */
2062                 if (RC_CHK_ACCESS(pmu->cpus)->nr != cpu__max_cpu().cpu)
2063                         return NULL;
2064
2065                 return pmu;
2066         }
2067         return NULL;
2068 }