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/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
  21 static 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
  32 int 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                         grp_leader = NULL;
 116                         grp_evt = -1;
 117                 }
 118         }
 119         free(p_orig);
 120         return 0;
 121 error:
 122         free(p_orig);
 123         return -1;
 124 }
 125
 126 static const char *srcs[PFM_ATTR_CTRL_MAX] = {
 127         [PFM_ATTR_CTRL_UNKNOWN] = "???",
 128         [PFM_ATTR_CTRL_PMU] = "PMU",
 129         [PFM_ATTR_CTRL_PERF_EVENT] = "perf_event",
 130 };
 131
 132 static void
 133 print_attr_flags(struct strbuf *buf, const pfm_event_attr_info_t *info)
 134 {
 135         if (info->is_dfl)
 136                 strbuf_addf(buf, "[default] ");
 137
 138         if (info->is_precise)
 139                 strbuf_addf(buf, "[precise] ");
 140 }
 141
 142 static void
 143 print_libpfm_event(const struct print_callbacks *print_cb, void *print_state,
 144                 const pfm_pmu_info_t *pinfo, const pfm_event_info_t *info,
 145                 struct strbuf *buf)
 146 {
 147         int j, ret;
 148         char topic[80], name[80];
 149
 150         strbuf_setlen(buf, 0);
 151         snprintf(topic, sizeof(topic), "pfm %s", pinfo->name);
 152
 153         snprintf(name, sizeof(name), "%s::%s", pinfo->name, info->name);
 154         strbuf_addf(buf, "Code: 0x%"PRIx64"\n", info->code);
 155
 156         pfm_for_each_event_attr(j, info) {
 157                 pfm_event_attr_info_t ainfo;
 158                 const char *src;
 159
 160                 ainfo.size = sizeof(ainfo);
 161                 ret = pfm_get_event_attr_info(info->idx, j, PFM_OS_PERF_EVENT_EXT, &ainfo);
 162                 if (ret != PFM_SUCCESS)
 163                         continue;
 164
 165                 if (ainfo.ctrl >= PFM_ATTR_CTRL_MAX)
 166                         ainfo.ctrl = PFM_ATTR_CTRL_UNKNOWN;
 167
 168                 src = srcs[ainfo.ctrl];
 169                 switch (ainfo.type) {
 170                 case PFM_ATTR_UMASK: /* Ignore for now */
 171                         break;
 172                 case PFM_ATTR_MOD_BOOL:
 173                         strbuf_addf(buf, " Modif: %s: [%s] : %s (boolean)\n", src,
 174                                     ainfo.name, ainfo.desc);
 175                         break;
 176                 case PFM_ATTR_MOD_INTEGER:
 177                         strbuf_addf(buf, " Modif: %s: [%s] : %s (integer)\n", src,
 178                                     ainfo.name, ainfo.desc);
 179                         break;
 180                 case PFM_ATTR_NONE:
 181                 case PFM_ATTR_RAW_UMASK:
 182                 case PFM_ATTR_MAX:
 183                 default:
 184                         strbuf_addf(buf, " Attr: %s: [%s] : %s\n", src,
 185                                     ainfo.name, ainfo.desc);
 186                 }
 187         }
 188         print_cb->print_event(print_state,
 189                         pinfo->name,
 190                         topic,
 191                         name, info->equiv,
 192                         /*scale_unit=*/NULL,
 193                         /*deprecated=*/NULL, "PFM event",
 194                         info->desc, /*long_desc=*/NULL,
 195                         /*encoding_desc=*/buf->buf);
 196
 197         pfm_for_each_event_attr(j, info) {
 198                 pfm_event_attr_info_t ainfo;
 199                 const char *src;
 200
 201                 strbuf_setlen(buf, 0);
 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                 if (ainfo.type == PFM_ATTR_UMASK) {
 213                         strbuf_addf(buf, "Umask: 0x%02"PRIx64" : %s: ",
 214                                 ainfo.code, src);
 215                         print_attr_flags(buf, &ainfo);
 216                         snprintf(name, sizeof(name), "%s::%s:%s",
 217                                  pinfo->name, info->name, ainfo.name);
 218                         print_cb->print_event(print_state,
 219                                         pinfo->name,
 220                                         topic,
 221                                         name, /*alias=*/NULL,
 222                                         /*scale_unit=*/NULL,
 223                                         /*deprecated=*/NULL, "PFM event",
 224                                         ainfo.desc, /*long_desc=*/NULL,
 225                                         /*encoding_desc=*/buf->buf);
 226                 }
 227         }
 228 }
 229
 230 void print_libpfm_events(const struct print_callbacks *print_cb, void *print_state)
 231 {
 232         pfm_event_info_t info;
 233         pfm_pmu_info_t pinfo;
 234         int p, ret;
 235         struct strbuf storage;
 236
 237         libpfm_initialize();
 238
 239         /* initialize to zero to indicate ABI version */
 240         info.size  = sizeof(info);
 241         pinfo.size = sizeof(pinfo);
 242
 243         strbuf_init(&storage, 2048);
 244
 245         pfm_for_all_pmus(p) {
 246                 ret = pfm_get_pmu_info(p, &pinfo);
 247                 if (ret != PFM_SUCCESS)
 248                         continue;
 249
 250                 /* only print events that are supported by host HW */
 251                 if (!pinfo.is_present)
 252                         continue;
 253
 254                 /* handled by perf directly */
 255                 if (pinfo.pmu == PFM_PMU_PERF_EVENT)
 256                         continue;
 257
 258                 for (int i = pinfo.first_event; i != -1; i = pfm_get_event_next(i)) {
 259                         ret = pfm_get_event_info(i, PFM_OS_PERF_EVENT_EXT,
 260                                                 &info);
 261                         if (ret != PFM_SUCCESS)
 262                                 continue;
 263
 264                         print_libpfm_event(print_cb, print_state, &pinfo, &info, &storage);
 265                 }
 266         }
 267         strbuf_release(&storage);
 268 }