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