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
  16 #include <string.h>
  17 #include <linux/kernel.h>
  18 #include <perfmon/pfmlib_perf_event.h>
  19
  20 static void libpfm_initialize(void)
  21 {
  22         int ret;
  23
  24         ret = pfm_initialize();
  25         if (ret != PFM_SUCCESS) {
  26                 ui__warning("libpfm failed to initialize: %s\n",
  27                         pfm_strerror(ret));
  28         }
  29 }
  30
  31 int parse_libpfm_events_option(const struct option *opt, const char *str,
  32                         int unset __maybe_unused)
  33 {
  34         struct evlist *evlist = *(struct evlist **)opt->value;
  35         struct perf_event_attr attr;
  36         struct perf_pmu *pmu;
  37         struct evsel *evsel, *grp_leader = NULL;
  38         char *p, *q, *p_orig;
  39         const char *sep;
  40         int grp_evt = -1;
  41         int ret;
  42
  43         libpfm_initialize();
  44
  45         p_orig = p = strdup(str);
  46         if (!p)
  47                 return -1;
  48         /*
  49          * force loading of the PMU list
  50          */
  51         perf_pmu__scan(NULL);
  52
  53         for (q = p; strsep(&p, ",{}"); q = p) {
  54                 sep = p ? str + (p - p_orig - 1) : "";
  55                 if (*sep == '{') {
  56                         if (grp_evt > -1) {
  57                                 ui__error(
  58                                         "nested event groups not supported\n");
  59                                 goto error;
  60                         }
  61                         grp_evt++;
  62                 }
  63
  64                 /* no event */
  65                 if (*q == '\0') {
  66                         if (*sep == '}') {
  67                                 if (grp_evt < 0) {
  68                                         ui__error("cannot close a non-existing event group\n");
  69                                         goto error;
  70                                 }
  71                                 grp_evt--;
  72                         }
  73                         continue;
  74                 }
  75
  76                 memset(&attr, 0, sizeof(attr));
  77                 event_attr_init(&attr);
  78
  79                 ret = pfm_get_perf_event_encoding(q, PFM_PLM0|PFM_PLM3,
  80                                                 &attr, NULL, NULL);
  81
  82                 if (ret != PFM_SUCCESS) {
  83                         ui__error("failed to parse event %s : %s\n", str,
  84                                   pfm_strerror(ret));
  85                         goto error;
  86                 }
  87
  88                 pmu = perf_pmu__find_by_type((unsigned int)attr.type);
  89                 evsel = parse_events__add_event(evlist->core.nr_entries,
  90                                                 &attr, q, /*metric_id=*/NULL,
  91                                                 pmu);
  92                 if (evsel == NULL)
  93                         goto error;
  94
  95                 evsel->is_libpfm_event = true;
  96
  97                 evlist__add(evlist, evsel);
  98
  99                 if (grp_evt == 0)
 100                         grp_leader = evsel;
 101
 102                 if (grp_evt > -1) {
 103                         evsel__set_leader(evsel, grp_leader);
 104                         grp_leader->core.nr_members++;
 105                         grp_evt++;
 106                 }
 107
 108                 if (*sep == '}') {
 109                         if (grp_evt < 0) {
 110                                 ui__error(
 111                                    "cannot close a non-existing event group\n");
 112                                 goto error;
 113                         }
 114                         evlist->core.nr_groups++;
 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(pfm_event_attr_info_t *info)
 134 {
 135         int n = 0;
 136
 137         if (info->is_dfl) {
 138                 printf("[default] ");
 139                 n++;
 140         }
 141
 142         if (info->is_precise) {
 143                 printf("[precise] ");
 144                 n++;
 145         }
 146
 147         if (!n)
 148                 printf("- ");
 149 }
 150
 151 static void
 152 print_libpfm_events_detailed(pfm_event_info_t *info, bool long_desc)
 153 {
 154         pfm_event_attr_info_t ainfo;
 155         const char *src;
 156         int j, ret;
 157
 158         ainfo.size = sizeof(ainfo);
 159
 160         printf("  %s\n", info->name);
 161         printf("    [%s]\n", info->desc);
 162         if (long_desc) {
 163                 if (info->equiv)
 164                         printf("      Equiv: %s\n", info->equiv);
 165
 166                 printf("      Code  : 0x%"PRIx64"\n", info->code);
 167         }
 168         pfm_for_each_event_attr(j, info) {
 169                 ret = pfm_get_event_attr_info(info->idx, j,
 170                                               PFM_OS_PERF_EVENT_EXT, &ainfo);
 171                 if (ret != PFM_SUCCESS)
 172                         continue;
 173
 174                 if (ainfo.type == PFM_ATTR_UMASK) {
 175                         printf("      %s:%s\n", info->name, ainfo.name);
 176                         printf("        [%s]\n", ainfo.desc);
 177                 }
 178
 179                 if (!long_desc)
 180                         continue;
 181
 182                 if (ainfo.ctrl >= PFM_ATTR_CTRL_MAX)
 183                         ainfo.ctrl = PFM_ATTR_CTRL_UNKNOWN;
 184
 185                 src = srcs[ainfo.ctrl];
 186                 switch (ainfo.type) {
 187                 case PFM_ATTR_UMASK:
 188                         printf("        Umask : 0x%02"PRIx64" : %s: ",
 189                                 ainfo.code, src);
 190                         print_attr_flags(&ainfo);
 191                         putchar('\n');
 192                         break;
 193                 case PFM_ATTR_MOD_BOOL:
 194                         printf("      Modif : %s: [%s] : %s (boolean)\n", src,
 195                                 ainfo.name, ainfo.desc);
 196                         break;
 197                 case PFM_ATTR_MOD_INTEGER:
 198                         printf("      Modif : %s: [%s] : %s (integer)\n", src,
 199                                 ainfo.name, ainfo.desc);
 200                         break;
 201                 case PFM_ATTR_NONE:
 202                 case PFM_ATTR_RAW_UMASK:
 203                 case PFM_ATTR_MAX:
 204                 default:
 205                         printf("      Attr  : %s: [%s] : %s\n", src,
 206                                 ainfo.name, ainfo.desc);
 207                 }
 208         }
 209 }
 210
 211 /*
 212  * list all pmu::event:umask, pmu::event
 213  * printed events may not be all valid combinations of umask for an event
 214  */
 215 static void
 216 print_libpfm_events_raw(pfm_pmu_info_t *pinfo, pfm_event_info_t *info)
 217 {
 218         pfm_event_attr_info_t ainfo;
 219         int j, ret;
 220         bool has_umask = false;
 221
 222         ainfo.size = sizeof(ainfo);
 223
 224         pfm_for_each_event_attr(j, info) {
 225                 ret = pfm_get_event_attr_info(info->idx, j,
 226                                               PFM_OS_PERF_EVENT_EXT, &ainfo);
 227                 if (ret != PFM_SUCCESS)
 228                         continue;
 229
 230                 if (ainfo.type != PFM_ATTR_UMASK)
 231                         continue;
 232
 233                 printf("%s::%s:%s\n", pinfo->name, info->name, ainfo.name);
 234                 has_umask = true;
 235         }
 236         if (!has_umask)
 237                 printf("%s::%s\n", pinfo->name, info->name);
 238 }
 239
 240 void print_libpfm_events(bool name_only, bool long_desc)
 241 {
 242         pfm_event_info_t info;
 243         pfm_pmu_info_t pinfo;
 244         int i, p, ret;
 245
 246         libpfm_initialize();
 247
 248         /* initialize to zero to indicate ABI version */
 249         info.size  = sizeof(info);
 250         pinfo.size = sizeof(pinfo);
 251
 252         if (!name_only)
 253                 puts("\nList of pre-defined events (to be used in --pfm-events):\n");
 254
 255         pfm_for_all_pmus(p) {
 256                 bool printed_pmu = false;
 257
 258                 ret = pfm_get_pmu_info(p, &pinfo);
 259                 if (ret != PFM_SUCCESS)
 260                         continue;
 261
 262                 /* only print events that are supported by host HW */
 263                 if (!pinfo.is_present)
 264                         continue;
 265
 266                 /* handled by perf directly */
 267                 if (pinfo.pmu == PFM_PMU_PERF_EVENT)
 268                         continue;
 269
 270                 for (i = pinfo.first_event; i != -1;
 271                      i = pfm_get_event_next(i)) {
 272
 273                         ret = pfm_get_event_info(i, PFM_OS_PERF_EVENT_EXT,
 274                                                 &info);
 275                         if (ret != PFM_SUCCESS)
 276                                 continue;
 277
 278                         if (!name_only && !printed_pmu) {
 279                                 printf("%s:\n", pinfo.name);
 280                                 printed_pmu = true;
 281                         }
 282
 283                         if (!name_only)
 284                                 print_libpfm_events_detailed(&info, long_desc);
 285                         else
 286                                 print_libpfm_events_raw(&pinfo, &info);
 287                 }
 288                 if (!name_only && printed_pmu)
 289                         putchar('\n');
 290         }
 291 }