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/pmus.h"
14#include "util/pfm.h"
15#include "util/strbuf.h"
16#include "util/thread_map.h"
17
18#include <string.h>
19#include <linux/kernel.h>
20#include <perfmon/pfmlib_perf_event.h>
21
22static void libpfm_initialize(void)
23{
24	int ret;
25
26	ret = pfm_initialize();
27	if (ret != PFM_SUCCESS) {
28		ui__warning("libpfm failed to initialize: %s\n",
29			pfm_strerror(ret));
30	}
31}
32
33int parse_libpfm_events_option(const struct option *opt, const char *str,
34			int unset __maybe_unused)
35{
36	struct evlist *evlist = *(struct evlist **)opt->value;
37	struct perf_event_attr attr;
38	struct perf_pmu *pmu;
39	struct evsel *evsel, *grp_leader = NULL;
40	char *p, *q, *p_orig;
41	const char *sep;
42	int grp_evt = -1;
43	int ret;
44
45	libpfm_initialize();
46
47	p_orig = p = strdup(str);
48	if (!p)
49		return -1;
50	/*
51	 * force loading of the PMU list
52	 */
53	perf_pmus__scan(NULL);
54
55	for (q = p; strsep(&p, ",{}"); q = p) {
56		sep = p ? str + (p - p_orig - 1) : "";
57		if (*sep == '{') {
58			if (grp_evt > -1) {
59				ui__error(
60					"nested event groups not supported\n");
61				goto error;
62			}
63			grp_evt++;
64		}
65
66		/* no event */
67		if (*q == '\0') {
68			if (*sep == '}') {
69				if (grp_evt < 0) {
70					ui__error("cannot close a non-existing event group\n");
71					goto error;
72				}
73				grp_evt--;
74			}
75			continue;
76		}
77
78		memset(&attr, 0, sizeof(attr));
79		event_attr_init(&attr);
80
81		ret = pfm_get_perf_event_encoding(q, PFM_PLM0|PFM_PLM3,
82						&attr, NULL, NULL);
83
84		if (ret != PFM_SUCCESS) {
85			ui__error("failed to parse event %s : %s\n", str,
86				  pfm_strerror(ret));
87			goto error;
88		}
89
90		pmu = perf_pmus__find_by_type((unsigned int)attr.type);
91		evsel = parse_events__add_event(evlist->core.nr_entries,
92						&attr, q, /*metric_id=*/NULL,
93						pmu);
94		if (evsel == NULL)
95			goto error;
96
97		evsel->is_libpfm_event = true;
98
99		evlist__add(evlist, evsel);
100
101		if (grp_evt == 0)
102			grp_leader = evsel;
103
104		if (grp_evt > -1) {
105			evsel__set_leader(evsel, grp_leader);
106			grp_leader->core.nr_members++;
107			grp_evt++;
108		}
109
110		if (*sep == '}') {
111			if (grp_evt < 0) {
112				ui__error(
113				   "cannot close a non-existing event group\n");
114				goto error;
115			}
116			grp_leader = NULL;
117			grp_evt = -1;
118		}
119	}
120	free(p_orig);
121	return 0;
122error:
123	free(p_orig);
124	return -1;
125}
126
127static bool is_libpfm_event_supported(const char *name, struct perf_cpu_map *cpus,
128				      struct perf_thread_map *threads)
129{
130	struct perf_pmu *pmu;
131	struct evsel *evsel;
132	struct perf_event_attr attr = {};
133	bool result = true;
134	int ret;
135
136	ret = pfm_get_perf_event_encoding(name, PFM_PLM0|PFM_PLM3,
137					  &attr, NULL, NULL);
138	if (ret != PFM_SUCCESS)
139		return false;
140
141	pmu = perf_pmus__find_by_type((unsigned int)attr.type);
142	evsel = parse_events__add_event(0, &attr, name, /*metric_id=*/NULL, pmu);
143	if (evsel == NULL)
144		return false;
145
146	evsel->is_libpfm_event = true;
147
148	ret = evsel__open(evsel, cpus, threads);
149	if (ret == -EACCES) {
150		/*
151		 * This happens if the paranoid value
152		 * /proc/sys/kernel/perf_event_paranoid is set to 2
153		 * Re-run with exclude_kernel set; we don't do that
154		 * by default as some ARM machines do not support it.
155		 *
156		 */
157		evsel->core.attr.exclude_kernel = 1;
158		ret = evsel__open(evsel, cpus, threads);
159
160	}
161	if (ret < 0)
162		result = false;
163
164	evsel__close(evsel);
165	evsel__delete(evsel);
166
167	return result;
168}
169
170static const char *srcs[PFM_ATTR_CTRL_MAX] = {
171	[PFM_ATTR_CTRL_UNKNOWN] = "???",
172	[PFM_ATTR_CTRL_PMU] = "PMU",
173	[PFM_ATTR_CTRL_PERF_EVENT] = "perf_event",
174};
175
176static void
177print_attr_flags(struct strbuf *buf, const pfm_event_attr_info_t *info)
178{
179	if (info->is_dfl)
180		strbuf_addf(buf, "[default] ");
181
182	if (info->is_precise)
183		strbuf_addf(buf, "[precise] ");
184}
185
186static void
187print_libpfm_event(const struct print_callbacks *print_cb, void *print_state,
188		const pfm_pmu_info_t *pinfo, const pfm_event_info_t *info,
189		struct strbuf *buf)
190{
191	int j, ret;
192	char topic[80], name[80];
193	struct perf_cpu_map *cpus = perf_cpu_map__empty_new(1);
194	struct perf_thread_map *threads = thread_map__new_by_tid(0);
195
196	strbuf_setlen(buf, 0);
197	snprintf(topic, sizeof(topic), "pfm %s", pinfo->name);
198
199	snprintf(name, sizeof(name), "%s::%s", pinfo->name, info->name);
200	strbuf_addf(buf, "Code: 0x%"PRIx64"\n", info->code);
201
202	pfm_for_each_event_attr(j, info) {
203		pfm_event_attr_info_t ainfo;
204		const char *src;
205
206		ainfo.size = sizeof(ainfo);
207		ret = pfm_get_event_attr_info(info->idx, j, PFM_OS_PERF_EVENT_EXT, &ainfo);
208		if (ret != PFM_SUCCESS)
209			continue;
210
211		if (ainfo.ctrl >= PFM_ATTR_CTRL_MAX)
212			ainfo.ctrl = PFM_ATTR_CTRL_UNKNOWN;
213
214		src = srcs[ainfo.ctrl];
215		switch (ainfo.type) {
216		case PFM_ATTR_UMASK: /* Ignore for now */
217			break;
218		case PFM_ATTR_MOD_BOOL:
219			strbuf_addf(buf, " Modif: %s: [%s] : %s (boolean)\n", src,
220				    ainfo.name, ainfo.desc);
221			break;
222		case PFM_ATTR_MOD_INTEGER:
223			strbuf_addf(buf, " Modif: %s: [%s] : %s (integer)\n", src,
224				    ainfo.name, ainfo.desc);
225			break;
226		case PFM_ATTR_NONE:
227		case PFM_ATTR_RAW_UMASK:
228		case PFM_ATTR_MAX:
229		default:
230			strbuf_addf(buf, " Attr: %s: [%s] : %s\n", src,
231				    ainfo.name, ainfo.desc);
232		}
233	}
234
235	if (is_libpfm_event_supported(name, cpus, threads)) {
236		print_cb->print_event(print_state, pinfo->name, topic,
237				      name, info->equiv,
238				      /*scale_unit=*/NULL,
239				      /*deprecated=*/NULL, "PFM event",
240				      info->desc, /*long_desc=*/NULL,
241				      /*encoding_desc=*/buf->buf);
242	}
243
244	pfm_for_each_event_attr(j, info) {
245		pfm_event_attr_info_t ainfo;
246		const char *src;
247
248		strbuf_setlen(buf, 0);
249
250		ainfo.size = sizeof(ainfo);
251		ret = pfm_get_event_attr_info(info->idx, j, PFM_OS_PERF_EVENT_EXT, &ainfo);
252		if (ret != PFM_SUCCESS)
253			continue;
254
255		if (ainfo.ctrl >= PFM_ATTR_CTRL_MAX)
256			ainfo.ctrl = PFM_ATTR_CTRL_UNKNOWN;
257
258		src = srcs[ainfo.ctrl];
259		if (ainfo.type == PFM_ATTR_UMASK) {
260			strbuf_addf(buf, "Umask: 0x%02"PRIx64" : %s: ",
261				ainfo.code, src);
262			print_attr_flags(buf, &ainfo);
263			snprintf(name, sizeof(name), "%s::%s:%s",
264				 pinfo->name, info->name, ainfo.name);
265
266			if (!is_libpfm_event_supported(name, cpus, threads))
267				continue;
268
269			print_cb->print_event(print_state,
270					pinfo->name,
271					topic,
272					name, /*alias=*/NULL,
273					/*scale_unit=*/NULL,
274					/*deprecated=*/NULL, "PFM event",
275					ainfo.desc, /*long_desc=*/NULL,
276					/*encoding_desc=*/buf->buf);
277		}
278	}
279
280	perf_cpu_map__put(cpus);
281	perf_thread_map__put(threads);
282}
283
284void print_libpfm_events(const struct print_callbacks *print_cb, void *print_state)
285{
286	pfm_event_info_t info;
287	pfm_pmu_info_t pinfo;
288	int p, ret;
289	struct strbuf storage;
290
291	libpfm_initialize();
292
293	/* initialize to zero to indicate ABI version */
294	info.size  = sizeof(info);
295	pinfo.size = sizeof(pinfo);
296
297	strbuf_init(&storage, 2048);
298
299	pfm_for_all_pmus(p) {
300		ret = pfm_get_pmu_info(p, &pinfo);
301		if (ret != PFM_SUCCESS)
302			continue;
303
304		/* only print events that are supported by host HW */
305		if (!pinfo.is_present)
306			continue;
307
308		/* handled by perf directly */
309		if (pinfo.pmu == PFM_PMU_PERF_EVENT)
310			continue;
311
312		for (int i = pinfo.first_event; i != -1; i = pfm_get_event_next(i)) {
313			ret = pfm_get_event_info(i, PFM_OS_PERF_EVENT_EXT,
314						&info);
315			if (ret != PFM_SUCCESS)
316				continue;
317
318			print_libpfm_event(print_cb, print_state, &pinfo, &info, &storage);
319		}
320	}
321	strbuf_release(&storage);
322}
323