]> Git Repo - J-linux.git/blob - tools/perf/util/pfm.c
Merge tag 'vfs-6.13-rc7.fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs
[J-linux.git] / tools / perf / util / 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 <string.h>
19 #include <linux/kernel.h>
20 #include <perfmon/pfmlib_perf_event.h>
21
22 static 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
33 int 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;
122 error:
123         free(p_orig);
124         return -1;
125 }
126
127 static 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
170 static 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
176 static void
177 print_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
186 static void
187 print_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, topic, pinfo->name,
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                                         topic,
271                                         pinfo->name,
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
284 void 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 }
This page took 0.046144 seconds and 4 git commands to generate.