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                 snprintf(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. looking for possible sysfs files to identify as core device.
 543  */
 544 static int is_pmu_core(const char *name)
 545 {
 546         struct stat st;
 547         char path[PATH_MAX];
 548         const char *sysfs = sysfs__mountpoint();
 549
 550         if (!sysfs)
 551                 return 0;
 552
 553         /* Look for cpu sysfs (x86 and others) */
 554         scnprintf(path, PATH_MAX, "%s/bus/event_source/devices/cpu", sysfs);
 555         if ((stat(path, &st) == 0) &&
 556                         (strncmp(name, "cpu", strlen("cpu")) == 0))
 557                 return 1;
 558
 559         /* Look for cpu sysfs (specific to arm) */
 560         scnprintf(path, PATH_MAX, "%s/bus/event_source/devices/%s/cpus",
 561                                 sysfs, name);
 562         if (stat(path, &st) == 0)
 563                 return 1;
 564
 565         return 0;
 566 }
 567
 568 /*
 569  * Return the CPU id as a raw string.
 570  *
 571  * Each architecture should provide a more precise id string that
 572  * can be use to match the architecture's "mapfile".
 573  */
 574 char * __weak get_cpuid_str(struct perf_pmu *pmu __maybe_unused)
 575 {
 576         return NULL;
 577 }
 578
 579 static char *perf_pmu__getcpuid(struct perf_pmu *pmu)
 580 {
 581         char *cpuid;
 582         static bool printed;
 583
 584         cpuid = getenv("PERF_CPUID");
 585         if (cpuid)
 586                 cpuid = strdup(cpuid);
 587         if (!cpuid)
 588                 cpuid = get_cpuid_str(pmu);
 589         if (!cpuid)
 590                 return NULL;
 591
 592         if (!printed) {
 593                 pr_debug("Using CPUID %s\n", cpuid);
 594                 printed = true;
 595         }
 596         return cpuid;
 597 }
 598
 599 struct pmu_events_map *perf_pmu__find_map(struct perf_pmu *pmu)
 600 {
 601         struct pmu_events_map *map;
 602         char *cpuid = perf_pmu__getcpuid(pmu);
 603         int i;
 604
 605         /* on some platforms which uses cpus map, cpuid can be NULL for
 606          * PMUs other than CORE PMUs.
 607          */
 608         if (!cpuid)
 609                 return NULL;
 610
 611         i = 0;
 612         for (;;) {
 613                 regex_t re;
 614                 regmatch_t pmatch[1];
 615                 int match;
 616
 617                 map = &pmu_events_map[i++];
 618                 if (!map->table) {
 619                         map = NULL;
 620                         break;
 621                 }
 622
 623                 if (regcomp(&re, map->cpuid, REG_EXTENDED) != 0) {
 624                         /* Warn unable to generate match particular string. */
 625                         pr_info("Invalid regular expression %s\n", map->cpuid);
 626                         break;
 627                 }
 628
 629                 match = !regexec(&re, cpuid, 1, pmatch, 0);
 630                 regfree(&re);
 631                 if (match) {
 632                         size_t match_len = (pmatch[0].rm_eo - pmatch[0].rm_so);
 633
 634                         /* Verify the entire string matched. */
 635                         if (match_len == strlen(cpuid))
 636                                 break;
 637                 }
 638         }
 639         free(cpuid);
 640         return map;
 641 }
 642
 643 /*
 644  * From the pmu_events_map, find the table of PMU events that corresponds
 645  * to the current running CPU. Then, add all PMU events from that table
 646  * as aliases.
 647  */
 648 static void pmu_add_cpu_aliases(struct list_head *head, struct perf_pmu *pmu)
 649 {
 650         int i;
 651         struct pmu_events_map *map;
 652         struct pmu_event *pe;
 653         const char *name = pmu->name;
 654
 655         map = perf_pmu__find_map(pmu);
 656         if (!map)
 657                 return;
 658
 659         /*
 660          * Found a matching PMU events table. Create aliases
 661          */
 662         i = 0;
 663         while (1) {
 664
 665                 pe = &map->table[i++];
 666                 if (!pe->name) {
 667                         if (pe->metric_group || pe->metric_name)
 668                                 continue;
 669                         break;
 670                 }
 671
 672                 if (!is_pmu_core(name)) {
 673                         /* check for uncore devices */
 674                         if (pe->pmu == NULL)
 675                                 continue;
 676                         if (strncmp(pe->pmu, name, strlen(pe->pmu)))
 677                                 continue;
 678                 }
 679
 680                 /* need type casts to override 'const' */
 681                 __perf_pmu__new_alias(head, NULL, (char *)pe->name,
 682                                 (char *)pe->desc, (char *)pe->event,
 683                                 (char *)pe->long_desc, (char *)pe->topic,
 684                                 (char *)pe->unit, (char *)pe->perpkg,
 685                                 (char *)pe->metric_expr,
 686                                 (char *)pe->metric_name);
 687         }
 688 }
 689
 690 struct perf_event_attr * __weak
 691 perf_pmu__get_default_config(struct perf_pmu *pmu __maybe_unused)
 692 {
 693         return NULL;
 694 }
 695
 696 static struct perf_pmu *pmu_lookup(const char *name)
 697 {
 698         struct perf_pmu *pmu;
 699         LIST_HEAD(format);
 700         LIST_HEAD(aliases);
 701         __u32 type;
 702
 703         /*
 704          * The pmu data we store & need consists of the pmu
 705          * type value and format definitions. Load both right
 706          * now.
 707          */
 708         if (pmu_format(name, &format))
 709                 return NULL;
 710
 711         /*
 712          * Check the type first to avoid unnecessary work.
 713          */
 714         if (pmu_type(name, &type))
 715                 return NULL;
 716
 717         if (pmu_aliases(name, &aliases))
 718                 return NULL;
 719
 720         pmu = zalloc(sizeof(*pmu));
 721         if (!pmu)
 722                 return NULL;
 723
 724         pmu->cpus = pmu_cpumask(name);
 725         pmu->name = strdup(name);
 726         pmu->type = type;
 727         pmu->is_uncore = pmu_is_uncore(name);
 728         pmu_add_cpu_aliases(&aliases, pmu);
 729
 730         INIT_LIST_HEAD(&pmu->format);
 731         INIT_LIST_HEAD(&pmu->aliases);
 732         list_splice(&format, &pmu->format);
 733         list_splice(&aliases, &pmu->aliases);
 734         list_add_tail(&pmu->list, &pmus);
 735
 736         pmu->default_config = perf_pmu__get_default_config(pmu);
 737
 738         return pmu;
 739 }
 740
 741 static struct perf_pmu *pmu_find(const char *name)
 742 {
 743         struct perf_pmu *pmu;
 744
 745         list_for_each_entry(pmu, &pmus, list)
 746                 if (!strcmp(pmu->name, name))
 747                         return pmu;
 748
 749         return NULL;
 750 }
 751
 752 struct perf_pmu *perf_pmu__scan(struct perf_pmu *pmu)
 753 {
 754         /*
 755          * pmu iterator: If pmu is NULL, we start at the begin,
 756          * otherwise return the next pmu. Returns NULL on end.
 757          */
 758         if (!pmu) {
 759                 pmu_read_sysfs();
 760                 pmu = list_prepare_entry(pmu, &pmus, list);
 761         }
 762         list_for_each_entry_continue(pmu, &pmus, list)
 763                 return pmu;
 764         return NULL;
 765 }
 766
 767 struct perf_pmu *perf_pmu__find(const char *name)
 768 {
 769         struct perf_pmu *pmu;
 770
 771         /*
 772          * Once PMU is loaded it stays in the list,
 773          * so we keep us from multiple reading/parsing
 774          * the pmu format definitions.
 775          */
 776         pmu = pmu_find(name);
 777         if (pmu)
 778                 return pmu;
 779
 780         return pmu_lookup(name);
 781 }
 782
 783 static struct perf_pmu_format *
 784 pmu_find_format(struct list_head *formats, const char *name)
 785 {
 786         struct perf_pmu_format *format;
 787
 788         list_for_each_entry(format, formats, list)
 789                 if (!strcmp(format->name, name))
 790                         return format;
 791
 792         return NULL;
 793 }
 794
 795 __u64 perf_pmu__format_bits(struct list_head *formats, const char *name)
 796 {
 797         struct perf_pmu_format *format = pmu_find_format(formats, name);
 798         __u64 bits = 0;
 799         int fbit;
 800
 801         if (!format)
 802                 return 0;
 803
 804         for_each_set_bit(fbit, format->bits, PERF_PMU_FORMAT_BITS)
 805                 bits |= 1ULL << fbit;
 806
 807         return bits;
 808 }
 809
 810 /*
 811  * Sets value based on the format definition (format parameter)
 812  * and unformated value (value parameter).
 813  */
 814 static void pmu_format_value(unsigned long *format, __u64 value, __u64 *v,
 815                              bool zero)
 816 {
 817         unsigned long fbit, vbit;
 818
 819         for (fbit = 0, vbit = 0; fbit < PERF_PMU_FORMAT_BITS; fbit++) {
 820
 821                 if (!test_bit(fbit, format))
 822                         continue;
 823
 824                 if (value & (1llu << vbit++))
 825                         *v |= (1llu << fbit);
 826                 else if (zero)
 827                         *v &= ~(1llu << fbit);
 828         }
 829 }
 830
 831 static __u64 pmu_format_max_value(const unsigned long *format)
 832 {
 833         __u64 w = 0;
 834         int fbit;
 835
 836         for_each_set_bit(fbit, format, PERF_PMU_FORMAT_BITS)
 837                 w |= (1ULL << fbit);
 838
 839         return w;
 840 }
 841
 842 /*
 843  * Term is a string term, and might be a param-term. Try to look up it's value
 844  * in the remaining terms.
 845  * - We have a term like "base-or-format-term=param-term",
 846  * - We need to find the value supplied for "param-term" (with param-term named
 847  *   in a config string) later on in the term list.
 848  */
 849 static int pmu_resolve_param_term(struct parse_events_term *term,
 850                                   struct list_head *head_terms,
 851                                   __u64 *value)
 852 {
 853         struct parse_events_term *t;
 854
 855         list_for_each_entry(t, head_terms, list) {
 856                 if (t->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
 857                         if (!strcmp(t->config, term->config)) {
 858                                 t->used = true;
 859                                 *value = t->val.num;
 860                                 return 0;
 861                         }
 862                 }
 863         }
 864
 865         if (verbose > 0)
 866                 printf("Required parameter '%s' not specified\n", term->config);
 867
 868         return -1;
 869 }
 870
 871 static char *pmu_formats_string(struct list_head *formats)
 872 {
 873         struct perf_pmu_format *format;
 874         char *str = NULL;
 875         struct strbuf buf = STRBUF_INIT;
 876         unsigned i = 0;
 877
 878         if (!formats)
 879                 return NULL;
 880
 881         /* sysfs exported terms */
 882         list_for_each_entry(format, formats, list)
 883                 if (strbuf_addf(&buf, i++ ? ",%s" : "%s", format->name) < 0)
 884                         goto error;
 885
 886         str = strbuf_detach(&buf, NULL);
 887 error:
 888         strbuf_release(&buf);
 889
 890         return str;
 891 }
 892
 893 /*
 894  * Setup one of config[12] attr members based on the
 895  * user input data - term parameter.
 896  */
 897 static int pmu_config_term(struct list_head *formats,
 898                            struct perf_event_attr *attr,
 899                            struct parse_events_term *term,
 900                            struct list_head *head_terms,
 901                            bool zero, struct parse_events_error *err)
 902 {
 903         struct perf_pmu_format *format;
 904         __u64 *vp;
 905         __u64 val, max_val;
 906
 907         /*
 908          * If this is a parameter we've already used for parameterized-eval,
 909          * skip it in normal eval.
 910          */
 911         if (term->used)
 912                 return 0;
 913
 914         /*
 915          * Hardcoded terms should be already in, so nothing
 916          * to be done for them.
 917          */
 918         if (parse_events__is_hardcoded_term(term))
 919                 return 0;
 920
 921         format = pmu_find_format(formats, term->config);
 922         if (!format) {
 923                 if (verbose > 0)
 924                         printf("Invalid event/parameter '%s'\n", term->config);
 925                 if (err) {
 926                         char *pmu_term = pmu_formats_string(formats);
 927
 928                         err->idx  = term->err_term;
 929                         err->str  = strdup("unknown term");
 930                         err->help = parse_events_formats_error_string(pmu_term);
 931                         free(pmu_term);
 932                 }
 933                 return -EINVAL;
 934         }
 935
 936         switch (format->value) {
 937         case PERF_PMU_FORMAT_VALUE_CONFIG:
 938                 vp = &attr->config;
 939                 break;
 940         case PERF_PMU_FORMAT_VALUE_CONFIG1:
 941                 vp = &attr->config1;
 942                 break;
 943         case PERF_PMU_FORMAT_VALUE_CONFIG2:
 944                 vp = &attr->config2;
 945                 break;
 946         default:
 947                 return -EINVAL;
 948         }
 949
 950         /*
 951          * Either directly use a numeric term, or try to translate string terms
 952          * using event parameters.
 953          */
 954         if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
 955                 if (term->no_value &&
 956                     bitmap_weight(format->bits, PERF_PMU_FORMAT_BITS) > 1) {
 957                         if (err) {
 958                                 err->idx = term->err_val;
 959                                 err->str = strdup("no value assigned for term");
 960                         }
 961                         return -EINVAL;
 962                 }
 963
 964                 val = term->val.num;
 965         } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) {
 966                 if (strcmp(term->val.str, "?")) {
 967                         if (verbose > 0) {
 968                                 pr_info("Invalid sysfs entry %s=%s\n",
 969                                                 term->config, term->val.str);
 970                         }
 971                         if (err) {
 972                                 err->idx = term->err_val;
 973                                 err->str = strdup("expected numeric value");
 974                         }
 975                         return -EINVAL;
 976                 }
 977
 978                 if (pmu_resolve_param_term(term, head_terms, &val))
 979                         return -EINVAL;
 980         } else
 981                 return -EINVAL;
 982
 983         max_val = pmu_format_max_value(format->bits);
 984         if (val > max_val) {
 985                 if (err) {
 986                         err->idx = term->err_val;
 987                         if (asprintf(&err->str,
 988                                      "value too big for format, maximum is %llu",
 989                                      (unsigned long long)max_val) < 0)
 990                                 err->str = strdup("value too big for format");
 991                         return -EINVAL;
 992                 }
 993                 /*
 994                  * Assume we don't care if !err, in which case the value will be
 995                  * silently truncated.
 996                  */
 997         }
 998
 999         pmu_format_value(format->bits, val, vp, zero);
