xref: /linux/tools/perf/util/pfm.c (revision aec499c75cf8e0b599be4d559e6922b613085f8f)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Support for libpfm4 event encoding.
4  *
5  * Copyright 2020 Google LLC.
6  */
7 #include "util/cpumap.h"
8 #include "util/debug.h"
9 #include "util/event.h"
10 #include "util/evlist.h"
11 #include "util/evsel.h"
12 #include "util/parse-events.h"
13 #include "util/pmu.h"
14 #include "util/pfm.h"
15 
16 #include <string.h>
17 #include <linux/kernel.h>
18 #include <perfmon/pfmlib_perf_event.h>
19 
20 static void libpfm_initialize(void)
21 {
22 	int ret;
23 
24 	ret = pfm_initialize();
25 	if (ret != PFM_SUCCESS) {
26 		ui__warning("libpfm failed to initialize: %s\n",
27 			pfm_strerror(ret));
28 	}
29 }
30 
31 int parse_libpfm_events_option(const struct option *opt, const char *str,
32 			int unset __maybe_unused)
33 {
34 	struct evlist *evlist = *(struct evlist **)opt->value;
35 	struct perf_event_attr attr;
36 	struct perf_pmu *pmu;
37 	struct evsel *evsel, *grp_leader = NULL;
38 	char *p, *q, *p_orig;
39 	const char *sep;
40 	int grp_evt = -1;
41 	int ret;
42 
43 	libpfm_initialize();
44 
45 	p_orig = p = strdup(str);
46 	if (!p)
47 		return -1;
48 	/*
49 	 * force loading of the PMU list
50 	 */
51 	perf_pmu__scan(NULL);
52 
53 	for (q = p; strsep(&p, ",{}"); q = p) {
54 		sep = p ? str + (p - p_orig - 1) : "";
55 		if (*sep == '{') {
56 			if (grp_evt > -1) {
57 				ui__error(
58 					"nested event groups not supported\n");
59 				goto error;
60 			}
61 			grp_evt++;
62 		}
63 
64 		/* no event */
65 		if (*q == '\0') {
66 			if (*sep == '}') {
67 				if (grp_evt < 0) {
68 					ui__error("cannot close a non-existing event group\n");
69 					goto error;
70 				}
71 				grp_evt--;
72 			}
73 			continue;
74 		}
75 
76 		memset(&attr, 0, sizeof(attr));
77 		event_attr_init(&attr);
78 
79 		ret = pfm_get_perf_event_encoding(q, PFM_PLM0|PFM_PLM3,
80 						&attr, NULL, NULL);
81 
82 		if (ret != PFM_SUCCESS) {
83 			ui__error("failed to parse event %s : %s\n", str,
84 				  pfm_strerror(ret));
85 			goto error;
86 		}
87 
88 		pmu = perf_pmu__find_by_type((unsigned int)attr.type);
89 		evsel = parse_events__add_event(evlist->core.nr_entries,
90 						&attr, q, /*metric_id=*/NULL,
91 						pmu);
92 		if (evsel == NULL)
93 			goto error;
94 
95 		evsel->is_libpfm_event = true;
96 
97 		evlist__add(evlist, evsel);
98 
99 		if (grp_evt == 0)
100 			grp_leader = evsel;
101 
102 		if (grp_evt > -1) {
103 			evsel__set_leader(evsel, grp_leader);
104 			grp_leader->core.nr_members++;
105 			grp_evt++;
106 		}
107 
108 		if (*sep == '}') {
109 			if (grp_evt < 0) {
110 				ui__error(
111 				   "cannot close a non-existing event group\n");
112 				goto error;
113 			}
114 			evlist->core.nr_groups++;
115 			grp_leader = NULL;
116 			grp_evt = -1;
117 		}
118 	}
119 	free(p_orig);
120 	return 0;
121 error:
122 	free(p_orig);
123 	return -1;
124 }
125 
126 static const char *srcs[PFM_ATTR_CTRL_MAX] = {
127 	[PFM_ATTR_CTRL_UNKNOWN] = "???",
128 	[PFM_ATTR_CTRL_PMU] = "PMU",
129 	[PFM_ATTR_CTRL_PERF_EVENT] = "perf_event",
130 };
131 
132 static void
133 print_attr_flags(pfm_event_attr_info_t *info)
134 {
135 	int n = 0;
136 
137 	if (info->is_dfl) {
138 		printf("[default] ");
139 		n++;
140 	}
141 
142 	if (info->is_precise) {
143 		printf("[precise] ");
144 		n++;
145 	}
146 
147 	if (!n)
148 		printf("- ");
149 }
150 
151 static void
152 print_libpfm_events_detailed(pfm_event_info_t *info, bool long_desc)
153 {
154 	pfm_event_attr_info_t ainfo;
155 	const char *src;
156 	int j, ret;
157 
158 	ainfo.size = sizeof(ainfo);
159 
160 	printf("  %s\n", info->name);
161 	printf("    [%s]\n", info->desc);
162 	if (long_desc) {
163 		if (info->equiv)
164 			printf("      Equiv: %s\n", info->equiv);
165 
166 		printf("      Code  : 0x%"PRIx64"\n", info->code);
167 	}
168 	pfm_for_each_event_attr(j, info) {
169 		ret = pfm_get_event_attr_info(info->idx, j,
170 					      PFM_OS_PERF_EVENT_EXT, &ainfo);
171 		if (ret != PFM_SUCCESS)
172 			continue;
173 
174 		if (ainfo.type == PFM_ATTR_UMASK) {
175 			printf("      %s:%s\n", info->name, ainfo.name);
176 			printf("        [%s]\n", ainfo.desc);
177 		}
178 
179 		if (!long_desc)
180 			continue;
181 
182 		if (ainfo.ctrl >= PFM_ATTR_CTRL_MAX)
183 			ainfo.ctrl = PFM_ATTR_CTRL_UNKNOWN;
184 
185 		src = srcs[ainfo.ctrl];
186 		switch (ainfo.type) {
187 		case PFM_ATTR_UMASK:
188 			printf("        Umask : 0x%02"PRIx64" : %s: ",
189 				ainfo.code, src);
190 			print_attr_flags(&ainfo);
191 			putchar('\n');
192 			break;
193 		case PFM_ATTR_MOD_BOOL:
194 			printf("      Modif : %s: [%s] : %s (boolean)\n", src,
195 				ainfo.name, ainfo.desc);
196 			break;
197 		case PFM_ATTR_MOD_INTEGER:
198 			printf("      Modif : %s: [%s] : %s (integer)\n", src,
199 				ainfo.name, ainfo.desc);
200 			break;
201 		case PFM_ATTR_NONE:
202 		case PFM_ATTR_RAW_UMASK:
203 		case PFM_ATTR_MAX:
204 		default:
205 			printf("      Attr  : %s: [%s] : %s\n", src,
206 				ainfo.name, ainfo.desc);
207 		}
208 	}
209 }
210 
211 /*
212  * list all pmu::event:umask, pmu::event
213  * printed events may not be all valid combinations of umask for an event
214  */
215 static void
216 print_libpfm_events_raw(pfm_pmu_info_t *pinfo, pfm_event_info_t *info)
217 {
218 	pfm_event_attr_info_t ainfo;
219 	int j, ret;
220 	bool has_umask = false;
221 
222 	ainfo.size = sizeof(ainfo);
223 
224 	pfm_for_each_event_attr(j, info) {
225 		ret = pfm_get_event_attr_info(info->idx, j,
226 					      PFM_OS_PERF_EVENT_EXT, &ainfo);
227 		if (ret != PFM_SUCCESS)
228 			continue;
229 
230 		if (ainfo.type != PFM_ATTR_UMASK)
231 			continue;
232 
233 		printf("%s::%s:%s\n", pinfo->name, info->name, ainfo.name);
234 		has_umask = true;
235 	}
236 	if (!has_umask)
237 		printf("%s::%s\n", pinfo->name, info->name);
238 }
239 
240 void print_libpfm_events(bool name_only, bool long_desc)
241 {
242 	pfm_event_info_t info;
243 	pfm_pmu_info_t pinfo;
244 	int i, p, ret;
245 
246 	libpfm_initialize();
247 
248 	/* initialize to zero to indicate ABI version */
249 	info.size  = sizeof(info);
250 	pinfo.size = sizeof(pinfo);
251 
252 	if (!name_only)
253 		puts("\nList of pre-defined events (to be used in --pfm-events):\n");
254 
255 	pfm_for_all_pmus(p) {
256 		bool printed_pmu = false;
257 
258 		ret = pfm_get_pmu_info(p, &pinfo);
259 		if (ret != PFM_SUCCESS)
260 			continue;
261 
262 		/* only print events that are supported by host HW */
263 		if (!pinfo.is_present)
264 			continue;
265 
266 		/* handled by perf directly */
267 		if (pinfo.pmu == PFM_PMU_PERF_EVENT)
268 			continue;
269 
270 		for (i = pinfo.first_event; i != -1;
271 		     i = pfm_get_event_next(i)) {
272 
273 			ret = pfm_get_event_info(i, PFM_OS_PERF_EVENT_EXT,
274 						&info);
275 			if (ret != PFM_SUCCESS)
276 				continue;
277 
278 			if (!name_only && !printed_pmu) {
279 				printf("%s:\n", pinfo.name);
280 				printed_pmu = true;
281 			}
282 
283 			if (!name_only)
284 				print_libpfm_events_detailed(&info, long_desc);
285 			else
286 				print_libpfm_events_raw(&pinfo, &info);
287 		}
288 		if (!name_only && printed_pmu)
289 			putchar('\n');
290 	}
291 }
292