Linux Audio

Check our new training course

Loading...
v4.6
 
 1/*
 2 * builtin-list.c
 3 *
 4 * Builtin list command: list all event types
 5 *
 6 * Copyright (C) 2009, Thomas Gleixner <tglx@linutronix.de>
 7 * Copyright (C) 2008-2009, Red Hat Inc, Ingo Molnar <mingo@redhat.com>
 8 * Copyright (C) 2011, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
 9 */
10#include "builtin.h"
11
12#include "perf.h"
13
14#include "util/parse-events.h"
15#include "util/cache.h"
16#include "util/pmu.h"
 
 
 
 
 
 
 
17#include <subcmd/parse-options.h>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
18
19int cmd_list(int argc, const char **argv, const char *prefix __maybe_unused)
20{
21	int i;
22	bool raw_dump = false;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
23	struct option list_options[] = {
24		OPT_BOOLEAN(0, "raw-dump", &raw_dump, "Dump raw events"),
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
25		OPT_END()
26	};
27	const char * const list_usage[] = {
28		"perf list [hw|sw|cache|tracepoint|pmu|event_glob]",
29		NULL
30	};
31
32	set_option_flag(list_options, 0, "raw-dump", PARSE_OPT_HIDDEN);
 
 
33
34	argc = parse_options(argc, argv, list_options, list_usage,
35			     PARSE_OPT_STOP_AT_NON_OPTION);
36
37	setup_pager();
38
39	if (!raw_dump && pager_in_use())
40		printf("\nList of pre-defined events (to be used in -e):\n\n");
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
41
42	if (argc == 0) {
43		print_events(NULL, raw_dump);
44		return 0;
 
 
45	}
46
47	for (i = 0; i < argc; ++i) {
48		char *sep, *s;
49
50		if (strcmp(argv[i], "tracepoint") == 0)
51			print_tracepoint_events(NULL, NULL, raw_dump);
52		else if (strcmp(argv[i], "hw") == 0 ||
53			 strcmp(argv[i], "hardware") == 0)
54			print_symbol_events(NULL, PERF_TYPE_HARDWARE,
55					event_symbols_hw, PERF_COUNT_HW_MAX, raw_dump);
56		else if (strcmp(argv[i], "sw") == 0 ||
57			 strcmp(argv[i], "software") == 0)
58			print_symbol_events(NULL, PERF_TYPE_SOFTWARE,
59					event_symbols_sw, PERF_COUNT_SW_MAX, raw_dump);
60		else if (strcmp(argv[i], "cache") == 0 ||
 
61			 strcmp(argv[i], "hwcache") == 0)
62			print_hwcache_events(NULL, raw_dump);
63		else if (strcmp(argv[i], "pmu") == 0)
64			print_pmu_events(NULL, raw_dump);
65		else if ((sep = strchr(argv[i], ':')) != NULL) {
66			int sep_idx;
67
68			if (sep == NULL) {
69				print_events(argv[i], raw_dump);
70				continue;
 
 
 
 
 
 
 
 
 
 
 
 
71			}
72			sep_idx = sep - argv[i];
73			s = strdup(argv[i]);
74			if (s == NULL)
75				return -1;
76
77			s[sep_idx] = '\0';
78			print_tracepoint_events(s, s + sep_idx + 1, raw_dump);
79			free(s);
 
 
 
 
80		} else {
81			if (asprintf(&s, "*%s*", argv[i]) < 0) {
82				printf("Critical: Not enough memory! Trying to continue...\n");
83				continue;
84			}
85			print_symbol_events(s, PERF_TYPE_HARDWARE,
86					    event_symbols_hw, PERF_COUNT_HW_MAX, raw_dump);
87			print_symbol_events(s, PERF_TYPE_SOFTWARE,
88					    event_symbols_sw, PERF_COUNT_SW_MAX, raw_dump);
89			print_hwcache_events(s, raw_dump);
90			print_pmu_events(s, raw_dump);
91			print_tracepoint_events(NULL, s, raw_dump);
 
 
 
 
 
 
92			free(s);
93		}
94	}
95	return 0;
 
 
 
 
 
 
 
96}
v6.2
  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/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 */
 31struct 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
 64static 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
 72static void default_print_end(void *print_state __maybe_unused) {}
 73
 74static 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
 97static 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
170static 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
237struct json_print_state {
238	/** Should a separator be printed prior to the next item? */
239	bool need_sep;
240};
241
242static void json_print_start(void *print_state __maybe_unused)
243{
244	printf("[\n");
245}
246
247static 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
254static 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
306static 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
383static 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
425int 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
575out:
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}