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(buf: topic, size: sizeof(topic), fmt: "pfm %s", pinfo->name);
195
196 snprintf(buf: name, size: sizeof(name), fmt: "%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}
322

source code of linux/tools/perf/util/pfm.c