1 // SPDX-License-Identifier: GPL-2.0 2 #include "debug.h" 3 #include "evlist.h" 4 #include "evsel.h" 5 #include "parse-events.h" 6 #include <errno.h> 7 #include <limits.h> 8 #include <stdlib.h> 9 #include <api/fs/fs.h> 10 #include <subcmd/parse-options.h> 11 #include <perf/cpumap.h> 12 #include "cloexec.h" 13 #include "record.h" 14 #include "../perf-sys.h" 15 16 typedef void (*setup_probe_fn_t)(struct evsel *evsel); 17 18 static int perf_do_probe_api(setup_probe_fn_t fn, int cpu, const char *str) 19 { 20 struct evlist *evlist; 21 struct evsel *evsel; 22 unsigned long flags = perf_event_open_cloexec_flag(); 23 int err = -EAGAIN, fd; 24 static pid_t pid = -1; 25 26 evlist = evlist__new(); 27 if (!evlist) 28 return -ENOMEM; 29 30 if (parse_events(evlist, str, NULL)) 31 goto out_delete; 32 33 evsel = evlist__first(evlist); 34 35 while (1) { 36 fd = sys_perf_event_open(&evsel->core.attr, pid, cpu, -1, flags); 37 if (fd < 0) { 38 if (pid == -1 && errno == EACCES) { 39 pid = 0; 40 continue; 41 } 42 goto out_delete; 43 } 44 break; 45 } 46 close(fd); 47 48 fn(evsel); 49 50 fd = sys_perf_event_open(&evsel->core.attr, pid, cpu, -1, flags); 51 if (fd < 0) { 52 if (errno == EINVAL) 53 err = -EINVAL; 54 goto out_delete; 55 } 56 close(fd); 57 err = 0; 58 59 out_delete: 60 evlist__delete(evlist); 61 return err; 62 } 63 64 static bool perf_probe_api(setup_probe_fn_t fn) 65 { 66 const char *try[] = {"cycles:u", "instructions:u", "cpu-clock:u", NULL}; 67 struct perf_cpu_map *cpus; 68 int cpu, ret, i = 0; 69 70 cpus = perf_cpu_map__new(NULL); 71 if (!cpus) 72 return false; 73 cpu = cpus->map[0]; 74 perf_cpu_map__put(cpus); 75 76 do { 77 ret = perf_do_probe_api(fn, cpu, try[i++]); 78 if (!ret) 79 return true; 80 } while (ret == -EAGAIN && try[i]); 81 82 return false; 83 } 84 85 static void perf_probe_sample_identifier(struct evsel *evsel) 86 { 87 evsel->core.attr.sample_type |= PERF_SAMPLE_IDENTIFIER; 88 } 89 90 static void perf_probe_comm_exec(struct evsel *evsel) 91 { 92 evsel->core.attr.comm_exec = 1; 93 } 94 95 static void perf_probe_context_switch(struct evsel *evsel) 96 { 97 evsel->core.attr.context_switch = 1; 98 } 99 100 bool perf_can_sample_identifier(void) 101 { 102 return perf_probe_api(perf_probe_sample_identifier); 103 } 104 105 static bool perf_can_comm_exec(void) 106 { 107 return perf_probe_api(perf_probe_comm_exec); 108 } 109 110 bool perf_can_record_switch_events(void) 111 { 112 return perf_probe_api(perf_probe_context_switch); 113 } 114 115 bool perf_can_record_cpu_wide(void) 116 { 117 struct perf_event_attr attr = { 118 .type = PERF_TYPE_SOFTWARE, 119 .config = PERF_COUNT_SW_CPU_CLOCK, 120 .exclude_kernel = 1, 121 }; 122 struct perf_cpu_map *cpus; 123 int cpu, fd; 124 125 cpus = perf_cpu_map__new(NULL); 126 if (!cpus) 127 return false; 128 cpu = cpus->map[0]; 129 perf_cpu_map__put(cpus); 130 131 fd = sys_perf_event_open(&attr, -1, cpu, -1, 0); 132 if (fd < 0) 133 return false; 134 close(fd); 135 136 return true; 137 } 138 139 /* 140 * Architectures are expected to know if AUX area sampling is supported by the 141 * hardware. Here we check for kernel support. 142 */ 143 bool perf_can_aux_sample(void) 144 { 145 struct perf_event_attr attr = { 146 .size = sizeof(struct perf_event_attr), 147 .exclude_kernel = 1, 148 /* 149 * Non-zero value causes the kernel to calculate the effective 150 * attribute size up to that byte. 151 */ 152 .aux_sample_size = 1, 153 }; 154 int fd; 155 156 fd = sys_perf_event_open(&attr, -1, 0, -1, 0); 157 /* 158 * If the kernel attribute is big enough to contain aux_sample_size 159 * then we assume that it is supported. We are relying on the kernel to 160 * validate the attribute size before anything else that could be wrong. 161 */ 162 if (fd < 0 && errno == E2BIG) 163 return false; 164 if (fd >= 0) 165 close(fd); 166 167 return true; 168 } 169 170 void perf_evlist__config(struct evlist *evlist, struct record_opts *opts, 171 struct callchain_param *callchain) 172 { 173 struct evsel *evsel; 174 bool use_sample_identifier = false; 175 bool use_comm_exec; 176 bool sample_id = opts->sample_id; 177 178 /* 179 * Set the evsel leader links before we configure attributes, 180 * since some might depend on this info. 181 */ 182 if (opts->group) 183 perf_evlist__set_leader(evlist); 184 185 if (evlist->core.cpus->map[0] < 0) 186 opts->no_inherit = true; 187 188 use_comm_exec = perf_can_comm_exec(); 189 190 evlist__for_each_entry(evlist, evsel) { 191 perf_evsel__config(evsel, opts, callchain); 192 if (evsel->tracking && use_comm_exec) 193 evsel->core.attr.comm_exec = 1; 194 } 195 196 if (opts->full_auxtrace) { 197 /* 198 * Need to be able to synthesize and parse selected events with 199 * arbitrary sample types, which requires always being able to 200 * match the id. 201 */ 202 use_sample_identifier = perf_can_sample_identifier(); 203 sample_id = true; 204 } else if (evlist->core.nr_entries > 1) { 205 struct evsel *first = evlist__first(evlist); 206 207 evlist__for_each_entry(evlist, evsel) { 208 if (evsel->core.attr.sample_type == first->core.attr.sample_type) 209 continue; 210 use_sample_identifier = perf_can_sample_identifier(); 211 break; 212 } 213 sample_id = true; 214 } 215 216 if (sample_id) { 217 evlist__for_each_entry(evlist, evsel) 218 perf_evsel__set_sample_id(evsel, use_sample_identifier); 219 } 220 221 perf_evlist__set_id_pos(evlist); 222 } 223 224 static int get_max_rate(unsigned int *rate) 225 { 226 return sysctl__read_int("kernel/perf_event_max_sample_rate", (int *)rate); 227 } 228 229 static int record_opts__config_freq(struct record_opts *opts) 230 { 231 bool user_freq = opts->user_freq != UINT_MAX; 232 unsigned int max_rate; 233 234 if (opts->user_interval != ULLONG_MAX) 235 opts->default_interval = opts->user_interval; 236 if (user_freq) 237 opts->freq = opts->user_freq; 238 239 /* 240 * User specified count overrides default frequency. 241 */ 242 if (opts->default_interval) 243 opts->freq = 0; 244 else if (opts->freq) { 245 opts->default_interval = opts->freq; 246 } else { 247 pr_err("frequency and count are zero, aborting\n"); 248 return -1; 249 } 250 251 if (get_max_rate(&max_rate)) 252 return 0; 253 254 /* 255 * User specified frequency is over current maximum. 256 */ 257 if (user_freq && (max_rate < opts->freq)) { 258 if (opts->strict_freq) { 259 pr_err("error: Maximum frequency rate (%'u Hz) exceeded.\n" 260 " Please use -F freq option with a lower value or consider\n" 261 " tweaking /proc/sys/kernel/perf_event_max_sample_rate.\n", 262 max_rate); 263 return -1; 264 } else { 265 pr_warning("warning: Maximum frequency rate (%'u Hz) exceeded, throttling from %'u Hz to %'u Hz.\n" 266 " The limit can be raised via /proc/sys/kernel/perf_event_max_sample_rate.\n" 267 " The kernel will lower it when perf's interrupts take too long.\n" 268 " Use --strict-freq to disable this throttling, refusing to record.\n", 269 max_rate, opts->freq, max_rate); 270 271 opts->freq = max_rate; 272 } 273 } 274 275 /* 276 * Default frequency is over current maximum. 277 */ 278 if (max_rate < opts->freq) { 279 pr_warning("Lowering default frequency rate to %u.\n" 280 "Please consider tweaking " 281 "/proc/sys/kernel/perf_event_max_sample_rate.\n", 282 max_rate); 283 opts->freq = max_rate; 284 } 285 286 return 0; 287 } 288 289 int record_opts__config(struct record_opts *opts) 290 { 291 return record_opts__config_freq(opts); 292 } 293 294 bool perf_evlist__can_select_event(struct evlist *evlist, const char *str) 295 { 296 struct evlist *temp_evlist; 297 struct evsel *evsel; 298 int err, fd, cpu; 299 bool ret = false; 300 pid_t pid = -1; 301 302 temp_evlist = evlist__new(); 303 if (!temp_evlist) 304 return false; 305 306 err = parse_events(temp_evlist, str, NULL); 307 if (err) 308 goto out_delete; 309 310 evsel = evlist__last(temp_evlist); 311 312 if (!evlist || perf_cpu_map__empty(evlist->core.cpus)) { 313 struct perf_cpu_map *cpus = perf_cpu_map__new(NULL); 314 315 cpu = cpus ? cpus->map[0] : 0; 316 perf_cpu_map__put(cpus); 317 } else { 318 cpu = evlist->core.cpus->map[0]; 319 } 320 321 while (1) { 322 fd = sys_perf_event_open(&evsel->core.attr, pid, cpu, -1, 323 perf_event_open_cloexec_flag()); 324 if (fd < 0) { 325 if (pid == -1 && errno == EACCES) { 326 pid = 0; 327 continue; 328 } 329 goto out_delete; 330 } 331 break; 332 } 333 close(fd); 334 ret = true; 335 336 out_delete: 337 evlist__delete(temp_evlist); 338 return ret; 339 } 340 341 int record__parse_freq(const struct option *opt, const char *str, int unset __maybe_unused) 342 { 343 unsigned int freq; 344 struct record_opts *opts = opt->value; 345 346 if (!str) 347 return -EINVAL; 348 349 if (strcasecmp(str, "max") == 0) { 350 if (get_max_rate(&freq)) { 351 pr_err("couldn't read /proc/sys/kernel/perf_event_max_sample_rate\n"); 352 return -1; 353 } 354 pr_info("info: Using a maximum frequency rate of %'d Hz\n", freq); 355 } else { 356 freq = atoi(str); 357 } 358 359 opts->user_freq = freq; 360 return 0; 361 } 362