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 } 323