tools/perf/util/pmu.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/list.h>
   3 #include <linux/compiler.h>
   4 #include <sys/types.h>
   5 #include <errno.h>
   6 #include <fcntl.h>
   7 #include <sys/stat.h>
   8 #include <unistd.h>
   9 #include <stdio.h>
  10 #include <stdbool.h>
  11 #include <stdarg.h>
  12 #include <dirent.h>
  13 #include <api/fs/fs.h>
  14 #include <locale.h>
  15 #include <regex.h>
  16 #include "util.h"
  17 #include "pmu.h"
  18 #include "parse-events.h"
  19 #include "cpumap.h"
  20 #include "header.h"
  21 #include "pmu-events/pmu-events.h"
  22 #include "cache.h"
  23 #include "string2.h"
  24
  25 struct perf_pmu_format {
  26         char *name;
  27         int value;
  28         DECLARE_BITMAP(bits, PERF_PMU_FORMAT_BITS);
  29         struct list_head list;
  30 };
  31
  32 #define EVENT_SOURCE_DEVICE_PATH "/bus/event_source/devices/"
  33
  34 int perf_pmu_parse(struct list_head *list, char *name);
  35 extern FILE *perf_pmu_in;
  36
  37 static LIST_HEAD(pmus);
  38
  39 /*
  40  * Parse & process all the sysfs attributes located under
  41  * the directory specified in 'dir' parameter.
  42  */
  43 int perf_pmu__format_parse(char *dir, struct list_head *head)
  44 {
  45         struct dirent *evt_ent;
  46         DIR *format_dir;
  47         int ret = 0;
  48
  49         format_dir = opendir(dir);
  50         if (!format_dir)
  51                 return -EINVAL;
  52
  53         while (!ret && (evt_ent = readdir(format_dir))) {
  54                 char path[PATH_MAX];
  55                 char *name = evt_ent->d_name;
  56                 FILE *file;
  57
  58                 if (!strcmp(name, ".") || !strcmp(name, ".."))
  59                         continue;
  60
  61                 snprintf(path, PATH_MAX, "%s/%s", dir, name);
  62
  63                 ret = -EINVAL;
  64                 file = fopen(path, "r");
  65                 if (!file)
  66                         break;
  67
  68                 perf_pmu_in = file;
  69                 ret = perf_pmu_parse(head, name);
  70                 fclose(file);
  71         }
  72
  73         closedir(format_dir);
  74         return ret;
  75 }
  76
  77 /*
  78  * Reading/parsing the default pmu format definition, which should be
  79  * located at:
  80  * /sys/bus/event_source/devices/<dev>/format as sysfs group attributes.
  81  */
  82 static int pmu_format(const char *name, struct list_head *format)
  83 {
  84         struct stat st;
  85         char path[PATH_MAX];
  86         const char *sysfs = sysfs__mountpoint();
  87
  88         if (!sysfs)
  89                 return -1;
  90
  91         snprintf(path, PATH_MAX,
  92                  "%s" EVENT_SOURCE_DEVICE_PATH "%s/format", sysfs, name);
  93
  94         if (stat(path, &st) < 0)
  95                 return 0;       /* no error if format does not exist */
  96
  97         if (perf_pmu__format_parse(path, format))
  98                 return -1;
  99
 100         return 0;
 101 }
 102
 103 static int convert_scale(const char *scale, char **end, double *sval)
 104 {
 105         char *lc;
 106         int ret = 0;
 107
 108         /*
 109          * save current locale
 110          */
 111         lc = setlocale(LC_NUMERIC, NULL);
 112
 113         /*
 114          * The lc string may be allocated in static storage,
 115          * so get a dynamic copy to make it survive setlocale
 116          * call below.
 117          */
 118         lc = strdup(lc);
 119         if (!lc) {
 120                 ret = -ENOMEM;
 121                 goto out;
 122         }
 123
 124         /*
 125          * force to C locale to ensure kernel
 126          * scale string is converted correctly.
 127          * kernel uses default C locale.
 128          */
 129         setlocale(LC_NUMERIC, "C");
 130
 131         *sval = strtod(scale, end);
 132
 133 out:
 134         /* restore locale */
 135         setlocale(LC_NUMERIC, lc);
 136         free(lc);
 137         return ret;
 138 }
 139
 140 static int perf_pmu__parse_scale(struct perf_pmu_alias *alias, char *dir, char *name)
 141 {
 142         struct stat st;
 143         ssize_t sret;
 144         char scale[128];
 145         int fd, ret = -1;
 146         char path[PATH_MAX];
 147
 148         snprintf(path, PATH_MAX, "%s/%s.scale", dir, name);
 149
 150         fd = open(path, O_RDONLY);
 151         if (fd == -1)
 152                 return -1;
 153
 154         if (fstat(fd, &st) < 0)
 155                 goto error;
 156
 157         sret = read(fd, scale, sizeof(scale)-1);
 158         if (sret < 0)
 159                 goto error;
 160
 161         if (scale[sret - 1] == '\n')
 162                 scale[sret - 1] = '\0';
 163         else
 164                 scale[sret] = '\0';
 165
 166         ret = convert_scale(scale, NULL, &alias->scale);
 167 error:
 168         close(fd);
 169         return ret;
 170 }
 171
 172 static int perf_pmu__parse_unit(struct perf_pmu_alias *alias, char *dir, char *name)
 173 {
 174         char path[PATH_MAX];
 175         ssize_t sret;
 176         int fd;
 177
 178         snprintf(path, PATH_MAX, "%s/%s.unit", dir, name);
 179
 180         fd = open(path, O_RDONLY);
 181         if (fd == -1)
 182                 return -1;
 183
 184         sret = read(fd, alias->unit, UNIT_MAX_LEN);
 185         if (sret < 0)
 186                 goto error;
 187
 188         close(fd);
 189
 190         if (alias->unit[sret - 1] == '\n')
 191                 alias->unit[sret - 1] = '\0';
 192         else
 193                 alias->unit[sret] = '\0';
 194
 195         return 0;
 196 error:
 197         close(fd);
 198         alias->unit[0] = '\0';
 199         return -1;
 200 }
 201
 202 static int
 203 perf_pmu__parse_per_pkg(struct perf_pmu_alias *alias, char *dir, char *name)
 204 {
 205         char path[PATH_MAX];
 206         int fd;
 207
 208         snprintf(path, PATH_MAX, "%s/%s.per-pkg", dir, name);
 209
 210         fd = open(path, O_RDONLY);
 211         if (fd == -1)
 212                 return -1;
 213
 214         close(fd);
 215
 216         alias->per_pkg = true;
 217         return 0;
 218 }
 219
 220 static int perf_pmu__parse_snapshot(struct perf_pmu_alias *alias,
 221                                     char *dir, char *name)
 222 {
 223         char path[PATH_MAX];
 224         int fd;
 225
 226         snprintf(path, PATH_MAX, "%s/%s.snapshot", dir, name);
 227
 228         fd = open(path, O_RDONLY);
 229         if (fd == -1)
 230                 return -1;
 231
 232         alias->snapshot = true;
 233         close(fd);
 234         return 0;
 235 }
 236
 237 static int __perf_pmu__new_alias(struct list_head *list, char *dir, char *name,
 238                                  char *desc, char *val,
 239                                  char *long_desc, char *topic,
 240                                  char *unit, char *perpkg,
 241                                  char *metric_expr,
 242                                  char *metric_name)
 243 {
 244         struct perf_pmu_alias *alias;
 245         int ret;
 246         int num;
 247
 248         alias = malloc(sizeof(*alias));
 249         if (!alias)
 250                 return -ENOMEM;
 251
 252         INIT_LIST_HEAD(&alias->terms);
 253         alias->scale = 1.0;
 254         alias->unit[0] = '\0';
 255         alias->per_pkg = false;
 256         alias->snapshot = false;
 257
 258         ret = parse_events_terms(&alias->terms, val);
 259         if (ret) {
 260                 pr_err("Cannot parse alias %s: %d\n", val, ret);
 261                 free(alias);
 262                 return ret;
 263         }
 264
 265         alias->name = strdup(name);
 266         if (dir) {
 267                 /*
 268                  * load unit name and scale if available
 269                  */
 270                 perf_pmu__parse_unit(alias, dir, name);
 271                 perf_pmu__parse_scale(alias, dir, name);
 272                 perf_pmu__parse_per_pkg(alias, dir, name);
 273                 perf_pmu__parse_snapshot(alias, dir, name);
 274         }
 275
 276         alias->metric_expr = metric_expr ? strdup(metric_expr) : NULL;
 277         alias->metric_name = metric_name ? strdup(metric_name): NULL;
 278         alias->desc = desc ? strdup(desc) : NULL;
 279         alias->long_desc = long_desc ? strdup(long_desc) :
 280                                 desc ? strdup(desc) : NULL;
 281         alias->topic = topic ? strdup(topic) : NULL;
 282         if (unit) {
 283                 if (convert_scale(unit, &unit, &alias->scale) < 0)
 284                         return -1;
 285                 snprintf(alias->unit, sizeof(alias->unit), "%s", unit);
 286         }
 287         alias->per_pkg = perpkg && sscanf(perpkg, "%d", &num) == 1 && num == 1;
 288         alias->str = strdup(val);
 289
 290         list_add_tail(&alias->list, list);
 291
 292         return 0;
 293 }
 294
 295 static int perf_pmu__new_alias(struct list_head *list, char *dir, char *name, FILE *file)
 296 {
 297         char buf[256];
 298         int ret;
 299
 300         ret = fread(buf, 1, sizeof(buf), file);
 301         if (ret == 0)
 302                 return -EINVAL;
 303
 304         buf[ret] = 0;
 305
 306         return __perf_pmu__new_alias(list, dir, name, NULL, buf, NULL, NULL, NULL,
 307                                      NULL, NULL, NULL);
 308 }
 309
 310 static inline bool pmu_alias_info_file(char *name)
 311 {
 312         size_t len;
 313
 314         len = strlen(name);
 315         if (len > 5 && !strcmp(name + len - 5, ".unit"))
 316                 return true;
 317         if (len > 6 && !strcmp(name + len - 6, ".scale"))
 318                 return true;
 319         if (len > 8 && !strcmp(name + len - 8, ".per-pkg"))
 320                 return true;
 321         if (len > 9 && !strcmp(name + len - 9, ".snapshot"))
 322                 return true;
 323
 324         return false;
 325 }
 326
 327 /*
 328  * Process all the sysfs attributes located under the directory
 329  * specified in 'dir' parameter.
 330  */
 331 static int pmu_aliases_parse(char *dir, struct list_head *head)
 332 {
 333         struct dirent *evt_ent;
 334         DIR *event_dir;
 335
 336         event_dir = opendir(dir);
 337         if (!event_dir)
 338                 return -EINVAL;
 339
 340         while ((evt_ent = readdir(event_dir))) {
 341                 char path[PATH_MAX];
 342                 char *name = evt_ent->d_name;
 343                 FILE *file;
 344
 345                 if (!strcmp(name, ".") || !strcmp(name, ".."))
 346                         continue;
 347
 348                 /*
 349                  * skip info files parsed in perf_pmu__new_alias()
 350                  */
 351                 if (pmu_alias_info_file(name))
 352                         continue;
 353
 354                 scnprintf(path, PATH_MAX, "%s/%s", dir, name);
 355
 356                 file = fopen(path, "r");
 357                 if (!file) {
 358                         pr_debug("Cannot open %s\n", path);
 359                         continue;
 360                 }
 361
 362                 if (perf_pmu__new_alias(head, dir, name, file) < 0)
 363                         pr_debug("Cannot set up %s\n", name);
 364                 fclose(file);
 365         }
 366
 367         closedir(event_dir);
 368         return 0;
 369 }
 370
 371 /*
 372  * Reading the pmu event aliases definition, which should be located at:
 373  * /sys/bus/event_source/devices/<dev>/events as sysfs group attributes.
 374  */
 375 static int pmu_aliases(const char *name, struct list_head *head)
 376 {
 377         struct stat st;
 378         char path[PATH_MAX];
 379         const char *sysfs = sysfs__mountpoint();
 380
 381         if (!sysfs)
 382                 return -1;
 383
 384         snprintf(path, PATH_MAX,
 385                  "%s/bus/event_source/devices/%s/events", sysfs, name);
 386
 387         if (stat(path, &st) < 0)
 388                 return 0;        /* no error if 'events' does not exist */
 389
 390         if (pmu_aliases_parse(path, head))
 391                 return -1;
 392
 393         return 0;
 394 }
 395
 396 static int pmu_alias_terms(struct perf_pmu_alias *alias,
 397                            struct list_head *terms)
 398 {
 399         struct parse_events_term *term, *cloned;
 400         LIST_HEAD(list);
 401         int ret;
 402
 403         list_for_each_entry(term, &alias->terms, list) {
 404                 ret = parse_events_term__clone(&cloned, term);
 405                 if (ret) {
 406                         parse_events_terms__purge(&list);
 407                         return ret;
 408                 }
 409                 /*
 410                  * Weak terms don't override command line options,
 411                  * which we don't want for implicit terms in aliases.
 412                  */
 413                 cloned->weak = true;
 414                 list_add_tail(&cloned->list, &list);
 415         }
 416         list_splice(&list, terms);
 417         return 0;
 418 }
 419
 420 /*
 421  * Reading/parsing the default pmu type value, which should be
 422  * located at:
 423  * /sys/bus/event_source/devices/<dev>/type as sysfs attribute.
 424  */
 425 static int pmu_type(const char *name, __u32 *type)
 426 {
 427         struct stat st;
 428         char path[PATH_MAX];
 429         FILE *file;
 430         int ret = 0;
 431         const char *sysfs = sysfs__mountpoint();
 432
 433         if (!sysfs)
 434                 return -1;
 435
 436         snprintf(path, PATH_MAX,
 437                  "%s" EVENT_SOURCE_DEVICE_PATH "%s/type", sysfs, name);
 438
 439         if (stat(path, &st) < 0)
 440                 return -1;
 441
 442         file = fopen(path, "r");
 443         if (!file)
 444                 return -EINVAL;
 445
 446         if (1 != fscanf(file, "%u", type))
 447                 ret = -1;
 448
 449         fclose(file);
 450         return ret;
 451 }
 452
 453 /* Add all pmus in sysfs to pmu list: */
 454 static void pmu_read_sysfs(void)
 455 {
 456         char path[PATH_MAX];
 457         DIR *dir;
 458         struct dirent *dent;
 459         const char *sysfs = sysfs__mountpoint();
 460
 461         if (!sysfs)
 462                 return;
 463
 464         snprintf(path, PATH_MAX,
 465                  "%s" EVENT_SOURCE_DEVICE_PATH, sysfs);
 466
 467         dir = opendir(path);
 468         if (!dir)
 469                 return;
 470
 471         while ((dent = readdir(dir))) {
 472                 if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, ".."))
 473                         continue;
 474                 /* add to static LIST_HEAD(pmus): */
 475                 perf_pmu__find(dent->d_name);
 476         }
 477
 478         closedir(dir);
 479 }
 480
 481 static struct cpu_map *__pmu_cpumask(const char *path)
 482 {
 483         FILE *file;
 484         struct cpu_map *cpus;
 485
 486         file = fopen(path, "r");
 487         if (!file)
 488                 return NULL;
 489
 490         cpus = cpu_map__read(file);
 491         fclose(file);
 492         return cpus;
 493 }
 494
 495 /*
 496  * Uncore PMUs have a "cpumask" file under sysfs. CPU PMUs (e.g. on arm/arm64)
 497  * may have a "cpus" file.
 498  */
 499 #define CPUS_TEMPLATE_UNCORE    "%s/bus/event_source/devices/%s/cpumask"
 500 #define CPUS_TEMPLATE_CPU       "%s/bus/event_source/devices/%s/cpus"
 501
 502 static struct cpu_map *pmu_cpumask(const char *name)
 503 {
 504         char path[PATH_MAX];
 505         struct cpu_map *cpus;
 506         const char *sysfs = sysfs__mountpoint();
 507         const char *templates[] = {
 508                 CPUS_TEMPLATE_UNCORE,
 509                 CPUS_TEMPLATE_CPU,
 510                 NULL
 511         };
 512         const char **template;
 513
 514         if (!sysfs)
 515                 return NULL;
 516
 517         for (template = templates; *template; template++) {
 518                 snprintf(path, PATH_MAX, *template, sysfs, name);
 519                 cpus = __pmu_cpumask(path);
 520                 if (cpus)
 521                         return cpus;
 522         }
 523
 524         return NULL;
 525 }
 526
 527 static bool pmu_is_uncore(const char *name)
 528 {
 529         char path[PATH_MAX];
 530         struct cpu_map *cpus;
 531         const char *sysfs = sysfs__mountpoint();
 532
 533         snprintf(path, PATH_MAX, CPUS_TEMPLATE_UNCORE, sysfs, name);
 534         cpus = __pmu_cpumask(path);
 535         cpu_map__put(cpus);
 536
 537         return !!cpus;
 538 }
 539
 540 /*
 541  *  PMU CORE devices have different name other than cpu in sysfs on some
 542  *  platforms.
 543  *  Looking for possible sysfs files to identify the arm core device.
 544  */
 545 static int is_arm_pmu_core(const char *name)
 546 {
 547         struct stat st;
 548         char path[PATH_MAX];
 549         const char *sysfs = sysfs__mountpoint();
 550
 551         if (!sysfs)
 552                 return 0;
 553
 554         /* Look for cpu sysfs (specific to arm) */
 555         scnprintf(path, PATH_MAX, "%s/bus/event_source/devices/%s/cpus",
 556                                 sysfs, name);
 557         if (stat(path, &st) == 0)
 558                 return 1;
 559
 560         /* Look for cpu sysfs (specific to s390) */
 561         scnprintf(path, PATH_MAX, "%s/bus/event_source/devices/%s",
 562                   sysfs, name);
 563         if (stat(path, &st) == 0 && !strncmp(name, "cpum_", 5))
 564                 return 1;
 565
 566         return 0;
 567 }
 568
 569 /*
 570  * Return the CPU id as a raw string.
 571  *
 572  * Each architecture should provide a more precise id string that
 573  * can be use to match the architecture's "mapfile".
 574  */
 575 char * __weak get_cpuid_str(struct perf_pmu *pmu __maybe_unused)
 576 {
 577         return NULL;
 578 }
 579
 580 /* Return zero when the cpuid from the mapfile.csv matches the
 581  * cpuid string generated on this platform.
 582  * Otherwise return non-zero.
 583  */
 584 int strcmp_cpuid_str(const char *mapcpuid, const char *cpuid)
 585 {
 586         regex_t re;
 587         regmatch_t pmatch[1];
 588         int match;
 589
 590         if (regcomp(&re, mapcpuid, REG_EXTENDED) != 0) {
 591                 /* Warn unable to generate match particular string. */
 592                 pr_info("Invalid regular expression %s\n", mapcpuid);
 593                 return 1;
 594         }
 595
 596         match = !regexec(&re, cpuid, 1, pmatch, 0);
 597         regfree(&re);
 598         if (match) {
 599                 size_t match_len = (pmatch[0].rm_eo - pmatch[0].rm_so);
 600
 601                 /* Verify the entire string matched. */
 602                 if (match_len == strlen(cpuid))
 603                         return 0;
 604         }
 605         return 1;
 606 }
 607
 608 static char *perf_pmu__getcpuid(struct perf_pmu *pmu)
 609 {
 610         char *cpuid;
 611         static bool printed;
 612
 613         cpuid = getenv("PERF_CPUID");
 614         if (cpuid)
 615                 cpuid = strdup(cpuid);
 616         if (!cpuid)
 617                 cpuid = get_cpuid_str(pmu);
 618         if (!cpuid)
 619                 return NULL;
 620
 621         if (!printed) {
 622                 pr_debug("Using CPUID %s\n", cpuid);
 623                 printed = true;
 624         }
 625         return cpuid;
 626 }
 627
 628 struct pmu_events_map *perf_pmu__find_map(struct perf_pmu *pmu)
 629 {
 630         struct pmu_events_map *map;
 631         char *cpuid = perf_pmu__getcpuid(pmu);
 632         int i;
 633
 634         /* on some platforms which uses cpus map, cpuid can be NULL for
 635          * PMUs other than CORE PMUs.
 636          */
 637         if (!cpuid)
 638                 return NULL;
 639
 640         i = 0;
 641         for (;;) {
 642                 map = &pmu_events_map[i++];
 643                 if (!map->table) {
 644                         map = NULL;
 645                         break;
 646                 }
 647
 648                 if (!strcmp_cpuid_str(map->cpuid, cpuid))
 649                         break;
 650         }
 651         free(cpuid);
 652         return map;
 653 }
 654
 655 /*
 656  * From the pmu_events_map, find the table of PMU events that corresponds
 657  * to the current running CPU. Then, add all PMU events from that table
 658  * as aliases.
 659  */
 660 static void pmu_add_cpu_aliases(struct list_head *head, struct perf_pmu *pmu)
 661 {
 662         int i;
 663         struct pmu_events_map *map;
 664         struct pmu_event *pe;
 665         const char *name = pmu->name;
 666         const char *pname;
 667
 668         map = perf_pmu__find_map(pmu);
 669         if (!map)
 670                 return;
 671
 672         /*
 673          * Found a matching PMU events table. Create aliases
 674          */
 675         i = 0;
 676         while (1) {
 677
 678                 pe = &map->table[i++];
 679                 if (!pe->name) {
 680                         if (pe->metric_group || pe->metric_name)
 681                                 continue;
 682                         break;
 683                 }
 684
 685                 if (!is_arm_pmu_core(name)) {
 686                         pname = pe->pmu ? pe->pmu : "cpu";
 687                         if (strncmp(pname, name, strlen(pname)))
 688                                 continue;
 689                 }
 690
 691                 /* need type casts to override 'const' */
 692                 __perf_pmu__new_alias(head, NULL, (char *)pe->name,
 693                                 (char *)pe->desc, (char *)pe->event,
 694                                 (char *)pe->long_desc, (char *)pe->topic,
 695                                 (char *)pe->unit, (char *)pe->perpkg,
 696                                 (char *)pe->metric_expr,
 697                                 (char *)pe->metric_name);
 698         }
 699 }
 700
 701 struct perf_event_attr * __weak
 702 perf_pmu__get_default_config(struct perf_pmu *pmu __maybe_unused)
 703 {
 704         return NULL;
 705 }
 706
 707 static struct perf_pmu *pmu_lookup(const char *name)
 708 {
 709         struct perf_pmu *pmu;
 710         LIST_HEAD(format);
 711         LIST_HEAD(aliases);
 712         __u32 type;
 713
 714         /*
 715          * The pmu data we store & need consists of the pmu
 716          * type value and format definitions. Load both right
 717          * now.
 718          */
 719         if (pmu_format(name, &format))
 720                 return NULL;
 721
 722         /*
 723          * Check the type first to avoid unnecessary work.
 724          */
 725         if (pmu_type(name, &type))
 726                 return NULL;
 727
 728         if (pmu_aliases(name, &aliases))
 729                 return NULL;
 730
 731         pmu = zalloc(sizeof(*pmu));
 732         if (!pmu)
 733                 return NULL;
 734
 735         pmu->cpus = pmu_cpumask(name);
 736         pmu->name = strdup(name);
 737         pmu->type = type;
 738         pmu->is_uncore = pmu_is_uncore(name);
 739         pmu_add_cpu_aliases(&aliases, pmu);
 740
 741         INIT_LIST_HEAD(&pmu->format);
 742         INIT_LIST_HEAD(&pmu->aliases);
 743         list_splice(&format, &pmu->format);
 744         list_splice(&aliases, &pmu->aliases);
 745         list_add_tail(&pmu->list, &pmus);
 746
 747         pmu->default_config = perf_pmu__get_default_config(pmu);
 748
 749         return pmu;
 750 }
 751
 752 static struct perf_pmu *pmu_find(const char *name)
 753 {
 754         struct perf_pmu *pmu;
 755
 756         list_for_each_entry(pmu, &pmus, list)
 757                 if (!strcmp(pmu->name, name))
 758                         return pmu;
 759
 760         return NULL;
 761 }
 762
 763 struct perf_pmu *perf_pmu__scan(struct perf_pmu *pmu)
 764 {
 765         /*
 766          * pmu iterator: If pmu is NULL, we start at the begin,
 767          * otherwise return the next pmu. Returns NULL on end.
 768          */
 769         if (!pmu) {
 770                 pmu_read_sysfs();
 771                 pmu = list_prepare_entry(pmu, &pmus, list);
 772         }
 773         list_for_each_entry_continue(pmu, &pmus, list)
 774                 return pmu;
 775         return NULL;
 776 }
 777
 778 struct perf_pmu *perf_pmu__find(const char *name)
 779 {
 780         struct perf_pmu *pmu;
 781
 782         /*
 783          * Once PMU is loaded it stays in the list,
 784          * so we keep us from multiple reading/parsing
 785          * the pmu format definitions.
 786          */
 787         pmu = pmu_find(name);
 788         if (pmu)
 789                 return pmu;
 790
 791         return pmu_lookup(name);
 792 }
 793
 794 static struct perf_pmu_format *
 795 pmu_find_format(struct list_head *formats, const char *name)
 796 {
 797         struct perf_pmu_format *format;
 798
 799         list_for_each_entry(format, formats, list)
 800                 if (!strcmp(format->name, name))
 801                         return format;
 802
 803         return NULL;
 804 }
 805
 806 __u64 perf_pmu__format_bits(struct list_head *formats, const char *name)
 807 {
 808         struct perf_pmu_format *format = pmu_find_format(formats, name);
 809         __u64 bits = 0;
 810         int fbit;
 811
 812         if (!format)
 813                 return 0;
 814
 815         for_each_set_bit(fbit, format->bits, PERF_PMU_FORMAT_BITS)
 816                 bits |= 1ULL << fbit;
 817
 818         return bits;
 819 }
 820
 821 /*
 822  * Sets value based on the format definition (format parameter)
 823  * and unformated value (value parameter).
 824  */
 825 static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v,
 826                              bool zero)
 827 {
 828         unsigned long fbit, vbit;
 829
 830         for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) {
 831
 832                 if (!test_bit(fbit, format))
 833                         continue;
 834
 835                 if (value & (1llu << vbit++))
 836                         *v |= (1llu << fbit);
 837                 else if (zero)
 838                         *v &= ~(1llu << fbit);
 839         }
 840 }
 841
 842 static __u64 pmu_format_max_value(const unsigned long *format)
 843 {
 844         __u64 w = 0;
 845         int fbit;
 846
 847         for_each_set_bit(fbit, format, PERF_PMU_FORMAT_BITS)
 848                 w |= (1ULL << fbit);
 849
 850         return w;
 851 }
 852
 853 /*
 854  * Term is a string term, and might be a param-term. Try to look up it's value
 855  * in the remaining terms.
 856  * - We have a term like "base-or-format-term=param-term",
 857  * - We need to find the value supplied for "param-term" (with param-term named
 858  *   in a config string) later on in the term list.
 859  */
 860 static int pmu_resolve_param_term(struct parse_events_term *term,
 861                                   struct list_head *head_terms,
 862                                   __u64 *value)
 863 {
 864         struct parse_events_term *t;
 865
 866         list_for_each_entry(t, head_terms, list) {
 867                 if (t->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
 868                         if (!strcmp(t->config, term->config)) {
 869                                 t->used = true;
 870                                 *value = t->val.num;
 871                                 return 0;
 872                         }
 873                 }
 874         }
 875
 876         if (verbose > 0)
 877                 printf("Required parameter '%s' not specified\n", term->config);
 878
 879         return -1;
 880 }
 881
 882 static char *pmu_formats_string(struct list_head *formats)
 883 {
 884         struct perf_pmu_format *format;
 885         char *str = NULL;
 886         struct strbuf buf = STRBUF_INIT;
 887         unsigned i = 0;
 888
 889         if (!formats)
 890                 return NULL;
 891
 892         /* sysfs exported terms */
 893         list_for_each_entry(format, formats, list)
 894                 if (strbuf_addf(&buf, i++ ? ",%s" : "%s", format->name) < 0)
 895                         goto error;
 896
 897         str = strbuf_detach(&buf, NULL);
 898 error:
 899         strbuf_release(&buf);
 900
 901         return str;
 902 }
 903
 904 /*
 905  * Setup one of config[12] attr members based on the
 906  * user input data - term parameter.
 907  */
 908 static int pmu_config_term(struct list_head *formats,
 909                            struct perf_event_attr *attr,
 910                            struct parse_events_term *term,
 911                            struct list_head *head_terms,
 912                            bool zero, struct parse_events_error *err)
 913 {
 914         struct perf_pmu_format *format;
 915         __u64 *vp;
 916         __u64 val, max_val;
 917
 918         /*
 919          * If this is a parameter we've already used for parameterized-eval,
 920          * skip it in normal eval.
 921          */
 922         if (term->used)
 923                 return 0;
 924
 925         /*
 926          * Hardcoded terms should be already in, so nothing
 927          * to be done for them.
 928          */
 929         if (parse_events__is_hardcoded_term(term))
 930                 return 0;
 931
 932         format = pmu_find_format(formats, term->config);
 933         if (!format) {
 934                 if (verbose > 0)
 935                         printf("Invalid event/parameter '%s'\n", term->config);
 936                 if (err) {
 937                         char *pmu_term = pmu_formats_string(formats);
 938
 939                         err->idx  = term->err_term;
 940                         err->str  = strdup("unknown term");
 941                         err->help = parse_events_formats_error_string(pmu_term);
 942                         free(pmu_term);
 943                 }
 944                 return -EINVAL;
 945         }
 946
 947         switch (format->value) {
 948         case PERF_PMU_FORMAT_VALUE_CONFIG:
 949                 vp = &attr->config;
 950                 break;
 951         case PERF_PMU_FORMAT_VALUE_CONFIG1:
 952                 vp = &attr->config1;
 953                 break;
 954         case PERF_PMU_FORMAT_VALUE_CONFIG2:
 955                 vp = &attr->config2;
 956                 break;
 957         default:
 958                 return -EINVAL;
 959         }
 960
 961         /*
 962          * Either directly use a numeric term, or try to translate string terms
 963          * using event parameters.
 964          */
 965         if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
 966                 if (term->no_value &&
 967                     bitmap_weight(format->bits, PERF_PMU_FORMAT_BITS) > 1) {
 968                         if (err) {
 969                                 err->idx = term->err_val;
 970                                 err->str = strdup("no value assigned for term");
 971                         }
 972                         return -EINVAL;
 973                 }
 974
 975                 val = term->val.num;
 976         } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) {
 977                 if (strcmp(term->val.str, "?")) {
 978                         if (verbose > 0) {
 979                                 pr_info("Invalid sysfs entry %s=%s\n",
 980                                                 term->config, term->val.str);
 981                         }
 982                         if (err) {
 983                                 err->idx = term->err_val;
 984                                 err->str = strdup("expected numeric value");
 985                         }
 986                         return -EINVAL;
 987                 }
 988
 989                 if (pmu_resolve_param_term(term, head_terms, &val))
 990                         return -EINVAL;
 991         } else
 992                 return -EINVAL;
 993
 994         max_val = pmu_format_max_value(format->bits);
 995         if (val > max_val) {
 996                 if (err) {
 997                         err->idx = term->err_val;
 998                         if (asprintf(&err->str,
 999                                      "value too big for format, maximum is %llu",
1000                                      (unsigned long long)max_val) < 0)
1001                                 err->str = strdup("value too big for format");
1002                         return -EINVAL;
1003                 }
1004                 /*
1005                  * Assume we don't care if !err, in which case the value will be
1006                  * silently truncated.
1007                  */
1008         }
1009
1010         pmu_format_value(format->bits, val, vp, zero);
1011         return 0;
1012 }
1013
1014 int perf_pmu__config_terms(struct list_head *formats,
1015                            struct perf_event_attr *attr,
1016                            struct list_head *head_terms,
1017                            bool zero, struct parse_events_error *err)
1018 {
1019         struct parse_events_term *term;
1020
1021         list_for_each_entry(term, head_terms, list) {
1022                 if (pmu_config_term(formats, attr, term, head_terms,
1023                                     zero, err))
1024                         return -EINVAL;
1025         }
1026
1027         return 0;
1028 }
1029
1030 /*
1031  * Configures event's 'attr' parameter based on the:
1032  * 1) users input - specified in terms parameter
1033  * 2) pmu format definitions - specified by pmu parameter
1034  */
1035 int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr,
1036                      struct list_head *head_terms,
1037                      struct parse_events_error *err)
1038 {
1039         bool zero = !!pmu->default_config;
1040
1041         attr->type = pmu->type;
1042         return perf_pmu__config_terms(&pmu->format, attr, head_terms,
1043                                       zero, err);
1044 }
1045
1046 static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu,
1047                                              struct parse_events_term *term)
1048 {
1049         struct perf_pmu_alias *alias;
1050         char *name;
1051
1052         if (parse_events__is_hardcoded_term(term))
1053                 return NULL;
1054
1055         if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
1056                 if (term->val.num != 1)
1057                         return NULL;
1058                 if (pmu_find_format(&pmu->format, term->config))
1059                         return NULL;
1060                 name = term->config;
1061         } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) {
1062                 if (strcasecmp(term->config, "event"))
1063                         return NULL;
1064                 name = term->val.str;
1065         } else {
1066                 return NULL;
1067         }
1068
1069         list_for_each_entry(alias, &pmu->aliases, list) {
1070                 if (!strcasecmp(alias->name, name))
1071                         return alias;
1072         }
1073         return NULL;
1074 }
1075
1076
1077 static int check_info_data(struct perf_pmu_alias *alias,
1078                            struct perf_pmu_info *info)
1079 {
1080         /*
1081          * Only one term in event definition can
1082          * define unit, scale and snapshot, fail
1083          * if there's more than one.
1084          */
1085         if ((info->unit && alias->unit[0]) ||
1086             (info->scale && alias->scale) ||
1087             (info->snapshot && alias->snapshot))
1088                 return -EINVAL;
1089
1090         if (alias->unit[0])
1091                 info->unit = alias->unit;
1092
1093         if (alias->scale)
1094                 info->scale = alias->scale;
1095
1096         if (alias->snapshot)
1097                 info->snapshot = alias->snapshot;
1098
1099         return 0;
1100 }
1101
1102 /*
1103  * Find alias in the terms list and replace it with the terms
1104  * defined for the alias
1105  */
1106 int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms,
1107                           struct perf_pmu_info *info)
1108 {
1109         struct parse_events_term *term, *h;
1110         struct perf_pmu_alias *alias;
1111         int ret;
1112
1113         info->per_pkg = false;
1114
1115         /*
1116          * Mark unit and scale as not set
1117          * (different from default values, see below)
1118          */
1119         info->unit     = NULL;
1120         info->scale    = 0.0;
1121         info->snapshot = false;
1122         info->metric_expr = NULL;
1123         info->metric_name = NULL;
1124
1125         list_for_each_entry_safe(term, h, head_terms, list) {
1126                 alias = pmu_find_alias(pmu, term);
1127                 if (!alias)
1128                         continue;
1129                 ret = pmu_alias_terms(alias, &term->list);
1130                 if (ret)
1131                         return ret;
1132
1133                 ret = check_info_data(alias, info);
1134                 if (ret)
1135                         return ret;
1136
1137                 if (alias->per_pkg)
1138                         info->per_pkg = true;
1139                 info->metric_expr = alias->metric_expr;
1140                 info->metric_name = alias->metric_name;
1141
1142                 list_del(&term->list);
1143                 free(term);
1144         }
1145
1146         /*
1147          * if no unit or scale foundin aliases, then
1148          * set defaults as for evsel
1149          * unit cannot left to NULL
1150          */
1151         if (info->unit == NULL)
1152                 info->unit   = "";
1153
1154         if (info->scale == 0.0)
1155                 info->scale  = 1.0;
1156
1157         return 0;
1158 }
1159
1160 int perf_pmu__new_format(struct list_head *list, char *name,
1161                          int config, unsigned long *bits)
1162 {
1163         struct perf_pmu_format *format;
1164
1165         format = zalloc(sizeof(*format));
1166         if (!format)
1167                 return -ENOMEM;
1168
1169         format->name = strdup(name);
1170         format->value = config;
1171         memcpy(format->bits, bits, sizeof(format->bits));
1172
1173         list_add_tail(&format->list, list);
1174         return 0;
1175 }
1176
1177 void perf_pmu__set_format(unsigned long *bits, long from, long to)
1178 {
1179         long b;
1180
1181         if (!to)
1182                 to = from;
1183
1184         memset(bits, 0, BITS_TO_BYTES(PERF_PMU_FORMAT_BITS));
1185         for (b = from; b <= to; b++)
1186                 set_bit(b, bits);
1187 }
1188
1189 static int sub_non_neg(int a, int b)
1190 {
1191         if (b > a)
1192                 return 0;
1193         return a - b;
1194 }
1195
1196 static char *format_alias(char *buf, int len, struct perf_pmu *pmu,
1197                           struct perf_pmu_alias *alias)
1198 {
1199         struct parse_events_term *term;
1200         int used = snprintf(buf, len, "%s/%s", pmu->name, alias->name);
1201
1202         list_for_each_entry(term, &alias->terms, list) {
1203                 if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR)
1204                         used += snprintf(buf + used, sub_non_neg(len, used),
1205                                         ",%s=%s", term->config,
1206                                         term->val.str);
1207         }
1208
1209         if (sub_non_neg(len, used) > 0) {
1210                 buf[used] = '/';
1211                 used++;
1212         }
1213         if (sub_non_neg(len, used) > 0) {
1214                 buf[used] = '\0';
1215                 used++;
1216         } else
1217                 buf[len - 1] = '\0';
1218
1219         return buf;
1220 }
1221
1222 static char *format_alias_or(char *buf, int len, struct perf_pmu *pmu,
1223                              struct perf_pmu_alias *alias)
1224 {
1225         snprintf(buf, len, "%s OR %s/%s/", alias->name, pmu->name, alias->name);
1226         return buf;
1227 }
1228
1229 struct sevent {
1230         char *name;
1231         char *desc;
1232         char *topic;
1233         char *str;
1234         char *pmu;
1235         char *metric_expr;
1236         char *metric_name;
1237 };
1238
1239 static int cmp_sevent(const void *a, const void *b)
1240 {
1241         const struct sevent *as = a;
1242         const struct sevent *bs = b;
1243
1244         /* Put extra events last */
1245         if (!!as->desc != !!bs->desc)
1246                 return !!as->desc - !!bs->desc;
1247         if (as->topic && bs->topic) {
1248                 int n = strcmp(as->topic, bs->topic);
1249
1250                 if (n)
1251                         return n;
1252         }
1253         return strcmp(as->name, bs->name);
1254 }
1255
1256 static void wordwrap(char *s, int start, int max, int corr)
1257 {
1258         int column = start;
1259         int n;
1260
1261         while (*s) {
1262                 int wlen = strcspn(s, " \t");
1263
1264                 if (column + wlen >= max && column > start) {
1265                         printf("\n%*s", start, "");
1266                         column = start + corr;
1267                 }
1268                 n = printf("%s%.*s", column > start ? " " : "", wlen, s);
1269                 if (n <= 0)
1270                         break;
1271                 s += wlen;
1272                 column += n;
1273                 s = ltrim(s);
1274         }
1275 }
1276
1277 void print_pmu_events(const char *event_glob, bool name_only, bool quiet_flag,
1278                         bool long_desc, bool details_flag)
1279 {
1280         struct perf_pmu *pmu;
1281         struct perf_pmu_alias *alias;
1282         char buf[1024];
1283         int printed = 0;
1284         int len, j;
1285         struct sevent *aliases;
1286         int numdesc = 0;
1287         int columns = pager_get_columns();
1288         char *topic = NULL;
1289
1290         pmu = NULL;
1291         len = 0;
1292         while ((pmu = perf_pmu__scan(pmu)) != NULL) {
1293                 list_for_each_entry(alias, &pmu->aliases, list)
1294                         len++;
1295                 if (pmu->selectable)
1296                         len++;
1297         }
1298         aliases = zalloc(sizeof(struct sevent) * len);
1299         if (!aliases)
1300                 goto out_enomem;
1301         pmu = NULL;
1302         j = 0;
1303         while ((pmu = perf_pmu__scan(pmu)) != NULL) {
1304                 list_for_each_entry(alias, &pmu->aliases, list) {
1305                         char *name = alias->desc ? alias->name :
1306                                 format_alias(buf, sizeof(buf), pmu, alias);
1307                         bool is_cpu = !strcmp(pmu->name, "cpu");
1308
1309                         if (event_glob != NULL &&
1310                             !(strglobmatch_nocase(name, event_glob) ||
1311                               (!is_cpu && strglobmatch_nocase(alias->name,
1312                                                        event_glob)) ||
1313                               (alias->topic &&
1314                                strglobmatch_nocase(alias->topic, event_glob))))
1315                                 continue;
1316
1317                         if (is_cpu && !name_only && !alias->desc)
1318                                 name = format_alias_or(buf, sizeof(buf), pmu, alias);
1319
1320                         aliases[j].name = name;
1321                         if (is_cpu && !name_only && !alias->desc)
1322                                 aliases[j].name = format_alias_or(buf,
1323                                                                   sizeof(buf),
1324                                                                   pmu, alias);
1325                         aliases[j].name = strdup(aliases[j].name);
1326                         if (!aliases[j].name)
1327                                 goto out_enomem;
1328
1329                         aliases[j].desc = long_desc ? alias->long_desc :
1330                                                 alias->desc;
1331                         aliases[j].topic = alias->topic;
1332                         aliases[j].str = alias->str;
1333                         aliases[j].pmu = pmu->name;
1334                         aliases[j].metric_expr = alias->metric_expr;
1335                         aliases[j].metric_name = alias->metric_name;
1336                         j++;
1337                 }
1338                 if (pmu->selectable &&
1339                     (event_glob == NULL || strglobmatch(pmu->name, event_glob))) {
1340                         char *s;
1341                         if (asprintf(&s, "%s//", pmu->name) < 0)
1342                                 goto out_enomem;
1343                         aliases[j].name = s;
1344                         j++;
1345                 }
1346         }
1347         len = j;
1348         qsort(aliases, len, sizeof(struct sevent), cmp_sevent);
1349         for (j = 0; j < len; j++) {
1350                 /* Skip duplicates */
1351                 if (j > 0 && !strcmp(aliases[j].name, aliases[j - 1].name))
1352                         continue;
1353                 if (name_only) {
1354                         printf("%s ", aliases[j].name);
1355                         continue;
1356                 }
1357                 if (aliases[j].desc && !quiet_flag) {
1358                         if (numdesc++ == 0)
1359                                 printf("\n");
1360                         if (aliases[j].topic && (!topic ||
1361                                         strcmp(topic, aliases[j].topic))) {
1362                                 printf("%s%s:\n", topic ? "\n" : "",
1363                                                 aliases[j].topic);
1364                                 topic = aliases[j].topic;
1365                         }
1366                         printf("  %-50s\n", aliases[j].name);
1367                         printf("%*s", 8, "[");
1368                         wordwrap(aliases[j].desc, 8, columns, 0);
1369                         printf("]\n");
1370                         if (details_flag) {
1371                                 printf("%*s%s/%s/ ", 8, "", aliases[j].pmu, aliases[j].str);
1372                                 if (aliases[j].metric_name)
1373                                         printf(" MetricName: %s", aliases[j].metric_name);
1374                                 if (aliases[j].metric_expr)
1375                                         printf(" MetricExpr: %s", aliases[j].metric_expr);
1376                                 putchar('\n');
1377                         }
1378                 } else
1379                         printf("  %-50s [Kernel PMU event]\n", aliases[j].name);
1380                 printed++;
1381         }
1382         if (printed && pager_in_use())
1383                 printf("\n");
1384 out_free:
1385         for (j = 0; j < len; j++)
1386                 zfree(&aliases[j].name);
1387         zfree(&aliases);
1388         return;
1389
1390 out_enomem:
1391         printf("FATAL: not enough memory to print PMU events\n");
1392         if (aliases)
1393                 goto out_free;
1394 }
1395
1396 bool pmu_have_event(const char *pname, const char *name)
1397 {
1398         struct perf_pmu *pmu;
1399         struct perf_pmu_alias *alias;
1400
1401         pmu = NULL;
1402         while ((pmu = perf_pmu__scan(pmu)) != NULL) {
1403                 if (strcmp(pname, pmu->name))
1404                         continue;
1405                 list_for_each_entry(alias, &pmu->aliases, list)
1406                         if (!strcmp(alias->name, name))
1407                                 return true;
1408         }
1409         return false;
1410 }
1411
1412 static FILE *perf_pmu__open_file(struct perf_pmu *pmu, const char *name)
1413 {
1414         struct stat st;
1415         char path[PATH_MAX];
1416         const char *sysfs;
1417
1418         sysfs = sysfs__mountpoint();
1419         if (!sysfs)
1420                 return NULL;
1421
1422         snprintf(path, PATH_MAX,
1423                  "%s" EVENT_SOURCE_DEVICE_PATH "%s/%s", sysfs, pmu->name, name);
1424
1425         if (stat(path, &st) < 0)
1426                 return NULL;
1427
1428         return fopen(path, "r");
1429 }
1430
1431 int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt,
1432                         ...)
1433 {
1434         va_list args;
1435         FILE *file;
1436         int ret = EOF;
1437
1438         va_start(args, fmt);
1439         file = perf_pmu__open_file(pmu, name);
1440         if (file) {
1441                 ret = vfscanf(file, fmt, args);
1442                 fclose(file);
1443         }
1444         va_end(args);
1445         return ret;
1446 }