tools/perf/util/perf_api_probe.c

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2
   3 #include "perf-sys.h"
   4 #include "util/cloexec.h"
   5 #include "util/evlist.h"
   6 #include "util/evsel.h"
   7 #include "util/parse-events.h"
   8 #include "util/perf_api_probe.h"
   9 #include <perf/cpumap.h>
  10 #include <errno.h>
  11
  12 typedef void (*setup_probe_fn_t)(struct evsel *evsel);
  13
  14 static int perf_do_probe_api(setup_probe_fn_t fn, int cpu, const char *str)
  15 {
  16         struct evlist *evlist;
  17         struct evsel *evsel;
  18         unsigned long flags = perf_event_open_cloexec_flag();
  19         int err = -EAGAIN, fd;
  20         static pid_t pid = -1;
  21
  22         evlist = evlist__new();
  23         if (!evlist)
  24                 return -ENOMEM;
  25
  26         if (parse_events(evlist, str, NULL))
  27                 goto out_delete;
  28
  29         evsel = evlist__first(evlist);
  30
  31         while (1) {
  32                 fd = sys_perf_event_open(&evsel->core.attr, pid, cpu, -1, flags);
  33                 if (fd < 0) {
  34                         if (pid == -1 && errno == EACCES) {
  35                                 pid = 0;
  36                                 continue;
  37                         }
  38                         goto out_delete;
  39                 }
  40                 break;
  41         }
  42         close(fd);
  43
  44         fn(evsel);
  45
  46         fd = sys_perf_event_open(&evsel->core.attr, pid, cpu, -1, flags);
  47         if (fd < 0) {
  48                 if (errno == EINVAL)
  49                         err = -EINVAL;
  50                 goto out_delete;
  51         }
  52         close(fd);
  53         err = 0;
  54
  55 out_delete:
  56         evlist__delete(evlist);
  57         return err;
  58 }
  59
  60 static bool perf_probe_api(setup_probe_fn_t fn)
  61 {
  62         const char *try[] = {"cycles:u", "instructions:u", "cpu-clock:u", NULL};
  63         struct perf_cpu_map *cpus;
  64         int cpu, ret, i = 0;
  65
  66         cpus = perf_cpu_map__new(NULL);
  67         if (!cpus)
  68                 return false;
  69         cpu = cpus->map[0];
  70         perf_cpu_map__put(cpus);
  71
  72         do {
  73                 ret = perf_do_probe_api(fn, cpu, try[i++]);
  74                 if (!ret)
  75                         return true;
  76         } while (ret == -EAGAIN && try[i]);
  77
  78         return false;
  79 }
  80
  81 static void perf_probe_sample_identifier(struct evsel *evsel)
  82 {
  83         evsel->core.attr.sample_type |= PERF_SAMPLE_IDENTIFIER;
  84 }
  85
  86 static void perf_probe_comm_exec(struct evsel *evsel)
  87 {
  88         evsel->core.attr.comm_exec = 1;
  89 }
  90
  91 static void perf_probe_context_switch(struct evsel *evsel)
  92 {
  93         evsel->core.attr.context_switch = 1;
  94 }
  95
  96 static void perf_probe_text_poke(struct evsel *evsel)
  97 {
  98         evsel->core.attr.text_poke = 1;
  99 }
 100
 101 bool perf_can_sample_identifier(void)
 102 {
 103         return perf_probe_api(perf_probe_sample_identifier);
 104 }
 105
 106 bool perf_can_comm_exec(void)
 107 {
 108         return perf_probe_api(perf_probe_comm_exec);
 109 }
 110
 111 bool perf_can_record_switch_events(void)
 112 {
 113         return perf_probe_api(perf_probe_context_switch);
 114 }
 115
 116 bool perf_can_record_text_poke_events(void)
 117 {
 118         return perf_probe_api(perf_probe_text_poke);
 119 }
 120
 121 bool perf_can_record_cpu_wide(void)
 122 {
 123         struct perf_event_attr attr = {
 124                 .type = PERF_TYPE_SOFTWARE,
 125                 .config = PERF_COUNT_SW_CPU_CLOCK,
 126                 .exclude_kernel = 1,
 127         };
 128         struct perf_cpu_map *cpus;
 129         int cpu, fd;
 130
 131         cpus = perf_cpu_map__new(NULL);
 132         if (!cpus)
 133                 return false;
 134         cpu = cpus->map[0];
 135         perf_cpu_map__put(cpus);
 136
 137         fd = sys_perf_event_open(&attr, -1, cpu, -1, 0);
 138         if (fd < 0)
 139                 return false;
 140         close(fd);
 141
 142         return true;
 143 }
 144
 145 /*
 146  * Architectures are expected to know if AUX area sampling is supported by the
 147  * hardware. Here we check for kernel support.
 148  */
 149 bool perf_can_aux_sample(void)
 150 {
 151         struct perf_event_attr attr = {
 152                 .size = sizeof(struct perf_event_attr),
 153                 .exclude_kernel = 1,
 154                 /*
 155                  * Non-zero value causes the kernel to calculate the effective
 156                  * attribute size up to that byte.
 157                  */
 158                 .aux_sample_size = 1,
 159         };
 160         int fd;
 161
 162         fd = sys_perf_event_open(&attr, -1, 0, -1, 0);
 163         /*
 164          * If the kernel attribute is big enough to contain aux_sample_size
 165          * then we assume that it is supported. We are relying on the kernel to
 166          * validate the attribute size before anything else that could be wrong.
 167          */
 168         if (fd < 0 && errno == E2BIG)
 169                 return false;
 170         if (fd >= 0)
 171                 close(fd);
 172
 173         return true;
 174 }