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