pfm.c

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