tools/perf/util/record.c

   1 #include "evlist.h"
   2 #include "evsel.h"
   3 #include "cpumap.h"
   4 #include "parse-events.h"
   5 #include <api/fs/fs.h>
   6 #include "util.h"
   7
   8 typedef void (*setup_probe_fn_t)(struct perf_evsel *evsel);
   9
  10 static int perf_do_probe_api(setup_probe_fn_t fn, int cpu, const char *str)
  11 {
  12         struct perf_evlist *evlist;
  13         struct perf_evsel *evsel;
  14         int err = -EAGAIN, fd;
  15
  16         evlist = perf_evlist__new();
  17         if (!evlist)
  18                 return -ENOMEM;
  19
  20         if (parse_events(evlist, str))
  21                 goto out_delete;
  22
  23         evsel = perf_evlist__first(evlist);
  24
  25         fd = sys_perf_event_open(&evsel->attr, -1, cpu, -1, 0);
  26         if (fd < 0)
  27                 goto out_delete;
  28         close(fd);
  29
  30         fn(evsel);
  31
  32         fd = sys_perf_event_open(&evsel->attr, -1, cpu, -1, 0);
  33         if (fd < 0) {
  34                 if (errno == EINVAL)
  35                         err = -EINVAL;
  36                 goto out_delete;
  37         }
  38         close(fd);
  39         err = 0;
  40
  41 out_delete:
  42         perf_evlist__delete(evlist);
  43         return err;
  44 }
  45
  46 static bool perf_probe_api(setup_probe_fn_t fn)
  47 {
  48         const char *try[] = {"cycles:u", "instructions:u", "cpu-clock", NULL};
  49         struct cpu_map *cpus;
  50         int cpu, ret, i = 0;
  51
  52         cpus = cpu_map__new(NULL);
  53         if (!cpus)
  54                 return false;
  55         cpu = cpus->map[0];
  56         cpu_map__delete(cpus);
  57
  58         do {
  59                 ret = perf_do_probe_api(fn, cpu, try[i++]);
  60                 if (!ret)
  61                         return true;
  62         } while (ret == -EAGAIN && try[i]);
  63
  64         return false;
  65 }
  66
  67 static void perf_probe_sample_identifier(struct perf_evsel *evsel)
  68 {
  69         evsel->attr.sample_type |= PERF_SAMPLE_IDENTIFIER;
  70 }
  71
  72 static void perf_probe_comm_exec(struct perf_evsel *evsel)
  73 {
  74         evsel->attr.comm_exec = 1;
  75 }
  76
  77 bool perf_can_sample_identifier(void)
  78 {
  79         return perf_probe_api(perf_probe_sample_identifier);
  80 }
  81
  82 static bool perf_can_comm_exec(void)
  83 {
  84         return perf_probe_api(perf_probe_comm_exec);
  85 }
  86
  87 void perf_evlist__config(struct perf_evlist *evlist, struct record_opts *opts)
  88 {
  89         struct perf_evsel *evsel;
  90         bool use_sample_identifier = false;
  91         bool use_comm_exec;
  92
  93         /*
  94          * Set the evsel leader links before we configure attributes,
  95          * since some might depend on this info.
  96          */
  97         if (opts->group)
  98                 perf_evlist__set_leader(evlist);
  99
 100         if (evlist->cpus->map[0] < 0)
 101                 opts->no_inherit = true;
 102
 103         use_comm_exec = perf_can_comm_exec();
 104
 105         evlist__for_each(evlist, evsel) {
 106                 perf_evsel__config(evsel, opts);
 107                 if (!evsel->idx && use_comm_exec)
 108                         evsel->attr.comm_exec = 1;
 109         }
 110
 111         if (evlist->nr_entries > 1) {
 112                 struct perf_evsel *first = perf_evlist__first(evlist);
 113
 114                 evlist__for_each(evlist, evsel) {
 115                         if (evsel->attr.sample_type == first->attr.sample_type)
 116                                 continue;
 117                         use_sample_identifier = perf_can_sample_identifier();
 118                         break;
 119                 }
 120                 evlist__for_each(evlist, evsel)
 121                         perf_evsel__set_sample_id(evsel, use_sample_identifier);
 122         }
 123
 124         perf_evlist__set_id_pos(evlist);
 125 }
 126
 127 static int get_max_rate(unsigned int *rate)
 128 {
 129         char path[PATH_MAX];
 130         const char *procfs = procfs__mountpoint();
 131
 132         if (!procfs)
 133                 return -1;
 134
 135         snprintf(path, PATH_MAX,
 136                  "%s/sys/kernel/perf_event_max_sample_rate", procfs);
 137
 138         return filename__read_int(path, (int *) rate);
 139 }
 140
 141 static int record_opts__config_freq(struct record_opts *opts)
 142 {
 143         bool user_freq = opts->user_freq != UINT_MAX;
 144         unsigned int max_rate;
 145
 146         if (opts->user_interval != ULLONG_MAX)
 147                 opts->default_interval = opts->user_interval;
 148         if (user_freq)
 149                 opts->freq = opts->user_freq;
 150
 151         /*
 152          * User specified count overrides default frequency.
 153          */
 154         if (opts->default_interval)
 155                 opts->freq = 0;
 156         else if (opts->freq) {
 157                 opts->default_interval = opts->freq;
 158         } else {
 159                 pr_err("frequency and count are zero, aborting\n");
 160                 return -1;
 161         }
 162
 163         if (get_max_rate(&max_rate))
 164                 return 0;
 165
 166         /*
 167          * User specified frequency is over current maximum.
 168          */
 169         if (user_freq && (max_rate < opts->freq)) {
 170                 pr_err("Maximum frequency rate (%u) reached.\n"
 171                    "Please use -F freq option with lower value or consider\n"
 172                    "tweaking /proc/sys/kernel/perf_event_max_sample_rate.\n",
 173                    max_rate);
 174                 return -1;
 175         }
 176
 177         /*
 178          * Default frequency is over current maximum.
 179          */
 180         if (max_rate < opts->freq) {
 181                 pr_warning("Lowering default frequency rate to %u.\n"
 182                            "Please consider tweaking "
 183                            "/proc/sys/kernel/perf_event_max_sample_rate.\n",
 184                            max_rate);
 185                 opts->freq = max_rate;
 186         }
 187
 188         return 0;
 189 }
 190
 191 int record_opts__config(struct record_opts *opts)
 192 {
 193         return record_opts__config_freq(opts);
 194 }
 195
 196 bool perf_evlist__can_select_event(struct perf_evlist *evlist, const char *str)
 197 {
 198         struct perf_evlist *temp_evlist;
 199         struct perf_evsel *evsel;
 200         int err, fd, cpu;
 201         bool ret = false;
 202
 203         temp_evlist = perf_evlist__new();
 204         if (!temp_evlist)
 205                 return false;
 206
 207         err = parse_events(temp_evlist, str);
 208         if (err)
 209                 goto out_delete;
 210
 211         evsel = perf_evlist__last(temp_evlist);
 212
 213         if (!evlist || cpu_map__empty(evlist->cpus)) {
 214                 struct cpu_map *cpus = cpu_map__new(NULL);
 215
 216                 cpu =  cpus ? cpus->map[0] : 0;
 217                 cpu_map__delete(cpus);
 218         } else {
 219                 cpu = evlist->cpus->map[0];
 220         }
 221
 222         fd = sys_perf_event_open(&evsel->attr, -1, cpu, -1, 0);
 223         if (fd >= 0) {
 224                 close(fd);
 225                 ret = true;
 226         }
 227
 228 out_delete:
 229         perf_evlist__delete(temp_evlist);
 230         return ret;
 231 }