tools/perf/util/pmus.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/list.h>
   3 #include <linux/zalloc.h>
   4 #include <subcmd/pager.h>
   5 #include <sys/types.h>
   6 #include <dirent.h>
   7 #include <pthread.h>
   8 #include <string.h>
   9 #include <unistd.h>
  10 #include "debug.h"
  11 #include "evsel.h"
  12 #include "pmus.h"
  13 #include "pmu.h"
  14 #include "print-events.h"
  15
  16 /*
  17  * core_pmus:  A PMU belongs to core_pmus if it's name is "cpu" or it's sysfs
  18  *             directory contains "cpus" file. All PMUs belonging to core_pmus
  19  *             must have pmu->is_core=1. If there are more than one PMU in
  20  *             this list, perf interprets it as a heterogeneous platform.
  21  *             (FWIW, certain ARM platforms having heterogeneous cores uses
  22  *             homogeneous PMU, and thus they are treated as homogeneous
  23  *             platform by perf because core_pmus will have only one entry)
  24  * other_pmus: All other PMUs which are not part of core_pmus list. It doesn't
  25  *             matter whether PMU is present per SMT-thread or outside of the
  26  *             core in the hw. For e.g., an instance of AMD ibs_fetch// and
  27  *             ibs_op// PMUs is present in each hw SMT thread, however they
  28  *             are captured under other_pmus. PMUs belonging to other_pmus
  29  *             must have pmu->is_core=0 but pmu->is_uncore could be 0 or 1.
  30  */
  31 static LIST_HEAD(core_pmus);
  32 static LIST_HEAD(other_pmus);
  33 static bool read_sysfs_core_pmus;
  34 static bool read_sysfs_all_pmus;
  35
  36 void perf_pmus__destroy(void)
  37 {
  38         struct perf_pmu *pmu, *tmp;
  39
  40         list_for_each_entry_safe(pmu, tmp, &core_pmus, list) {
  41                 list_del(&pmu->list);
  42
  43                 perf_pmu__delete(pmu);
  44         }
  45         list_for_each_entry_safe(pmu, tmp, &other_pmus, list) {
  46                 list_del(&pmu->list);
  47
  48                 perf_pmu__delete(pmu);
  49         }
  50         read_sysfs_core_pmus = false;
  51         read_sysfs_all_pmus = false;
  52 }
  53
  54 static struct perf_pmu *pmu_find(const char *name)
  55 {
  56         struct perf_pmu *pmu;
  57
  58         list_for_each_entry(pmu, &core_pmus, list) {
  59                 if (!strcmp(pmu->name, name) ||
  60                     (pmu->alias_name && !strcmp(pmu->alias_name, name)))
  61                         return pmu;
  62         }
  63         list_for_each_entry(pmu, &other_pmus, list) {
  64                 if (!strcmp(pmu->name, name) ||
  65                     (pmu->alias_name && !strcmp(pmu->alias_name, name)))
  66                         return pmu;
  67         }
  68
  69         return NULL;
  70 }
  71
  72 struct perf_pmu *perf_pmus__find(const char *name)
  73 {
  74         struct perf_pmu *pmu;
  75         int dirfd;
  76         bool core_pmu;
  77
  78         /*
  79          * Once PMU is loaded it stays in the list,
  80          * so we keep us from multiple reading/parsing
  81          * the pmu format definitions.
  82          */
  83         pmu = pmu_find(name);
  84         if (pmu)
  85                 return pmu;
  86
  87         if (read_sysfs_all_pmus)
  88                 return NULL;
  89
  90         core_pmu = is_pmu_core(name);
  91         if (core_pmu && read_sysfs_core_pmus)
  92                 return NULL;
  93
  94         dirfd = perf_pmu__event_source_devices_fd();
  95         pmu = perf_pmu__lookup(core_pmu ? &core_pmus : &other_pmus, dirfd, name);
  96         close(dirfd);
  97
  98         return pmu;
  99 }
 100
 101 static struct perf_pmu *perf_pmu__find2(int dirfd, const char *name)
 102 {
 103         struct perf_pmu *pmu;
 104         bool core_pmu;
 105
 106         /*
 107          * Once PMU is loaded it stays in the list,
 108          * so we keep us from multiple reading/parsing
 109          * the pmu format definitions.
 110          */
 111         pmu = pmu_find(name);
 112         if (pmu)
 113                 return pmu;
 114
 115         if (read_sysfs_all_pmus)
 116                 return NULL;
 117
 118         core_pmu = is_pmu_core(name);
 119         if (core_pmu && read_sysfs_core_pmus)
 120                 return NULL;
 121
 122         return perf_pmu__lookup(core_pmu ? &core_pmus : &other_pmus, dirfd, name);
 123 }
 124
 125 /* Add all pmus in sysfs to pmu list: */
 126 static void pmu_read_sysfs(bool core_only)
 127 {
 128         int fd;
 129         DIR *dir;
 130         struct dirent *dent;
 131
 132         if (read_sysfs_all_pmus || (core_only && read_sysfs_core_pmus))
 133                 return;
 134
 135         fd = perf_pmu__event_source_devices_fd();
 136         if (fd < 0)
 137                 return;
 138
 139         dir = fdopendir(fd);
 140         if (!dir) {
 141                 close(fd);
 142                 return;
 143         }
 144
 145         while ((dent = readdir(dir))) {
 146                 if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, ".."))
 147                         continue;
 148                 if (core_only && !is_pmu_core(dent->d_name))
 149                         continue;
 150                 /* add to static LIST_HEAD(core_pmus) or LIST_HEAD(other_pmus): */
 151                 perf_pmu__find2(fd, dent->d_name);
 152         }
 153
 154         closedir(dir);
 155         if (core_only) {
 156                 if (!list_empty(&core_pmus))
 157                         read_sysfs_core_pmus = true;
 158                 else {
 159                         if (perf_pmu__create_placeholder_core_pmu(&core_pmus))
 160                                 read_sysfs_core_pmus = true;
 161                 }
 162         } else {
 163                 read_sysfs_core_pmus = true;
 164                 read_sysfs_all_pmus = true;
 165         }
 166 }
 167
 168 static struct perf_pmu *__perf_pmus__find_by_type(unsigned int type)
 169 {
 170         struct perf_pmu *pmu;
 171
 172         list_for_each_entry(pmu, &core_pmus, list) {
 173                 if (pmu->type == type)
 174                         return pmu;
 175         }
 176
 177         list_for_each_entry(pmu, &other_pmus, list) {
 178                 if (pmu->type == type)
 179                         return pmu;
 180         }
 181         return NULL;
 182 }
 183
 184 struct perf_pmu *perf_pmus__find_by_type(unsigned int type)
 185 {
 186         struct perf_pmu *pmu = __perf_pmus__find_by_type(type);
 187
 188         if (pmu || read_sysfs_all_pmus)
 189                 return pmu;
 190
 191         pmu_read_sysfs(/*core_only=*/false);
 192         pmu = __perf_pmus__find_by_type(type);
 193         return pmu;
 194 }
 195
 196 /*
 197  * pmu iterator: If pmu is NULL, we start at the begin, otherwise return the
 198  * next pmu. Returns NULL on end.
 199  */
 200 struct perf_pmu *perf_pmus__scan(struct perf_pmu *pmu)
 201 {
 202         bool use_core_pmus = !pmu || pmu->is_core;
 203
 204         if (!pmu) {
 205                 pmu_read_sysfs(/*core_only=*/false);
 206                 pmu = list_prepare_entry(pmu, &core_pmus, list);
 207         }
 208         if (use_core_pmus) {
 209                 list_for_each_entry_continue(pmu, &core_pmus, list)
 210                         return pmu;
 211
 212                 pmu = NULL;
 213                 pmu = list_prepare_entry(pmu, &other_pmus, list);
 214         }
 215         list_for_each_entry_continue(pmu, &other_pmus, list)
 216                 return pmu;
 217         return NULL;
 218 }
 219
 220 struct perf_pmu *perf_pmus__scan_core(struct perf_pmu *pmu)
 221 {
 222         if (!pmu) {
 223                 pmu_read_sysfs(/*core_only=*/true);
 224                 pmu = list_prepare_entry(pmu, &core_pmus, list);
 225         }
 226         list_for_each_entry_continue(pmu, &core_pmus, list)
 227                 return pmu;
 228
 229         return NULL;
 230 }
 231
 232 const struct perf_pmu *perf_pmus__pmu_for_pmu_filter(const char *str)
 233 {
 234         struct perf_pmu *pmu = NULL;
 235
 236         while ((pmu = perf_pmus__scan(pmu)) != NULL) {
 237                 if (!strcmp(pmu->name, str))
 238                         return pmu;
 239                 /* Ignore "uncore_" prefix. */
 240                 if (!strncmp(pmu->name, "uncore_", 7)) {
 241                         if (!strcmp(pmu->name + 7, str))
 242                                 return pmu;
 243                 }
 244                 /* Ignore "cpu_" prefix on Intel hybrid PMUs. */
 245                 if (!strncmp(pmu->name, "cpu_", 4)) {
 246                         if (!strcmp(pmu->name + 4, str))
 247                                 return pmu;
 248                 }
 249         }
 250         return NULL;
 251 }
 252
 253 int __weak perf_pmus__num_mem_pmus(void)
 254 {
 255         /* All core PMUs are for mem events. */
 256         return perf_pmus__num_core_pmus();
 257 }
 258
 259 /** Struct for ordering events as output in perf list. */
 260 struct sevent {
 261         /** PMU for event. */
 262         const struct perf_pmu *pmu;
 263         /**
 264          * Optional event for name, desc, etc. If not present then this is a
 265          * selectable PMU and the event name is shown as "//".
 266          */
 267         const struct perf_pmu_alias *event;
 268         /** Is the PMU for the CPU? */
 269         bool is_cpu;
 270 };
 271
 272 static int cmp_sevent(const void *a, const void *b)
 273 {
 274         const struct sevent *as = a;
 275         const struct sevent *bs = b;
 276         const char *a_pmu_name = NULL, *b_pmu_name = NULL;
 277         const char *a_name = "//", *a_desc = NULL, *a_topic = "";
 278         const char *b_name = "//", *b_desc = NULL, *b_topic = "";
 279         int ret;
 280
 281         if (as->event) {
 282                 a_name = as->event->name;
 283                 a_desc = as->event->desc;
 284                 a_topic = as->event->topic ?: "";
 285                 a_pmu_name = as->event->pmu_name;
 286         }
 287         if (bs->event) {
 288                 b_name = bs->event->name;
 289                 b_desc = bs->event->desc;
 290                 b_topic = bs->event->topic ?: "";
 291                 b_pmu_name = bs->event->pmu_name;
 292         }
 293         /* Put extra events last. */
 294         if (!!a_desc != !!b_desc)
 295                 return !!a_desc - !!b_desc;
 296
 297         /* Order by topics. */
 298         ret = strcmp(a_topic, b_topic);
 299         if (ret)
 300                 return ret;
 301
 302         /* Order CPU core events to be first */
 303         if (as->is_cpu != bs->is_cpu)
 304                 return as->is_cpu ? -1 : 1;
 305
 306         /* Order by PMU name. */
 307         if (as->pmu != bs->pmu) {
 308                 a_pmu_name = a_pmu_name ?: (as->pmu->name ?: "");
 309                 b_pmu_name = b_pmu_name ?: (bs->pmu->name ?: "");
 310                 ret = strcmp(a_pmu_name, b_pmu_name);
 311                 if (ret)
 312                         return ret;
 313         }
 314
 315         /* Order by event name. */
 316         return strcmp(a_name, b_name);
 317 }
 318
 319 static bool pmu_alias_is_duplicate(struct sevent *alias_a,
 320                                    struct sevent *alias_b)
 321 {
 322         const char *a_pmu_name = NULL, *b_pmu_name = NULL;
 323         const char *a_name = "//", *b_name = "//";
 324
 325
 326         if (alias_a->event) {
 327                 a_name = alias_a->event->name;
 328                 a_pmu_name = alias_a->event->pmu_name;
 329         }
 330         if (alias_b->event) {
 331                 b_name = alias_b->event->name;
 332                 b_pmu_name = alias_b->event->pmu_name;
 333         }
 334
 335         /* Different names -> never duplicates */
 336         if (strcmp(a_name, b_name))
 337                 return false;
 338
 339         /* Don't remove duplicates for different PMUs */
 340         a_pmu_name = a_pmu_name ?: (alias_a->pmu->name ?: "");
 341         b_pmu_name = b_pmu_name ?: (alias_b->pmu->name ?: "");
 342         return strcmp(a_pmu_name, b_pmu_name) == 0;
 343 }
 344
 345 static int sub_non_neg(int a, int b)
 346 {
 347         if (b > a)
 348                 return 0;
 349         return a - b;
 350 }
 351
 352 static char *format_alias(char *buf, int len, const struct perf_pmu *pmu,
 353                           const struct perf_pmu_alias *alias)
 354 {
 355         struct parse_events_term *term;
 356         int used = snprintf(buf, len, "%s/%s", pmu->name, alias->name);
 357
 358         list_for_each_entry(term, &alias->terms, list) {
 359                 if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR)
 360                         used += snprintf(buf + used, sub_non_neg(len, used),
 361                                         ",%s=%s", term->config,
 362                                         term->val.str);
 363         }
 364
 365         if (sub_non_neg(len, used) > 0) {
 366                 buf[used] = '/';
 367                 used++;
 368         }
 369         if (sub_non_neg(len, used) > 0) {
 370                 buf[used] = '\0';
 371                 used++;
 372         } else
 373                 buf[len - 1] = '\0';
 374
 375         return buf;
 376 }
 377
 378 void perf_pmus__print_pmu_events(const struct print_callbacks *print_cb, void *print_state)
 379 {
 380         struct perf_pmu *pmu;
 381         struct perf_pmu_alias *event;
 382         char buf[1024];
 383         int printed = 0;
 384         int len, j;
 385         struct sevent *aliases;
 386
 387         pmu = NULL;
 388         len = 0;
 389         while ((pmu = perf_pmus__scan(pmu)) != NULL) {
 390                 list_for_each_entry(event, &pmu->aliases, list)
 391                         len++;
 392                 if (pmu->selectable)
 393                         len++;
 394         }
 395         aliases = zalloc(sizeof(struct sevent) * len);
 396         if (!aliases) {
 397                 pr_err("FATAL: not enough memory to print PMU events\n");
 398                 return;
 399         }
 400         pmu = NULL;
 401         j = 0;
 402         while ((pmu = perf_pmus__scan(pmu)) != NULL) {
 403                 bool is_cpu = pmu->is_core;
 404
 405                 list_for_each_entry(event, &pmu->aliases, list) {
 406                         aliases[j].event = event;
 407                         aliases[j].pmu = pmu;
 408                         aliases[j].is_cpu = is_cpu;
 409                         j++;
 410                 }
 411                 if (pmu->selectable) {
 412                         aliases[j].event = NULL;
 413                         aliases[j].pmu = pmu;
 414                         aliases[j].is_cpu = is_cpu;
 415                         j++;
 416                 }
 417         }
 418         len = j;
 419         qsort(aliases, len, sizeof(struct sevent), cmp_sevent);
 420         for (j = 0; j < len; j++) {
 421                 const char *name, *alias = NULL, *scale_unit = NULL,
 422                         *desc = NULL, *long_desc = NULL,
 423                         *encoding_desc = NULL, *topic = NULL,
 424                         *pmu_name = NULL;
 425                 bool deprecated = false;
 426                 size_t buf_used;
 427
 428                 /* Skip duplicates */
 429                 if (j > 0 && pmu_alias_is_duplicate(&aliases[j], &aliases[j - 1]))
 430                         continue;
 431
 432                 if (!aliases[j].event) {
 433                         /* A selectable event. */
 434                         pmu_name = aliases[j].pmu->name;
 435                         buf_used = snprintf(buf, sizeof(buf), "%s//", pmu_name) + 1;
 436                         name = buf;
 437                 } else {
 438                         if (aliases[j].event->desc) {
 439                                 name = aliases[j].event->name;
 440                                 buf_used = 0;
 441                         } else {
 442                                 name = format_alias(buf, sizeof(buf), aliases[j].pmu,
 443                                                     aliases[j].event);
 444                                 if (aliases[j].is_cpu) {
 445                                         alias = name;
 446                                         name = aliases[j].event->name;
 447                                 }
 448                                 buf_used = strlen(buf) + 1;
 449                         }
 450                         pmu_name = aliases[j].event->pmu_name ?: (aliases[j].pmu->name ?: "");
 451                         if (strlen(aliases[j].event->unit) || aliases[j].event->scale != 1.0) {
 452                                 scale_unit = buf + buf_used;
 453                                 buf_used += snprintf(buf + buf_used, sizeof(buf) - buf_used,
 454                                                 "%G%s", aliases[j].event->scale,
 455                                                 aliases[j].event->unit) + 1;
 456                         }
 457                         desc = aliases[j].event->desc;
 458                         long_desc = aliases[j].event->long_desc;
 459                         topic = aliases[j].event->topic;
 460                         encoding_desc = buf + buf_used;
 461                         buf_used += snprintf(buf + buf_used, sizeof(buf) - buf_used,
 462                                         "%s/%s/", pmu_name, aliases[j].event->str) + 1;
 463                         deprecated = aliases[j].event->deprecated;
 464                 }
 465                 print_cb->print_event(print_state,
 466                                 pmu_name,
 467                                 topic,
 468                                 name,
 469                                 alias,
 470                                 scale_unit,
 471                                 deprecated,
 472                                 "Kernel PMU event",
 473                                 desc,
 474                                 long_desc,
 475                                 encoding_desc);
 476         }
 477         if (printed && pager_in_use())
 478                 printf("\n");
 479
 480         zfree(&aliases);
 481 }
 482
 483 bool perf_pmus__have_event(const char *pname, const char *name)
 484 {
 485         struct perf_pmu *pmu = perf_pmus__find(pname);
 486
 487         return pmu && perf_pmu__have_event(pmu, name);
 488 }
 489
 490 int perf_pmus__num_core_pmus(void)
 491 {
 492         static int count;
 493
 494         if (!count) {
 495                 struct perf_pmu *pmu = NULL;
 496
 497                 while ((pmu = perf_pmus__scan_core(pmu)) != NULL)
 498                         count++;
 499         }
 500         return count;
 501 }
 502
 503 static bool __perf_pmus__supports_extended_type(void)
 504 {
 505         struct perf_pmu *pmu = NULL;
 506
 507         if (perf_pmus__num_core_pmus() <= 1)
 508                 return false;
 509
 510         while ((pmu = perf_pmus__scan_core(pmu)) != NULL) {
 511                 if (!is_event_supported(PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES | ((__u64)pmu->type << PERF_PMU_TYPE_SHIFT)))
 512                         return false;
 513         }
 514
 515         return true;
 516 }
 517
 518 static bool perf_pmus__do_support_extended_type;
 519
 520 static void perf_pmus__init_supports_extended_type(void)
 521 {
 522         perf_pmus__do_support_extended_type = __perf_pmus__supports_extended_type();
 523 }
 524
 525 bool perf_pmus__supports_extended_type(void)
 526 {
 527         static pthread_once_t extended_type_once = PTHREAD_ONCE_INIT;
 528
 529         pthread_once(&extended_type_once, perf_pmus__init_supports_extended_type);
 530
 531         return perf_pmus__do_support_extended_type;
 532 }
 533
 534 char *perf_pmus__default_pmu_name(void)
 535 {
 536         int fd;
 537         DIR *dir;
 538         struct dirent *dent;
 539         char *result = NULL;
 540
 541         if (!list_empty(&core_pmus))
 542                 return strdup(list_first_entry(&core_pmus, struct perf_pmu, list)->name);
 543
 544         fd = perf_pmu__event_source_devices_fd();
 545         if (fd < 0)
 546                 return strdup("cpu");
 547
 548         dir = fdopendir(fd);
 549         if (!dir) {
 550                 close(fd);
 551                 return strdup("cpu");
 552         }
 553
 554         while ((dent = readdir(dir))) {
 555                 if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, ".."))
 556                         continue;
 557                 if (is_pmu_core(dent->d_name)) {
 558                         result = strdup(dent->d_name);
 559                         break;
 560                 }
 561         }
 562
 563         closedir(dir);
 564         return result ?: strdup("cpu");
 565 }
 566
 567 struct perf_pmu *evsel__find_pmu(const struct evsel *evsel)
 568 {
 569         struct perf_pmu *pmu = evsel->pmu;
 570
 571         if (!pmu) {
 572                 pmu = perf_pmus__find_by_type(evsel->core.attr.type);
 573                 ((struct evsel *)evsel)->pmu = pmu;
 574         }
 575         return pmu;
 576 }