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