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}