tools/perf/builtin-list.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * builtin-list.c
   4  *
   5  * Builtin list command: list all event types
   6  *
   7  * Copyright (C) 2009, Thomas Gleixner <[email protected]>
   8  * Copyright (C) 2008-2009, Red Hat Inc, Ingo Molnar <[email protected]>
   9  * Copyright (C) 2011, Red Hat Inc, Arnaldo Carvalho de Melo <[email protected]>
  10  */
  11 #include "builtin.h"
  12
  13 #include "util/print-events.h"
  14 #include "util/pmu.h"
  15 #include "util/pmu-hybrid.h"
  16 #include "util/debug.h"
  17 #include "util/metricgroup.h"
  18 #include "util/string2.h"
  19 #include "util/strlist.h"
  20 #include "util/strbuf.h"
  21 #include <subcmd/pager.h>
  22 #include <subcmd/parse-options.h>
  23 #include <linux/zalloc.h>
  24 #include <stdarg.h>
  25 #include <stdio.h>
  26
  27 /**
  28  * struct print_state - State and configuration passed to the default_print
  29  * functions.
  30  */
  31 struct print_state {
  32         /**
  33          * @pmu_glob: Optionally restrict PMU and metric matching to PMU or
  34          * debugfs subsystem name.
  35          */
  36         char *pmu_glob;
  37         /** @event_glob: Optional pattern matching glob. */
  38         char *event_glob;
  39         /** @name_only: Print event or metric names only. */
  40         bool name_only;
  41         /** @desc: Print the event or metric description. */
  42         bool desc;
  43         /** @long_desc: Print longer event or metric description. */
  44         bool long_desc;
  45         /** @deprecated: Print deprecated events or metrics. */
  46         bool deprecated;
  47         /**
  48          * @detailed: Print extra information on the perf event such as names
  49          * and expressions used internally by events.
  50          */
  51         bool detailed;
  52         /** @metrics: Controls printing of metric and metric groups. */
  53         bool metrics;
  54         /** @metricgroups: Controls printing of metric and metric groups. */
  55         bool metricgroups;
  56         /** @last_topic: The last printed event topic. */
  57         char *last_topic;
  58         /** @last_metricgroups: The last printed metric group. */
  59         char *last_metricgroups;
  60         /** @visited_metrics: Metrics that are printed to avoid duplicates. */
  61         struct strlist *visited_metrics;
  62 };
  63
  64 static void default_print_start(void *ps)
  65 {
  66         struct print_state *print_state = ps;
  67
  68         if (!print_state->name_only && pager_in_use())
  69                 printf("\nList of pre-defined events (to be used in -e or -M):\n\n");
  70 }
  71
  72 static void default_print_end(void *print_state __maybe_unused) {}
  73
  74 static void wordwrap(const char *s, int start, int max, int corr)
  75 {
  76         int column = start;
  77         int n;
  78         bool saw_newline = false;
  79
  80         while (*s) {
  81                 int wlen = strcspn(s, " \t\n");
  82
  83                 if ((column + wlen >= max && column > start) || saw_newline) {
  84                         printf("\n%*s", start, "");
  85                         column = start + corr;
  86                 }
  87                 n = printf("%s%.*s", column > start ? " " : "", wlen, s);
  88                 if (n <= 0)
  89                         break;
  90                 saw_newline = s[wlen] == '\n';
  91                 s += wlen;
  92                 column += n;
  93                 s = skip_spaces(s);
  94         }
  95 }
  96
  97 static void default_print_event(void *ps, const char *pmu_name, const char *topic,
  98                                 const char *event_name, const char *event_alias,
  99                                 const char *scale_unit __maybe_unused,
 100                                 bool deprecated, const char *event_type_desc,
 101                                 const char *desc, const char *long_desc,
 102                                 const char *encoding_desc,
 103                                 const char *metric_name, const char *metric_expr)
 104 {
 105         struct print_state *print_state = ps;
 106         int pos;
 107
 108         if (deprecated && !print_state->deprecated)
 109                 return;
 110
 111         if (print_state->pmu_glob && pmu_name && !strglobmatch(pmu_name, print_state->pmu_glob))
 112                 return;
 113
 114         if (print_state->event_glob &&
 115             (!event_name || !strglobmatch(event_name, print_state->event_glob)) &&
 116             (!event_alias || !strglobmatch(event_alias, print_state->event_glob)) &&
 117             (!topic || !strglobmatch_nocase(topic, print_state->event_glob)))
 118                 return;
 119
 120         if (print_state->name_only) {
 121                 if (event_alias && strlen(event_alias))
 122                         printf("%s ", event_alias);
 123                 else
 124                         printf("%s ", event_name);
 125                 return;
 126         }
 127
 128         if (strcmp(print_state->last_topic, topic ?: "")) {
 129                 if (topic)
 130                         printf("\n%s:\n", topic);
 131                 free(print_state->last_topic);
 132                 print_state->last_topic = strdup(topic ?: "");
 133         }
 134
 135         if (event_alias && strlen(event_alias))
 136                 pos = printf("  %s OR %s", event_name, event_alias);
 137         else
 138                 pos = printf("  %s", event_name);
 139
 140         if (!topic && event_type_desc) {
 141                 for (; pos < 53; pos++)
 142                         putchar(' ');
 143                 printf("[%s]\n", event_type_desc);
 144         } else
 145                 putchar('\n');
 146
 147         if (desc && print_state->desc) {
 148                 printf("%*s", 8, "[");
 149                 wordwrap(desc, 8, pager_get_columns(), 0);
 150                 printf("]\n");
 151         }
 152         long_desc = long_desc ?: desc;
 153         if (long_desc && print_state->long_desc) {
 154                 printf("%*s", 8, "[");
 155                 wordwrap(long_desc, 8, pager_get_columns(), 0);
 156                 printf("]\n");
 157         }
 158
 159         if (print_state->detailed && encoding_desc) {
 160                 printf("%*s", 8, "");
 161                 wordwrap(encoding_desc, 8, pager_get_columns(), 0);
 162                 if (metric_name)
 163                         printf(" MetricName: %s", metric_name);
 164                 if (metric_expr)
 165                         printf(" MetricExpr: %s", metric_expr);
 166                 putchar('\n');
 167         }
 168 }
 169
 170 static void default_print_metric(void *ps,
 171                                 const char *group,
 172                                 const char *name,
 173                                 const char *desc,
 174                                 const char *long_desc,
 175                                 const char *expr,
 176                                 const char *unit __maybe_unused)
 177 {
 178         struct print_state *print_state = ps;
 179
 180         if (print_state->event_glob &&
 181             (!print_state->metrics || !name || !strglobmatch(name, print_state->event_glob)) &&
 182             (!print_state->metricgroups || !group || !strglobmatch(group, print_state->event_glob)))
 183                 return;
 184
 185         if (!print_state->name_only && !print_state->last_metricgroups) {
 186                 if (print_state->metricgroups) {
 187                         printf("\nMetric Groups:\n");
 188                         if (!print_state->metrics)
 189                                 putchar('\n');
 190                 } else {
 191                         printf("\nMetrics:\n\n");
 192                 }
 193         }
 194         if (!print_state->last_metricgroups ||
 195             strcmp(print_state->last_metricgroups, group ?: "")) {
 196                 if (group && print_state->metricgroups) {
 197                         if (print_state->name_only)
 198                                 printf("%s ", group);
 199                         else if (print_state->metrics)
 200                                 printf("\n%s:\n", group);
 201                         else
 202                                 printf("%s\n", group);
 203                 }
 204                 free(print_state->last_metricgroups);
 205                 print_state->last_metricgroups = strdup(group ?: "");
 206         }
 207         if (!print_state->metrics)
 208                 return;
 209
 210         if (print_state->name_only) {
 211                 if (print_state->metrics &&
 212                     !strlist__has_entry(print_state->visited_metrics, name)) {
 213                         printf("%s ", name);
 214                         strlist__add(print_state->visited_metrics, name);
 215                 }
 216                 return;
 217         }
 218         printf("  %s\n", name);
 219
 220         if (desc && print_state->desc) {
 221                 printf("%*s", 8, "[");
 222                 wordwrap(desc, 8, pager_get_columns(), 0);
 223                 printf("]\n");
 224         }
 225         if (long_desc && print_state->long_desc) {
 226                 printf("%*s", 8, "[");
 227                 wordwrap(long_desc, 8, pager_get_columns(), 0);
 228                 printf("]\n");
 229         }
 230         if (expr && print_state->detailed) {
 231                 printf("%*s", 8, "[");
 232                 wordwrap(expr, 8, pager_get_columns(), 0);
 233                 printf("]\n");
 234         }
 235 }
 236
 237 struct json_print_state {
 238         /** Should a separator be printed prior to the next item? */
 239         bool need_sep;
 240 };
 241
 242 static void json_print_start(void *print_state __maybe_unused)
 243 {
 244         printf("[\n");
 245 }
 246
 247 static void json_print_end(void *ps)
 248 {
 249         struct json_print_state *print_state = ps;
 250
 251         printf("%s]\n", print_state->need_sep ? "\n" : "");
 252 }
 253
 254 static void fix_escape_printf(struct strbuf *buf, const char *fmt, ...)
 255 {
 256         va_list args;
 257
 258         va_start(args, fmt);
 259         strbuf_setlen(buf, 0);
 260         for (size_t fmt_pos = 0; fmt_pos < strlen(fmt); fmt_pos++) {
 261                 switch (fmt[fmt_pos]) {
 262                 case '%':
 263                         fmt_pos++;
 264                         switch (fmt[fmt_pos]) {
 265                         case 's': {
 266                                 const char *s = va_arg(args, const char*);
 267
 268                                 strbuf_addstr(buf, s);
 269                                 break;
 270                         }
 271                         case 'S': {
 272                                 const char *s = va_arg(args, const char*);
 273
 274                                 for (size_t s_pos = 0; s_pos < strlen(s); s_pos++) {
 275                                         switch (s[s_pos]) {
 276                                         case '\n':
 277                                                 strbuf_addstr(buf, "\\n");
 278                                                 break;
 279                                         case '\\':
 280                                                 __fallthrough;
 281                                         case '\"':
 282                                                 strbuf_addch(buf, '\\');
 283                                                 __fallthrough;
 284                                         default:
 285                                                 strbuf_addch(buf, s[s_pos]);
 286                                                 break;
 287                                         }
 288                                 }
 289                                 break;
 290                         }
 291                         default:
 292                                 pr_err("Unexpected format character '%c'\n", fmt[fmt_pos]);
 293                                 strbuf_addch(buf, '%');
 294                                 strbuf_addch(buf, fmt[fmt_pos]);
 295                         }
 296                         break;
 297                 default:
 298                         strbuf_addch(buf, fmt[fmt_pos]);
 299                         break;
 300                 }
 301         }
 302         va_end(args);
 303         fputs(buf->buf, stdout);
 304 }
 305
 306 static void json_print_event(void *ps, const char *pmu_name, const char *topic,
 307                              const char *event_name, const char *event_alias,
 308                              const char *scale_unit,
 309                              bool deprecated, const char *event_type_desc,
 310                              const char *desc, const char *long_desc,
 311                              const char *encoding_desc,
 312                              const char *metric_name, const char *metric_expr)
 313 {
 314         struct json_print_state *print_state = ps;
 315         bool need_sep = false;
 316         struct strbuf buf;
 317
 318         strbuf_init(&buf, 0);
 319         printf("%s{\n", print_state->need_sep ? ",\n" : "");
 320         print_state->need_sep = true;
 321         if (pmu_name) {
 322                 fix_escape_printf(&buf, "\t\"Unit\": \"%S\"", pmu_name);
 323                 need_sep = true;
 324         }
 325         if (topic) {
 326                 fix_escape_printf(&buf, "%s\t\"Topic\": \"%S\"", need_sep ? ",\n" : "", topic);
 327                 need_sep = true;
 328         }
 329         if (event_name) {
 330                 fix_escape_printf(&buf, "%s\t\"EventName\": \"%S\"", need_sep ? ",\n" : "",
 331                                   event_name);
 332                 need_sep = true;
 333         }
 334         if (event_alias && strlen(event_alias)) {
 335                 fix_escape_printf(&buf, "%s\t\"EventAlias\": \"%S\"", need_sep ? ",\n" : "",
 336                                   event_alias);
 337                 need_sep = true;
 338         }
 339         if (scale_unit && strlen(scale_unit)) {
 340                 fix_escape_printf(&buf, "%s\t\"ScaleUnit\": \"%S\"", need_sep ? ",\n" : "",
 341                                   scale_unit);
 342                 need_sep = true;
 343         }
 344         if (event_type_desc) {
 345                 fix_escape_printf(&buf, "%s\t\"EventType\": \"%S\"", need_sep ? ",\n" : "",
 346                                   event_type_desc);
 347                 need_sep = true;
 348         }
 349         if (deprecated) {
 350                 fix_escape_printf(&buf, "%s\t\"Deprecated\": \"%S\"", need_sep ? ",\n" : "",
 351                                   deprecated ? "1" : "0");
 352                 need_sep = true;
 353         }
 354         if (desc) {
 355                 fix_escape_printf(&buf, "%s\t\"BriefDescription\": \"%S\"", need_sep ? ",\n" : "",
 356                                   desc);
 357                 need_sep = true;
 358         }
 359         if (long_desc) {
 360                 fix_escape_printf(&buf, "%s\t\"PublicDescription\": \"%S\"", need_sep ? ",\n" : "",
 361                                   long_desc);
 362                 need_sep = true;
 363         }
 364         if (encoding_desc) {
 365                 fix_escape_printf(&buf, "%s\t\"Encoding\": \"%S\"", need_sep ? ",\n" : "",
 366                                   encoding_desc);
 367                 need_sep = true;
 368         }
 369         if (metric_name) {
 370                 fix_escape_printf(&buf, "%s\t\"MetricName\": \"%S\"", need_sep ? ",\n" : "",
 371                                   metric_name);
 372                 need_sep = true;
 373         }
 374         if (metric_expr) {
 375                 fix_escape_printf(&buf, "%s\t\"MetricExpr\": \"%S\"", need_sep ? ",\n" : "",
 376                                   metric_expr);
 377                 need_sep = true;
 378         }
 379         printf("%s}", need_sep ? "\n" : "");
 380         strbuf_release(&buf);
 381 }
 382
 383 static void json_print_metric(void *ps __maybe_unused, const char *group,
 384                               const char *name, const char *desc,
 385                               const char *long_desc, const char *expr,
 386                               const char *unit)
 387 {
 388         struct json_print_state *print_state = ps;
 389         bool need_sep = false;
 390         struct strbuf buf;
 391
 392         strbuf_init(&buf, 0);
 393         printf("%s{\n", print_state->need_sep ? ",\n" : "");
 394         print_state->need_sep = true;
 395         if (group) {
 396                 fix_escape_printf(&buf, "\t\"MetricGroup\": \"%S\"", group);
 397                 need_sep = true;
 398         }
 399         if (name) {
 400                 fix_escape_printf(&buf, "%s\t\"MetricName\": \"%S\"", need_sep ? ",\n" : "", name);
 401                 need_sep = true;
 402         }
 403         if (expr) {
 404                 fix_escape_printf(&buf, "%s\t\"MetricExpr\": \"%S\"", need_sep ? ",\n" : "", expr);
 405                 need_sep = true;
 406         }
 407         if (unit) {
 408                 fix_escape_printf(&buf, "%s\t\"ScaleUnit\": \"%S\"", need_sep ? ",\n" : "", unit);
 409                 need_sep = true;
 410         }
 411         if (desc) {
 412                 fix_escape_printf(&buf, "%s\t\"BriefDescription\": \"%S\"", need_sep ? ",\n" : "",
 413                                   desc);
 414                 need_sep = true;
 415         }
 416         if (long_desc) {
 417                 fix_escape_printf(&buf, "%s\t\"PublicDescription\": \"%S\"", need_sep ? ",\n" : "",
 418                                   long_desc);
 419                 need_sep = true;
 420         }
 421         printf("%s}", need_sep ? "\n" : "");
 422         strbuf_release(&buf);
 423 }
 424
 425 int cmd_list(int argc, const char **argv)
 426 {
 427         int i, ret = 0;
 428         struct print_state default_ps = {};
 429         struct print_state json_ps = {};
 430         void *ps = &default_ps;
 431         struct print_callbacks print_cb = {
 432                 .print_start = default_print_start,
 433                 .print_end = default_print_end,
 434                 .print_event = default_print_event,
 435                 .print_metric = default_print_metric,
 436         };
 437         const char *hybrid_name = NULL;
 438         const char *unit_name = NULL;
 439         bool json = false;
 440         struct option list_options[] = {
 441                 OPT_BOOLEAN(0, "raw-dump", &default_ps.name_only, "Dump raw events"),
 442                 OPT_BOOLEAN('j', "json", &json, "JSON encode events and metrics"),
 443                 OPT_BOOLEAN('d', "desc", &default_ps.desc,
 444                             "Print extra event descriptions. --no-desc to not print."),
 445                 OPT_BOOLEAN('v', "long-desc", &default_ps.long_desc,
 446                             "Print longer event descriptions."),
 447                 OPT_BOOLEAN(0, "details", &default_ps.detailed,
 448                             "Print information on the perf event names and expressions used internally by events."),
 449                 OPT_BOOLEAN(0, "deprecated", &default_ps.deprecated,
 450                             "Print deprecated events."),
 451                 OPT_STRING(0, "cputype", &hybrid_name, "hybrid cpu type",
 452                            "Limit PMU or metric printing to the given hybrid PMU (e.g. core or atom)."),
 453                 OPT_STRING(0, "unit", &unit_name, "PMU name",
 454                            "Limit PMU or metric printing to the specified PMU."),
 455                 OPT_INCR(0, "debug", &verbose,
 456                              "Enable debugging output"),
 457                 OPT_END()
 458         };
 459         const char * const list_usage[] = {
 460                 "perf list [<options>] [hw|sw|cache|tracepoint|pmu|sdt|metric|metricgroup|event_glob]",
 461                 NULL
 462         };
 463
 464         set_option_flag(list_options, 0, "raw-dump", PARSE_OPT_HIDDEN);
 465         /* Hide hybrid flag for the more generic 'unit' flag. */
 466         set_option_flag(list_options, 0, "cputype", PARSE_OPT_HIDDEN);
 467
 468         argc = parse_options(argc, argv, list_options, list_usage,
 469                              PARSE_OPT_STOP_AT_NON_OPTION);
 470
 471         setup_pager();
 472
 473         if (!default_ps.name_only)
 474                 setup_pager();
 475
 476         if (json) {
 477                 print_cb = (struct print_callbacks){
 478                         .print_start = json_print_start,
 479                         .print_end = json_print_end,
 480                         .print_event = json_print_event,
 481                         .print_metric = json_print_metric,
 482                 };
 483                 ps = &json_ps;
 484         } else {
 485                 default_ps.desc = !default_ps.long_desc;
 486                 default_ps.last_topic = strdup("");
 487                 assert(default_ps.last_topic);
 488                 default_ps.visited_metrics = strlist__new(NULL, NULL);
 489                 assert(default_ps.visited_metrics);
 490                 if (unit_name)
 491                         default_ps.pmu_glob = strdup(unit_name);
 492                 else if (hybrid_name) {
 493                         default_ps.pmu_glob = perf_pmu__hybrid_type_to_pmu(hybrid_name);
 494                         if (!default_ps.pmu_glob)
 495                                 pr_warning("WARNING: hybrid cputype is not supported!\n");
 496                 }
 497         }
 498         print_cb.print_start(ps);
 499
 500         if (argc == 0) {
 501                 default_ps.metrics = true;
 502                 default_ps.metricgroups = true;
 503                 print_events(&print_cb, ps);
 504                 goto out;
 505         }
 506
 507         for (i = 0; i < argc; ++i) {
 508                 char *sep, *s;
 509
 510                 if (strcmp(argv[i], "tracepoint") == 0)
 511                         print_tracepoint_events(&print_cb, ps);
 512                 else if (strcmp(argv[i], "hw") == 0 ||
 513                          strcmp(argv[i], "hardware") == 0)
 514                         print_symbol_events(&print_cb, ps, PERF_TYPE_HARDWARE,
 515                                         event_symbols_hw, PERF_COUNT_HW_MAX);
 516                 else if (strcmp(argv[i], "sw") == 0 ||
 517                          strcmp(argv[i], "software") == 0) {
 518                         print_symbol_events(&print_cb, ps, PERF_TYPE_SOFTWARE,
 519                                         event_symbols_sw, PERF_COUNT_SW_MAX);
 520                         print_tool_events(&print_cb, ps);
 521                 } else if (strcmp(argv[i], "cache") == 0 ||
 522                          strcmp(argv[i], "hwcache") == 0)
 523                         print_hwcache_events(&print_cb, ps);
 524                 else if (strcmp(argv[i], "pmu") == 0)
 525                         print_pmu_events(&print_cb, ps);
 526                 else if (strcmp(argv[i], "sdt") == 0)
 527                         print_sdt_events(&print_cb, ps);
 528                 else if (strcmp(argv[i], "metric") == 0 || strcmp(argv[i], "metrics") == 0) {
 529                         default_ps.metricgroups = false;
 530                         default_ps.metrics = true;
 531                         metricgroup__print(&print_cb, ps);
 532                 } else if (strcmp(argv[i], "metricgroup") == 0 ||
 533                            strcmp(argv[i], "metricgroups") == 0) {
 534                         default_ps.metricgroups = true;
 535                         default_ps.metrics = false;
 536                         metricgroup__print(&print_cb, ps);
 537                 } else if ((sep = strchr(argv[i], ':')) != NULL) {
 538                         char *old_pmu_glob = default_ps.pmu_glob;
 539
 540                         default_ps.event_glob = strdup(argv[i]);
 541                         if (!default_ps.event_glob) {
 542                                 ret = -1;
 543                                 goto out;
 544                         }
 545
 546                         print_tracepoint_events(&print_cb, ps);
 547                         print_sdt_events(&print_cb, ps);
 548                         default_ps.metrics = true;
 549                         default_ps.metricgroups = true;
 550                         metricgroup__print(&print_cb, ps);
 551                         zfree(&default_ps.event_glob);
 552                         default_ps.pmu_glob = old_pmu_glob;
 553                 } else {
 554                         if (asprintf(&s, "*%s*", argv[i]) < 0) {
 555                                 printf("Critical: Not enough memory! Trying to continue...\n");
 556                                 continue;
 557                         }
 558                         default_ps.event_glob = s;
 559                         print_symbol_events(&print_cb, ps, PERF_TYPE_HARDWARE,
 560                                         event_symbols_hw, PERF_COUNT_HW_MAX);
 561                         print_symbol_events(&print_cb, ps, PERF_TYPE_SOFTWARE,
 562                                         event_symbols_sw, PERF_COUNT_SW_MAX);
 563                         print_tool_events(&print_cb, ps);
 564                         print_hwcache_events(&print_cb, ps);
 565                         print_pmu_events(&print_cb, ps);
 566                         print_tracepoint_events(&print_cb, ps);
 567                         print_sdt_events(&print_cb, ps);
 568                         default_ps.metrics = true;
 569                         default_ps.metricgroups = true;
 570                         metricgroup__print(&print_cb, ps);
 571                         free(s);
 572                 }
 573         }
 574
 575 out:
 576         print_cb.print_end(ps);
 577         free(default_ps.pmu_glob);
 578         free(default_ps.last_topic);
 579         free(default_ps.last_metricgroups);
 580         strlist__delete(default_ps.visited_metrics);
 581         return ret;
 582 }