1000         return 0;
1001 }
1002
1003 int perf_pmu__config_terms(struct list_head *formats,
1004                            struct perf_event_attr *attr,
1005                            struct list_head *head_terms,
1006                            bool zero, struct parse_events_error *err)
1007 {
1008         struct parse_events_term *term;
1009
1010         list_for_each_entry(term, head_terms, list) {
1011                 if (pmu_config_term(formats, attr, term, head_terms,
1012                                     zero, err))
1013                         return -EINVAL;
1014         }
1015
1016         return 0;
1017 }
1018
1019 /*
1020  * Configures event's 'attr' parameter based on the:
1021  * 1) users input - specified in terms parameter
1022  * 2) pmu format definitions - specified by pmu parameter
1023  */
1024 int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr,
1025                      struct list_head *head_terms,
1026                      struct parse_events_error *err)
1027 {
1028         bool zero = !!pmu->default_config;
1029
1030         attr->type = pmu->type;
1031         return perf_pmu__config_terms(&pmu->format, attr, head_terms,
1032                                       zero, err);
1033 }
1034
1035 static struct perf_pmu_alias *pmu_find_alias(struct perf_pmu *pmu,
1036                                              struct parse_events_term *term)
1037 {
1038         struct perf_pmu_alias *alias;
1039         char *name;
1040
1041         if (parse_events__is_hardcoded_term(term))
1042                 return NULL;
1043
1044         if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
1045                 if (term->val.num != 1)
1046                         return NULL;
1047                 if (pmu_find_format(&pmu->format, term->config))
1048                         return NULL;
1049                 name = term->config;
1050         } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) {
1051                 if (strcasecmp(term->config, "event"))
1052                         return NULL;
1053                 name = term->val.str;
1054         } else {
1055                 return NULL;
1056         }
1057
1058         list_for_each_entry(alias, &pmu->aliases, list) {
1059                 if (!strcasecmp(alias->name, name))
1060                         return alias;
1061         }
1062         return NULL;
1063 }
1064
1065
1066 static int check_info_data(struct perf_pmu_alias *alias,
1067                            struct perf_pmu_info *info)
1068 {
1069         /*
1070          * Only one term in event definition can
1071          * define unit, scale and snapshot, fail
1072          * if there's more than one.
1073          */
1074         if ((info->unit && alias->unit[0]) ||
1075             (info->scale && alias->scale) ||
1076             (info->snapshot && alias->snapshot))
1077                 return -EINVAL;
1078
1079         if (alias->unit[0])
1080                 info->unit = alias->unit;
1081
1082         if (alias->scale)
1083                 info->scale = alias->scale;
1084
1085         if (alias->snapshot)
1086                 info->snapshot = alias->snapshot;
1087
1088         return 0;
1089 }
1090
1091 /*
1092  * Find alias in the terms list and replace it with the terms
1093  * defined for the alias
1094  */
1095 int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms,
1096                           struct perf_pmu_info *info)
1097 {
1098         struct parse_events_term *term, *h;
1099         struct perf_pmu_alias *alias;
1100         int ret;
1101
1102         info->per_pkg = false;
1103
1104         /*
1105          * Mark unit and scale as not set
1106          * (different from default values, see below)
1107          */
1108         info->unit     = NULL;
1109         info->scale    = 0.0;
1110         info->snapshot = false;
1111         info->metric_expr = NULL;
1112         info->metric_name = NULL;
1113
1114         list_for_each_entry_safe(term, h, head_terms, list) {
1115                 alias = pmu_find_alias(pmu, term);
1116                 if (!alias)
1117                         continue;
1118                 ret = pmu_alias_terms(alias, &term->list);
1119                 if (ret)
1120                         return ret;
1121
1122                 ret = check_info_data(alias, info);
1123                 if (ret)
1124                         return ret;
1125
1126                 if (alias->per_pkg)
1127                         info->per_pkg = true;
1128                 info->metric_expr = alias->metric_expr;
1129                 info->metric_name = alias->metric_name;
1130
1131                 list_del(&term->list);
1132                 free(term);
1133         }
1134
1135         /*
1136          * if no unit or scale foundin aliases, then
1137          * set defaults as for evsel
1138          * unit cannot left to NULL
1139          */
1140         if (info->unit == NULL)
1141                 info->unit   = "";
1142
1143         if (info->scale == 0.0)
1144                 info->scale  = 1.0;
1145
1146         return 0;
1147 }
1148
1149 int perf_pmu__new_format(struct list_head *list, char *name,
1150                          int config, unsigned long *bits)
1151 {
1152         struct perf_pmu_format *format;
1153
1154         format = zalloc(sizeof(*format));
1155         if (!format)
1156                 return -ENOMEM;
1157
1158         format->name = strdup(name);
1159         format->value = config;
1160         memcpy(format->bits, bits, sizeof(format->bits));
1161
1162         list_add_tail(&format->list, list);
1163         return 0;
1164 }
1165
1166 void perf_pmu__set_format(unsigned long *bits, long from, long to)
1167 {
1168         long b;
1169
1170         if (!to)
1171                 to = from;
1172
1173         memset(bits, 0, BITS_TO_BYTES(PERF_PMU_FORMAT_BITS));
1174         for (b = from; b <= to; b++)
1175                 set_bit(b, bits);
1176 }
1177
1178 static int sub_non_neg(int a, int b)
1179 {
1180         if (b > a)
1181                 return 0;
1182         return a - b;
1183 }
1184
1185 static char *format_alias(char *buf, int len, struct perf_pmu *pmu,
1186                           struct perf_pmu_alias *alias)
1187 {
1188         struct parse_events_term *term;
1189         int used = snprintf(buf, len, "%s/%s", pmu->name, alias->name);
1190
1191         list_for_each_entry(term, &alias->terms, list) {
1192                 if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR)
1193                         used += snprintf(buf + used, sub_non_neg(len, used),
1194                                         ",%s=%s", term->config,
1195                                         term->val.str);
1196         }
1197
1198         if (sub_non_neg(len, used) > 0) {
1199                 buf[used] = '/';
1200                 used++;
1201         }
1202         if (sub_non_neg(len, used) > 0) {
1203                 buf[used] = '\0';
1204                 used++;
1205         } else
1206                 buf[len - 1] = '\0';
1207
1208         return buf;
1209 }
1210
1211 static char *format_alias_or(char *buf, int len, struct perf_pmu *pmu,
1212                              struct perf_pmu_alias *alias)
1213 {
1214         snprintf(buf, len, "%s OR %s/%s/", alias->name, pmu->name, alias->name);
1215         return buf;
1216 }
1217
1218 struct sevent {
1219         char *name;
1220         char *desc;
1221         char *topic;
1222         char *str;
1223         char *pmu;
1224         char *metric_expr;
1225         char *metric_name;
1226 };
1227
1228 static int cmp_sevent(const void *a, const void *b)
1229 {
1230         const struct sevent *as = a;
1231         const struct sevent *bs = b;
1232
1233         /* Put extra events last */
1234         if (!!as->desc != !!bs->desc)
1235                 return !!as->desc - !!bs->desc;
1236         if (as->topic && bs->topic) {
1237                 int n = strcmp(as->topic, bs->topic);
1238
1239                 if (n)
1240                         return n;
1241         }
1242         return strcmp(as->name, bs->name);
1243 }
1244
1245 static void wordwrap(char *s, int start, int max, int corr)
1246 {
1247         int column = start;
1248         int n;
1249
1250         while (*s) {
1251                 int wlen = strcspn(s, " \t");
1252
1253                 if (column + wlen >= max && column > start) {
1254                         printf("\n%*s", start, "");
1255                         column = start + corr;
1256                 }
1257                 n = printf("%s%.*s", column > start ? " " : "", wlen, s);
1258                 if (n <= 0)
1259                         break;
1260                 s += wlen;
1261                 column += n;
1262                 s = ltrim(s);
1263         }
1264 }
1265
1266 void print_pmu_events(const char *event_glob, bool name_only, bool quiet_flag,
1267                         bool long_desc, bool details_flag)
1268 {
1269         struct perf_pmu *pmu;
1270         struct perf_pmu_alias *alias;
1271         char buf[1024];
1272         int printed = 0;
1273         int len, j;
1274         struct sevent *aliases;
1275         int numdesc = 0;
1276         int columns = pager_get_columns();
1277         char *topic = NULL;
1278
1279         pmu = NULL;
1280         len = 0;
1281         while ((pmu = perf_pmu__scan(pmu)) != NULL) {
1282                 list_for_each_entry(alias, &pmu->aliases, list)
1283                         len++;
1284                 if (pmu->selectable)
1285                         len++;
1286         }
1287         aliases = zalloc(sizeof(struct sevent) * len);
1288         if (!aliases)
1289                 goto out_enomem;
1290         pmu = NULL;
1291         j = 0;
1292         while ((pmu = perf_pmu__scan(pmu)) != NULL) {
1293                 list_for_each_entry(alias, &pmu->aliases, list) {
1294                         char *name = alias->desc ? alias->name :
1295                                 format_alias(buf, sizeof(buf), pmu, alias);
1296                         bool is_cpu = !strcmp(pmu->name, "cpu");
1297
1298                         if (event_glob != NULL &&
1299                             !(strglobmatch_nocase(name, event_glob) ||
1300                               (!is_cpu && strglobmatch_nocase(alias->name,
1301                                                        event_glob)) ||
1302                               (alias->topic &&
1303                                strglobmatch_nocase(alias->topic, event_glob))))
1304                                 continue;
1305
1306                         if (is_cpu && !name_only && !alias->desc)
1307                                 name = format_alias_or(buf, sizeof(buf), pmu, alias);
1308
1309                         aliases[j].name = name;
1310                         if (is_cpu && !name_only && !alias->desc)
1311                                 aliases[j].name = format_alias_or(buf,
1312                                                                   sizeof(buf),
1313                                                                   pmu, alias);
1314                         aliases[j].name = strdup(aliases[j].name);
1315                         if (!aliases[j].name)
1316                                 goto out_enomem;
1317
1318                         aliases[j].desc = long_desc ? alias->long_desc :
1319                                                 alias->desc;
1320                         aliases[j].topic = alias->topic;
1321                         aliases[j].str = alias->str;
1322                         aliases[j].pmu = pmu->name;
1323                         aliases[j].metric_expr = alias->metric_expr;
1324                         aliases[j].metric_name = alias->metric_name;
1325                         j++;
1326                 }
1327                 if (pmu->selectable &&
1328                     (event_glob == NULL || strglobmatch(pmu->name, event_glob))) {
1329                         char *s;
1330                         if (asprintf(&s, "%s//", pmu->name) < 0)
1331                                 goto out_enomem;
1332                         aliases[j].name = s;
1333                         j++;
1334                 }
1335         }
1336         len = j;
1337         qsort(aliases, len, sizeof(struct sevent), cmp_sevent);
1338         for (j = 0; j < len; j++) {
1339                 /* Skip duplicates */
1340                 if (j > 0 && !strcmp(aliases[j].name, aliases[j - 1].name))
1341                         continue;
1342                 if (name_only) {
1343                         printf("%s ", aliases[j].name);
1344                         continue;
1345                 }
1346                 if (aliases[j].desc && !quiet_flag) {
1347                         if (numdesc++ == 0)
1348                                 printf("\n");
1349                         if (aliases[j].topic && (!topic ||
1350                                         strcmp(topic, aliases[j].topic))) {
1351                                 printf("%s%s:\n", topic ? "\n" : "",
1352                                                 aliases[j].topic);
1353                                 topic = aliases[j].topic;
1354                         }
1355                         printf("  %-50s\n", aliases[j].name);
1356                         printf("%*s", 8, "[");
1357                         wordwrap(aliases[j].desc, 8, columns, 0);
1358                         printf("]\n");
1359                         if (details_flag) {
1360                                 printf("%*s%s/%s/ ", 8, "", aliases[j].pmu, aliases[j].str);
1361                                 if (aliases[j].metric_name)
1362                                         printf(" MetricName: %s", aliases[j].metric_name);
1363                                 if (aliases[j].metric_expr)
1364                                         printf(" MetricExpr: %s", aliases[j].metric_expr);
1365                                 putchar('\n');
1366                         }
1367                 } else
1368                         printf("  %-50s [Kernel PMU event]\n", aliases[j].name);
1369                 printed++;
1370         }
1371         if (printed && pager_in_use())
1372                 printf("\n");
1373 out_free:
1374         for (j = 0; j < len; j++)
1375                 zfree(&aliases[j].name);
1376         zfree(&aliases);
1377         return;
1378
1379 out_enomem:
1380         printf("FATAL: not enough memory to print PMU events\n");
1381         if (aliases)
1382                 goto out_free;
1383 }
1384
1385 bool pmu_have_event(const char *pname, const char *name)
1386 {
1387         struct perf_pmu *pmu;
1388         struct perf_pmu_alias *alias;
1389
1390         pmu = NULL;
1391         while ((pmu = perf_pmu__scan(pmu)) != NULL) {
1392                 if (strcmp(pname, pmu->name))
1393                         continue;
1394                 list_for_each_entry(alias, &pmu->aliases, list)
1395                         if (!strcmp(alias->name, name))
1396                                 return true;
1397         }
1398         return false;
1399 }
1400
1401 static FILE *perf_pmu__open_file(struct perf_pmu *pmu, const char *name)
1402 {
1403         struct stat st;
1404         char path[PATH_MAX];
1405         const char *sysfs;
1406
1407         sysfs = sysfs__mountpoint();
1408         if (!sysfs)
1409                 return NULL;
1410
1411         snprintf(path, PATH_MAX,
1412                  "%s" EVENT_SOURCE_DEVICE_PATH "%s/%s", sysfs, pmu->name, name);
1413
1414         if (stat(path, &st) < 0)
1415                 return NULL;
1416
1417         return fopen(path, "r");
1418 }
1419
1420 int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt,
1421                         ...)
1422 {
1423         va_list args;
1424         FILE *file;
1425         int ret = EOF;
1426
1427         va_start(args, fmt);
1428         file = perf_pmu__open_file(pmu, name);
1429         if (file) {
1430                 ret = vfscanf(file, fmt, args);
1431                 fclose(file);
1432         }
1433         va_end(args);
1434         return ret;
1435 }