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                         evlist->core.nr_groups++;
 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 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
 133 static void
 134 print_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
 143 static void
 144 print_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
 233 void 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 }