1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Copyright (C) 2011, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com> |
4 | * |
5 | * Parts came from builtin-{top,stat,record}.c, see those files for further |
6 | * copyright notes. |
7 | */ |
8 | |
9 | #include <byteswap.h> |
10 | #include <errno.h> |
11 | #include <inttypes.h> |
12 | #include <linux/bitops.h> |
13 | #include <api/fs/fs.h> |
14 | #include <api/fs/tracing_path.h> |
15 | #include <linux/hw_breakpoint.h> |
16 | #include <linux/perf_event.h> |
17 | #include <linux/compiler.h> |
18 | #include <linux/err.h> |
19 | #include <linux/zalloc.h> |
20 | #include <sys/ioctl.h> |
21 | #include <sys/resource.h> |
22 | #include <sys/types.h> |
23 | #include <dirent.h> |
24 | #include <stdlib.h> |
25 | #include <perf/evsel.h> |
26 | #include "asm/bug.h" |
27 | #include "bpf_counter.h" |
28 | #include "callchain.h" |
29 | #include "cgroup.h" |
30 | #include "counts.h" |
31 | #include "event.h" |
32 | #include "evsel.h" |
33 | #include "util/env.h" |
34 | #include "util/evsel_config.h" |
35 | #include "util/evsel_fprintf.h" |
36 | #include "evlist.h" |
37 | #include <perf/cpumap.h> |
38 | #include "thread_map.h" |
39 | #include "target.h" |
40 | #include "perf_regs.h" |
41 | #include "record.h" |
42 | #include "debug.h" |
43 | #include "trace-event.h" |
44 | #include "stat.h" |
45 | #include "string2.h" |
46 | #include "memswap.h" |
47 | #include "util.h" |
48 | #include "util/hashmap.h" |
49 | #include "off_cpu.h" |
50 | #include "pmu.h" |
51 | #include "pmus.h" |
52 | #include "rlimit.h" |
53 | #include "../perf-sys.h" |
54 | #include "util/parse-branch-options.h" |
55 | #include "util/bpf-filter.h" |
56 | #include <internal/xyarray.h> |
57 | #include <internal/lib.h> |
58 | #include <internal/threadmap.h> |
59 | |
60 | #include <linux/ctype.h> |
61 | |
62 | #ifdef HAVE_LIBTRACEEVENT |
63 | #include <traceevent/event-parse.h> |
64 | #endif |
65 | |
66 | struct perf_missing_features perf_missing_features; |
67 | |
68 | static clockid_t clockid; |
69 | |
70 | static const char *const perf_tool_event__tool_names[PERF_TOOL_MAX] = { |
71 | NULL, |
72 | "duration_time" , |
73 | "user_time" , |
74 | "system_time" , |
75 | }; |
76 | |
77 | const char *perf_tool_event__to_str(enum perf_tool_event ev) |
78 | { |
79 | if (ev > PERF_TOOL_NONE && ev < PERF_TOOL_MAX) |
80 | return perf_tool_event__tool_names[ev]; |
81 | |
82 | return NULL; |
83 | } |
84 | |
85 | enum perf_tool_event perf_tool_event__from_str(const char *str) |
86 | { |
87 | int i; |
88 | |
89 | perf_tool_event__for_each_event(i) { |
90 | if (!strcmp(str, perf_tool_event__tool_names[i])) |
91 | return i; |
92 | } |
93 | return PERF_TOOL_NONE; |
94 | } |
95 | |
96 | |
97 | static int (struct evsel *evsel __maybe_unused) |
98 | { |
99 | return 0; |
100 | } |
101 | |
102 | void __weak test_attr__ready(void) { } |
103 | |
104 | static void (struct evsel *evsel __maybe_unused) |
105 | { |
106 | } |
107 | |
108 | static struct { |
109 | size_t size; |
110 | int (*init)(struct evsel *evsel); |
111 | void (*fini)(struct evsel *evsel); |
112 | } perf_evsel__object = { |
113 | .size = sizeof(struct evsel), |
114 | .init = evsel__no_extra_init, |
115 | .fini = evsel__no_extra_fini, |
116 | }; |
117 | |
118 | int evsel__object_config(size_t object_size, int (*init)(struct evsel *evsel), |
119 | void (*fini)(struct evsel *evsel)) |
120 | { |
121 | |
122 | if (object_size == 0) |
123 | goto set_methods; |
124 | |
125 | if (perf_evsel__object.size > object_size) |
126 | return -EINVAL; |
127 | |
128 | perf_evsel__object.size = object_size; |
129 | |
130 | set_methods: |
131 | if (init != NULL) |
132 | perf_evsel__object.init = init; |
133 | |
134 | if (fini != NULL) |
135 | perf_evsel__object.fini = fini; |
136 | |
137 | return 0; |
138 | } |
139 | |
140 | #define FD(e, x, y) (*(int *)xyarray__entry(e->core.fd, x, y)) |
141 | |
142 | int __evsel__sample_size(u64 sample_type) |
143 | { |
144 | u64 mask = sample_type & PERF_SAMPLE_MASK; |
145 | int size = 0; |
146 | int i; |
147 | |
148 | for (i = 0; i < 64; i++) { |
149 | if (mask & (1ULL << i)) |
150 | size++; |
151 | } |
152 | |
153 | size *= sizeof(u64); |
154 | |
155 | return size; |
156 | } |
157 | |
158 | /** |
159 | * __perf_evsel__calc_id_pos - calculate id_pos. |
160 | * @sample_type: sample type |
161 | * |
162 | * This function returns the position of the event id (PERF_SAMPLE_ID or |
163 | * PERF_SAMPLE_IDENTIFIER) in a sample event i.e. in the array of struct |
164 | * perf_record_sample. |
165 | */ |
166 | static int __perf_evsel__calc_id_pos(u64 sample_type) |
167 | { |
168 | int idx = 0; |
169 | |
170 | if (sample_type & PERF_SAMPLE_IDENTIFIER) |
171 | return 0; |
172 | |
173 | if (!(sample_type & PERF_SAMPLE_ID)) |
174 | return -1; |
175 | |
176 | if (sample_type & PERF_SAMPLE_IP) |
177 | idx += 1; |
178 | |
179 | if (sample_type & PERF_SAMPLE_TID) |
180 | idx += 1; |
181 | |
182 | if (sample_type & PERF_SAMPLE_TIME) |
183 | idx += 1; |
184 | |
185 | if (sample_type & PERF_SAMPLE_ADDR) |
186 | idx += 1; |
187 | |
188 | return idx; |
189 | } |
190 | |
191 | /** |
192 | * __perf_evsel__calc_is_pos - calculate is_pos. |
193 | * @sample_type: sample type |
194 | * |
195 | * This function returns the position (counting backwards) of the event id |
196 | * (PERF_SAMPLE_ID or PERF_SAMPLE_IDENTIFIER) in a non-sample event i.e. if |
197 | * sample_id_all is used there is an id sample appended to non-sample events. |
198 | */ |
199 | static int __perf_evsel__calc_is_pos(u64 sample_type) |
200 | { |
201 | int idx = 1; |
202 | |
203 | if (sample_type & PERF_SAMPLE_IDENTIFIER) |
204 | return 1; |
205 | |
206 | if (!(sample_type & PERF_SAMPLE_ID)) |
207 | return -1; |
208 | |
209 | if (sample_type & PERF_SAMPLE_CPU) |
210 | idx += 1; |
211 | |
212 | if (sample_type & PERF_SAMPLE_STREAM_ID) |
213 | idx += 1; |
214 | |
215 | return idx; |
216 | } |
217 | |
218 | void evsel__calc_id_pos(struct evsel *evsel) |
219 | { |
220 | evsel->id_pos = __perf_evsel__calc_id_pos(sample_type: evsel->core.attr.sample_type); |
221 | evsel->is_pos = __perf_evsel__calc_is_pos(sample_type: evsel->core.attr.sample_type); |
222 | } |
223 | |
224 | void __evsel__set_sample_bit(struct evsel *evsel, |
225 | enum perf_event_sample_format bit) |
226 | { |
227 | if (!(evsel->core.attr.sample_type & bit)) { |
228 | evsel->core.attr.sample_type |= bit; |
229 | evsel->sample_size += sizeof(u64); |
230 | evsel__calc_id_pos(evsel); |
231 | } |
232 | } |
233 | |
234 | void __evsel__reset_sample_bit(struct evsel *evsel, |
235 | enum perf_event_sample_format bit) |
236 | { |
237 | if (evsel->core.attr.sample_type & bit) { |
238 | evsel->core.attr.sample_type &= ~bit; |
239 | evsel->sample_size -= sizeof(u64); |
240 | evsel__calc_id_pos(evsel); |
241 | } |
242 | } |
243 | |
244 | void evsel__set_sample_id(struct evsel *evsel, |
245 | bool can_sample_identifier) |
246 | { |
247 | if (can_sample_identifier) { |
248 | evsel__reset_sample_bit(evsel, ID); |
249 | evsel__set_sample_bit(evsel, IDENTIFIER); |
250 | } else { |
251 | evsel__set_sample_bit(evsel, ID); |
252 | } |
253 | evsel->core.attr.read_format |= PERF_FORMAT_ID; |
254 | } |
255 | |
256 | /** |
257 | * evsel__is_function_event - Return whether given evsel is a function |
258 | * trace event |
259 | * |
260 | * @evsel - evsel selector to be tested |
261 | * |
262 | * Return %true if event is function trace event |
263 | */ |
264 | bool evsel__is_function_event(struct evsel *evsel) |
265 | { |
266 | #define FUNCTION_EVENT "ftrace:function" |
267 | |
268 | return evsel->name && |
269 | !strncmp(FUNCTION_EVENT, evsel->name, sizeof(FUNCTION_EVENT)); |
270 | |
271 | #undef FUNCTION_EVENT |
272 | } |
273 | |
274 | void evsel__init(struct evsel *evsel, |
275 | struct perf_event_attr *attr, int idx) |
276 | { |
277 | perf_evsel__init(&evsel->core, attr, idx); |
278 | evsel->tracking = !idx; |
279 | evsel->unit = strdup("" ); |
280 | evsel->scale = 1.0; |
281 | evsel->max_events = ULONG_MAX; |
282 | evsel->evlist = NULL; |
283 | evsel->bpf_obj = NULL; |
284 | evsel->bpf_fd = -1; |
285 | INIT_LIST_HEAD(list: &evsel->config_terms); |
286 | INIT_LIST_HEAD(list: &evsel->bpf_counter_list); |
287 | INIT_LIST_HEAD(list: &evsel->bpf_filters); |
288 | perf_evsel__object.init(evsel); |
289 | evsel->sample_size = __evsel__sample_size(sample_type: attr->sample_type); |
290 | evsel__calc_id_pos(evsel); |
291 | evsel->cmdline_group_boundary = false; |
292 | evsel->metric_events = NULL; |
293 | evsel->per_pkg_mask = NULL; |
294 | evsel->collect_stat = false; |
295 | evsel->pmu_name = NULL; |
296 | evsel->group_pmu_name = NULL; |
297 | evsel->skippable = false; |
298 | } |
299 | |
300 | struct evsel *evsel__new_idx(struct perf_event_attr *attr, int idx) |
301 | { |
302 | struct evsel *evsel = zalloc(perf_evsel__object.size); |
303 | |
304 | if (!evsel) |
305 | return NULL; |
306 | evsel__init(evsel, attr, idx); |
307 | |
308 | if (evsel__is_bpf_output(evsel) && !attr->sample_type) { |
309 | evsel->core.attr.sample_type = (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME | |
310 | PERF_SAMPLE_CPU | PERF_SAMPLE_PERIOD), |
311 | evsel->core.attr.sample_period = 1; |
312 | } |
313 | |
314 | if (evsel__is_clock(evsel)) { |
315 | free((char *)evsel->unit); |
316 | evsel->unit = strdup("msec" ); |
317 | evsel->scale = 1e-6; |
318 | } |
319 | |
320 | return evsel; |
321 | } |
322 | |
323 | int copy_config_terms(struct list_head *dst, struct list_head *src) |
324 | { |
325 | struct evsel_config_term *pos, *tmp; |
326 | |
327 | list_for_each_entry(pos, src, list) { |
328 | tmp = malloc(sizeof(*tmp)); |
329 | if (tmp == NULL) |
330 | return -ENOMEM; |
331 | |
332 | *tmp = *pos; |
333 | if (tmp->free_str) { |
334 | tmp->val.str = strdup(pos->val.str); |
335 | if (tmp->val.str == NULL) { |
336 | free(tmp); |
337 | return -ENOMEM; |
338 | } |
339 | } |
340 | list_add_tail(new: &tmp->list, head: dst); |
341 | } |
342 | return 0; |
343 | } |
344 | |
345 | static int evsel__copy_config_terms(struct evsel *dst, struct evsel *src) |
346 | { |
347 | return copy_config_terms(dst: &dst->config_terms, src: &src->config_terms); |
348 | } |
349 | |
350 | /** |
351 | * evsel__clone - create a new evsel copied from @orig |
352 | * @orig: original evsel |
353 | * |
354 | * The assumption is that @orig is not configured nor opened yet. |
355 | * So we only care about the attributes that can be set while it's parsed. |
356 | */ |
357 | struct evsel *evsel__clone(struct evsel *orig) |
358 | { |
359 | struct evsel *evsel; |
360 | |
361 | BUG_ON(orig->core.fd); |
362 | BUG_ON(orig->counts); |
363 | BUG_ON(orig->priv); |
364 | BUG_ON(orig->per_pkg_mask); |
365 | |
366 | /* cannot handle BPF objects for now */ |
367 | if (orig->bpf_obj) |
368 | return NULL; |
369 | |
370 | evsel = evsel__new(attr: &orig->core.attr); |
371 | if (evsel == NULL) |
372 | return NULL; |
373 | |
374 | evsel->core.cpus = perf_cpu_map__get(orig->core.cpus); |
375 | evsel->core.own_cpus = perf_cpu_map__get(orig->core.own_cpus); |
376 | evsel->core.threads = perf_thread_map__get(orig->core.threads); |
377 | evsel->core.nr_members = orig->core.nr_members; |
378 | evsel->core.system_wide = orig->core.system_wide; |
379 | evsel->core.requires_cpu = orig->core.requires_cpu; |
380 | evsel->core.is_pmu_core = orig->core.is_pmu_core; |
381 | |
382 | if (orig->name) { |
383 | evsel->name = strdup(orig->name); |
384 | if (evsel->name == NULL) |
385 | goto out_err; |
386 | } |
387 | if (orig->group_name) { |
388 | evsel->group_name = strdup(orig->group_name); |
389 | if (evsel->group_name == NULL) |
390 | goto out_err; |
391 | } |
392 | if (orig->pmu_name) { |
393 | evsel->pmu_name = strdup(orig->pmu_name); |
394 | if (evsel->pmu_name == NULL) |
395 | goto out_err; |
396 | } |
397 | if (orig->group_pmu_name) { |
398 | evsel->group_pmu_name = strdup(orig->group_pmu_name); |
399 | if (evsel->group_pmu_name == NULL) |
400 | goto out_err; |
401 | } |
402 | if (orig->filter) { |
403 | evsel->filter = strdup(orig->filter); |
404 | if (evsel->filter == NULL) |
405 | goto out_err; |
406 | } |
407 | if (orig->metric_id) { |
408 | evsel->metric_id = strdup(orig->metric_id); |
409 | if (evsel->metric_id == NULL) |
410 | goto out_err; |
411 | } |
412 | evsel->cgrp = cgroup__get(cgroup: orig->cgrp); |
413 | #ifdef HAVE_LIBTRACEEVENT |
414 | evsel->tp_format = orig->tp_format; |
415 | #endif |
416 | evsel->handler = orig->handler; |
417 | evsel->core.leader = orig->core.leader; |
418 | |
419 | evsel->max_events = orig->max_events; |
420 | evsel->tool_event = orig->tool_event; |
421 | free((char *)evsel->unit); |
422 | evsel->unit = strdup(orig->unit); |
423 | if (evsel->unit == NULL) |
424 | goto out_err; |
425 | |
426 | evsel->scale = orig->scale; |
427 | evsel->snapshot = orig->snapshot; |
428 | evsel->per_pkg = orig->per_pkg; |
429 | evsel->percore = orig->percore; |
430 | evsel->precise_max = orig->precise_max; |
431 | evsel->is_libpfm_event = orig->is_libpfm_event; |
432 | |
433 | evsel->exclude_GH = orig->exclude_GH; |
434 | evsel->sample_read = orig->sample_read; |
435 | evsel->auto_merge_stats = orig->auto_merge_stats; |
436 | evsel->collect_stat = orig->collect_stat; |
437 | evsel->weak_group = orig->weak_group; |
438 | evsel->use_config_name = orig->use_config_name; |
439 | evsel->pmu = orig->pmu; |
440 | |
441 | if (evsel__copy_config_terms(dst: evsel, src: orig) < 0) |
442 | goto out_err; |
443 | |
444 | return evsel; |
445 | |
446 | out_err: |
447 | evsel__delete(evsel); |
448 | return NULL; |
449 | } |
450 | |
451 | /* |
452 | * Returns pointer with encoded error via <linux/err.h> interface. |
453 | */ |
454 | #ifdef HAVE_LIBTRACEEVENT |
455 | struct evsel *evsel__newtp_idx(const char *sys, const char *name, int idx) |
456 | { |
457 | struct evsel *evsel = zalloc(perf_evsel__object.size); |
458 | int err = -ENOMEM; |
459 | |
460 | if (evsel == NULL) { |
461 | goto out_err; |
462 | } else { |
463 | struct perf_event_attr attr = { |
464 | .type = PERF_TYPE_TRACEPOINT, |
465 | .sample_type = (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME | |
466 | PERF_SAMPLE_CPU | PERF_SAMPLE_PERIOD), |
467 | }; |
468 | |
469 | if (asprintf(&evsel->name, "%s:%s" , sys, name) < 0) |
470 | goto out_free; |
471 | |
472 | evsel->tp_format = trace_event__tp_format(sys, name); |
473 | if (IS_ERR(evsel->tp_format)) { |
474 | err = PTR_ERR(evsel->tp_format); |
475 | goto out_free; |
476 | } |
477 | |
478 | event_attr_init(&attr); |
479 | attr.config = evsel->tp_format->id; |
480 | attr.sample_period = 1; |
481 | evsel__init(evsel, &attr, idx); |
482 | } |
483 | |
484 | return evsel; |
485 | |
486 | out_free: |
487 | zfree(&evsel->name); |
488 | free(evsel); |
489 | out_err: |
490 | return ERR_PTR(err); |
491 | } |
492 | #endif |
493 | |
494 | const char *const evsel__hw_names[PERF_COUNT_HW_MAX] = { |
495 | "cycles" , |
496 | "instructions" , |
497 | "cache-references" , |
498 | "cache-misses" , |
499 | "branches" , |
500 | "branch-misses" , |
501 | "bus-cycles" , |
502 | "stalled-cycles-frontend" , |
503 | "stalled-cycles-backend" , |
504 | "ref-cycles" , |
505 | }; |
506 | |
507 | char *evsel__bpf_counter_events; |
508 | |
509 | bool evsel__match_bpf_counter_events(const char *name) |
510 | { |
511 | int name_len; |
512 | bool match; |
513 | char *ptr; |
514 | |
515 | if (!evsel__bpf_counter_events) |
516 | return false; |
517 | |
518 | ptr = strstr(evsel__bpf_counter_events, name); |
519 | name_len = strlen(name); |
520 | |
521 | /* check name matches a full token in evsel__bpf_counter_events */ |
522 | match = (ptr != NULL) && |
523 | ((ptr == evsel__bpf_counter_events) || (*(ptr - 1) == ',')) && |
524 | ((*(ptr + name_len) == ',') || (*(ptr + name_len) == '\0')); |
525 | |
526 | return match; |
527 | } |
528 | |
529 | static const char *__evsel__hw_name(u64 config) |
530 | { |
531 | if (config < PERF_COUNT_HW_MAX && evsel__hw_names[config]) |
532 | return evsel__hw_names[config]; |
533 | |
534 | return "unknown-hardware" ; |
535 | } |
536 | |
537 | static int evsel__add_modifiers(struct evsel *evsel, char *bf, size_t size) |
538 | { |
539 | int colon = 0, r = 0; |
540 | struct perf_event_attr *attr = &evsel->core.attr; |
541 | bool exclude_guest_default = false; |
542 | |
543 | #define MOD_PRINT(context, mod) do { \ |
544 | if (!attr->exclude_##context) { \ |
545 | if (!colon) colon = ++r; \ |
546 | r += scnprintf(bf + r, size - r, "%c", mod); \ |
547 | } } while(0) |
548 | |
549 | if (attr->exclude_kernel || attr->exclude_user || attr->exclude_hv) { |
550 | MOD_PRINT(kernel, 'k'); |
551 | MOD_PRINT(user, 'u'); |
552 | MOD_PRINT(hv, 'h'); |
553 | exclude_guest_default = true; |
554 | } |
555 | |
556 | if (attr->precise_ip) { |
557 | if (!colon) |
558 | colon = ++r; |
559 | r += scnprintf(buf: bf + r, size: size - r, fmt: "%.*s" , attr->precise_ip, "ppp" ); |
560 | exclude_guest_default = true; |
561 | } |
562 | |
563 | if (attr->exclude_host || attr->exclude_guest == exclude_guest_default) { |
564 | MOD_PRINT(host, 'H'); |
565 | MOD_PRINT(guest, 'G'); |
566 | } |
567 | #undef MOD_PRINT |
568 | if (colon) |
569 | bf[colon - 1] = ':'; |
570 | return r; |
571 | } |
572 | |
573 | int __weak arch_evsel__hw_name(struct evsel *evsel, char *bf, size_t size) |
574 | { |
575 | return scnprintf(buf: bf, size, fmt: "%s" , __evsel__hw_name(config: evsel->core.attr.config)); |
576 | } |
577 | |
578 | static int evsel__hw_name(struct evsel *evsel, char *bf, size_t size) |
579 | { |
580 | int r = arch_evsel__hw_name(evsel, bf, size); |
581 | return r + evsel__add_modifiers(evsel, bf: bf + r, size: size - r); |
582 | } |
583 | |
584 | const char *const evsel__sw_names[PERF_COUNT_SW_MAX] = { |
585 | "cpu-clock" , |
586 | "task-clock" , |
587 | "page-faults" , |
588 | "context-switches" , |
589 | "cpu-migrations" , |
590 | "minor-faults" , |
591 | "major-faults" , |
592 | "alignment-faults" , |
593 | "emulation-faults" , |
594 | "dummy" , |
595 | }; |
596 | |
597 | static const char *__evsel__sw_name(u64 config) |
598 | { |
599 | if (config < PERF_COUNT_SW_MAX && evsel__sw_names[config]) |
600 | return evsel__sw_names[config]; |
601 | return "unknown-software" ; |
602 | } |
603 | |
604 | static int evsel__sw_name(struct evsel *evsel, char *bf, size_t size) |
605 | { |
606 | int r = scnprintf(buf: bf, size, fmt: "%s" , __evsel__sw_name(config: evsel->core.attr.config)); |
607 | return r + evsel__add_modifiers(evsel, bf: bf + r, size: size - r); |
608 | } |
609 | |
610 | static int evsel__tool_name(enum perf_tool_event ev, char *bf, size_t size) |
611 | { |
612 | return scnprintf(buf: bf, size, fmt: "%s" , perf_tool_event__to_str(ev)); |
613 | } |
614 | |
615 | static int __evsel__bp_name(char *bf, size_t size, u64 addr, u64 type) |
616 | { |
617 | int r; |
618 | |
619 | r = scnprintf(bf, size, "mem:0x%" PRIx64 ":" , addr); |
620 | |
621 | if (type & HW_BREAKPOINT_R) |
622 | r += scnprintf(buf: bf + r, size: size - r, fmt: "r" ); |
623 | |
624 | if (type & HW_BREAKPOINT_W) |
625 | r += scnprintf(buf: bf + r, size: size - r, fmt: "w" ); |
626 | |
627 | if (type & HW_BREAKPOINT_X) |
628 | r += scnprintf(buf: bf + r, size: size - r, fmt: "x" ); |
629 | |
630 | return r; |
631 | } |
632 | |
633 | static int evsel__bp_name(struct evsel *evsel, char *bf, size_t size) |
634 | { |
635 | struct perf_event_attr *attr = &evsel->core.attr; |
636 | int r = __evsel__bp_name(bf, size, addr: attr->bp_addr, type: attr->bp_type); |
637 | return r + evsel__add_modifiers(evsel, bf: bf + r, size: size - r); |
638 | } |
639 | |
640 | const char *const evsel__hw_cache[PERF_COUNT_HW_CACHE_MAX][EVSEL__MAX_ALIASES] = { |
641 | { "L1-dcache" , "l1-d" , "l1d" , "L1-data" , }, |
642 | { "L1-icache" , "l1-i" , "l1i" , "L1-instruction" , }, |
643 | { "LLC" , "L2" , }, |
644 | { "dTLB" , "d-tlb" , "Data-TLB" , }, |
645 | { "iTLB" , "i-tlb" , "Instruction-TLB" , }, |
646 | { "branch" , "branches" , "bpu" , "btb" , "bpc" , }, |
647 | { "node" , }, |
648 | }; |
649 | |
650 | const char *const evsel__hw_cache_op[PERF_COUNT_HW_CACHE_OP_MAX][EVSEL__MAX_ALIASES] = { |
651 | { "load" , "loads" , "read" , }, |
652 | { "store" , "stores" , "write" , }, |
653 | { "prefetch" , "prefetches" , "speculative-read" , "speculative-load" , }, |
654 | }; |
655 | |
656 | const char *const evsel__hw_cache_result[PERF_COUNT_HW_CACHE_RESULT_MAX][EVSEL__MAX_ALIASES] = { |
657 | { "refs" , "Reference" , "ops" , "access" , }, |
658 | { "misses" , "miss" , }, |
659 | }; |
660 | |
661 | #define C(x) PERF_COUNT_HW_CACHE_##x |
662 | #define CACHE_READ (1 << C(OP_READ)) |
663 | #define CACHE_WRITE (1 << C(OP_WRITE)) |
664 | #define CACHE_PREFETCH (1 << C(OP_PREFETCH)) |
665 | #define COP(x) (1 << x) |
666 | |
667 | /* |
668 | * cache operation stat |
669 | * L1I : Read and prefetch only |
670 | * ITLB and BPU : Read-only |
671 | */ |
672 | static const unsigned long evsel__hw_cache_stat[C(MAX)] = { |
673 | [C(L1D)] = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH), |
674 | [C(L1I)] = (CACHE_READ | CACHE_PREFETCH), |
675 | [C(LL)] = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH), |
676 | [C(DTLB)] = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH), |
677 | [C(ITLB)] = (CACHE_READ), |
678 | [C(BPU)] = (CACHE_READ), |
679 | [C(NODE)] = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH), |
680 | }; |
681 | |
682 | bool evsel__is_cache_op_valid(u8 type, u8 op) |
683 | { |
684 | if (evsel__hw_cache_stat[type] & COP(op)) |
685 | return true; /* valid */ |
686 | else |
687 | return false; /* invalid */ |
688 | } |
689 | |
690 | int __evsel__hw_cache_type_op_res_name(u8 type, u8 op, u8 result, char *bf, size_t size) |
691 | { |
692 | if (result) { |
693 | return scnprintf(buf: bf, size, fmt: "%s-%s-%s" , evsel__hw_cache[type][0], |
694 | evsel__hw_cache_op[op][0], |
695 | evsel__hw_cache_result[result][0]); |
696 | } |
697 | |
698 | return scnprintf(buf: bf, size, fmt: "%s-%s" , evsel__hw_cache[type][0], |
699 | evsel__hw_cache_op[op][1]); |
700 | } |
701 | |
702 | static int __evsel__hw_cache_name(u64 config, char *bf, size_t size) |
703 | { |
704 | u8 op, result, type = (config >> 0) & 0xff; |
705 | const char *err = "unknown-ext-hardware-cache-type" ; |
706 | |
707 | if (type >= PERF_COUNT_HW_CACHE_MAX) |
708 | goto out_err; |
709 | |
710 | op = (config >> 8) & 0xff; |
711 | err = "unknown-ext-hardware-cache-op" ; |
712 | if (op >= PERF_COUNT_HW_CACHE_OP_MAX) |
713 | goto out_err; |
714 | |
715 | result = (config >> 16) & 0xff; |
716 | err = "unknown-ext-hardware-cache-result" ; |
717 | if (result >= PERF_COUNT_HW_CACHE_RESULT_MAX) |
718 | goto out_err; |
719 | |
720 | err = "invalid-cache" ; |
721 | if (!evsel__is_cache_op_valid(type, op)) |
722 | goto out_err; |
723 | |
724 | return __evsel__hw_cache_type_op_res_name(type, op, result, bf, size); |
725 | out_err: |
726 | return scnprintf(buf: bf, size, fmt: "%s" , err); |
727 | } |
728 | |
729 | static int evsel__hw_cache_name(struct evsel *evsel, char *bf, size_t size) |
730 | { |
731 | int ret = __evsel__hw_cache_name(config: evsel->core.attr.config, bf, size); |
732 | return ret + evsel__add_modifiers(evsel, bf: bf + ret, size: size - ret); |
733 | } |
734 | |
735 | static int evsel__raw_name(struct evsel *evsel, char *bf, size_t size) |
736 | { |
737 | int ret = scnprintf(bf, size, "raw 0x%" PRIx64, evsel->core.attr.config); |
738 | return ret + evsel__add_modifiers(evsel, bf: bf + ret, size: size - ret); |
739 | } |
740 | |
741 | const char *evsel__name(struct evsel *evsel) |
742 | { |
743 | char bf[128]; |
744 | |
745 | if (!evsel) |
746 | goto out_unknown; |
747 | |
748 | if (evsel->name) |
749 | return evsel->name; |
750 | |
751 | switch (evsel->core.attr.type) { |
752 | case PERF_TYPE_RAW: |
753 | evsel__raw_name(evsel, bf, size: sizeof(bf)); |
754 | break; |
755 | |
756 | case PERF_TYPE_HARDWARE: |
757 | evsel__hw_name(evsel, bf, size: sizeof(bf)); |
758 | break; |
759 | |
760 | case PERF_TYPE_HW_CACHE: |
761 | evsel__hw_cache_name(evsel, bf, size: sizeof(bf)); |
762 | break; |
763 | |
764 | case PERF_TYPE_SOFTWARE: |
765 | if (evsel__is_tool(evsel)) |
766 | evsel__tool_name(ev: evsel->tool_event, bf, size: sizeof(bf)); |
767 | else |
768 | evsel__sw_name(evsel, bf, size: sizeof(bf)); |
769 | break; |
770 | |
771 | case PERF_TYPE_TRACEPOINT: |
772 | scnprintf(buf: bf, size: sizeof(bf), fmt: "%s" , "unknown tracepoint" ); |
773 | break; |
774 | |
775 | case PERF_TYPE_BREAKPOINT: |
776 | evsel__bp_name(evsel, bf, size: sizeof(bf)); |
777 | break; |
778 | |
779 | default: |
780 | scnprintf(buf: bf, size: sizeof(bf), fmt: "unknown attr type: %d" , |
781 | evsel->core.attr.type); |
782 | break; |
783 | } |
784 | |
785 | evsel->name = strdup(bf); |
786 | |
787 | if (evsel->name) |
788 | return evsel->name; |
789 | out_unknown: |
790 | return "unknown" ; |
791 | } |
792 | |
793 | bool evsel__name_is(struct evsel *evsel, const char *name) |
794 | { |
795 | return !strcmp(evsel__name(evsel), name); |
796 | } |
797 | |
798 | const char *evsel__metric_id(const struct evsel *evsel) |
799 | { |
800 | if (evsel->metric_id) |
801 | return evsel->metric_id; |
802 | |
803 | if (evsel__is_tool(evsel)) |
804 | return perf_tool_event__to_str(ev: evsel->tool_event); |
805 | |
806 | return "unknown" ; |
807 | } |
808 | |
809 | const char *evsel__group_name(struct evsel *evsel) |
810 | { |
811 | return evsel->group_name ?: "anon group" ; |
812 | } |
813 | |
814 | /* |
815 | * Returns the group details for the specified leader, |
816 | * with following rules. |
817 | * |
818 | * For record -e '{cycles,instructions}' |
819 | * 'anon group { cycles:u, instructions:u }' |
820 | * |
821 | * For record -e 'cycles,instructions' and report --group |
822 | * 'cycles:u, instructions:u' |
823 | */ |
824 | int evsel__group_desc(struct evsel *evsel, char *buf, size_t size) |
825 | { |
826 | int ret = 0; |
827 | struct evsel *pos; |
828 | const char *group_name = evsel__group_name(evsel); |
829 | |
830 | if (!evsel->forced_leader) |
831 | ret = scnprintf(buf, size, fmt: "%s { " , group_name); |
832 | |
833 | ret += scnprintf(buf: buf + ret, size: size - ret, fmt: "%s" , evsel__name(evsel)); |
834 | |
835 | for_each_group_member(pos, evsel) |
836 | ret += scnprintf(buf: buf + ret, size: size - ret, fmt: ", %s" , evsel__name(evsel: pos)); |
837 | |
838 | if (!evsel->forced_leader) |
839 | ret += scnprintf(buf: buf + ret, size: size - ret, fmt: " }" ); |
840 | |
841 | return ret; |
842 | } |
843 | |
844 | static void __evsel__config_callchain(struct evsel *evsel, struct record_opts *opts, |
845 | struct callchain_param *param) |
846 | { |
847 | bool function = evsel__is_function_event(evsel); |
848 | struct perf_event_attr *attr = &evsel->core.attr; |
849 | const char *arch = perf_env__arch(evsel__env(evsel)); |
850 | |
851 | evsel__set_sample_bit(evsel, CALLCHAIN); |
852 | |
853 | attr->sample_max_stack = param->max_stack; |
854 | |
855 | if (opts->kernel_callchains) |
856 | attr->exclude_callchain_user = 1; |
857 | if (opts->user_callchains) |
858 | attr->exclude_callchain_kernel = 1; |
859 | if (param->record_mode == CALLCHAIN_LBR) { |
860 | if (!opts->branch_stack) { |
861 | if (attr->exclude_user) { |
862 | pr_warning("LBR callstack option is only available " |
863 | "to get user callchain information. " |
864 | "Falling back to framepointers.\n" ); |
865 | } else { |
866 | evsel__set_sample_bit(evsel, BRANCH_STACK); |
867 | attr->branch_sample_type = PERF_SAMPLE_BRANCH_USER | |
868 | PERF_SAMPLE_BRANCH_CALL_STACK | |
869 | PERF_SAMPLE_BRANCH_NO_CYCLES | |
870 | PERF_SAMPLE_BRANCH_NO_FLAGS | |
871 | PERF_SAMPLE_BRANCH_HW_INDEX; |
872 | } |
873 | } else |
874 | pr_warning("Cannot use LBR callstack with branch stack. " |
875 | "Falling back to framepointers.\n" ); |
876 | } |
877 | |
878 | if (param->record_mode == CALLCHAIN_DWARF) { |
879 | if (!function) { |
880 | evsel__set_sample_bit(evsel, REGS_USER); |
881 | evsel__set_sample_bit(evsel, STACK_USER); |
882 | if (opts->sample_user_regs && |
883 | DWARF_MINIMAL_REGS(arch) != arch__user_reg_mask()) { |
884 | attr->sample_regs_user |= DWARF_MINIMAL_REGS(arch); |
885 | pr_warning("WARNING: The use of --call-graph=dwarf may require all the user registers, " |
886 | "specifying a subset with --user-regs may render DWARF unwinding unreliable, " |
887 | "so the minimal registers set (IP, SP) is explicitly forced.\n" ); |
888 | } else { |
889 | attr->sample_regs_user |= arch__user_reg_mask(); |
890 | } |
891 | attr->sample_stack_user = param->dump_size; |
892 | attr->exclude_callchain_user = 1; |
893 | } else { |
894 | pr_info("Cannot use DWARF unwind for function trace event," |
895 | " falling back to framepointers.\n" ); |
896 | } |
897 | } |
898 | |
899 | if (function) { |
900 | pr_info("Disabling user space callchains for function trace event.\n" ); |
901 | attr->exclude_callchain_user = 1; |
902 | } |
903 | } |
904 | |
905 | void evsel__config_callchain(struct evsel *evsel, struct record_opts *opts, |
906 | struct callchain_param *param) |
907 | { |
908 | if (param->enabled) |
909 | return __evsel__config_callchain(evsel, opts, param); |
910 | } |
911 | |
912 | static void evsel__reset_callgraph(struct evsel *evsel, struct callchain_param *param) |
913 | { |
914 | struct perf_event_attr *attr = &evsel->core.attr; |
915 | |
916 | evsel__reset_sample_bit(evsel, CALLCHAIN); |
917 | if (param->record_mode == CALLCHAIN_LBR) { |
918 | evsel__reset_sample_bit(evsel, BRANCH_STACK); |
919 | attr->branch_sample_type &= ~(PERF_SAMPLE_BRANCH_USER | |
920 | PERF_SAMPLE_BRANCH_CALL_STACK | |
921 | PERF_SAMPLE_BRANCH_HW_INDEX); |
922 | } |
923 | if (param->record_mode == CALLCHAIN_DWARF) { |
924 | evsel__reset_sample_bit(evsel, REGS_USER); |
925 | evsel__reset_sample_bit(evsel, STACK_USER); |
926 | } |
927 | } |
928 | |
929 | static void evsel__apply_config_terms(struct evsel *evsel, |
930 | struct record_opts *opts, bool track) |
931 | { |
932 | struct evsel_config_term *term; |
933 | struct list_head *config_terms = &evsel->config_terms; |
934 | struct perf_event_attr *attr = &evsel->core.attr; |
935 | /* callgraph default */ |
936 | struct callchain_param param = { |
937 | .record_mode = callchain_param.record_mode, |
938 | }; |
939 | u32 dump_size = 0; |
940 | int max_stack = 0; |
941 | const char *callgraph_buf = NULL; |
942 | |
943 | list_for_each_entry(term, config_terms, list) { |
944 | switch (term->type) { |
945 | case EVSEL__CONFIG_TERM_PERIOD: |
946 | if (!(term->weak && opts->user_interval != ULLONG_MAX)) { |
947 | attr->sample_period = term->val.period; |
948 | attr->freq = 0; |
949 | evsel__reset_sample_bit(evsel, PERIOD); |
950 | } |
951 | break; |
952 | case EVSEL__CONFIG_TERM_FREQ: |
953 | if (!(term->weak && opts->user_freq != UINT_MAX)) { |
954 | attr->sample_freq = term->val.freq; |
955 | attr->freq = 1; |
956 | evsel__set_sample_bit(evsel, PERIOD); |
957 | } |
958 | break; |
959 | case EVSEL__CONFIG_TERM_TIME: |
960 | if (term->val.time) |
961 | evsel__set_sample_bit(evsel, TIME); |
962 | else |
963 | evsel__reset_sample_bit(evsel, TIME); |
964 | break; |
965 | case EVSEL__CONFIG_TERM_CALLGRAPH: |
966 | callgraph_buf = term->val.str; |
967 | break; |
968 | case EVSEL__CONFIG_TERM_BRANCH: |
969 | if (term->val.str && strcmp(term->val.str, "no" )) { |
970 | evsel__set_sample_bit(evsel, BRANCH_STACK); |
971 | parse_branch_str(term->val.str, |
972 | &attr->branch_sample_type); |
973 | } else |
974 | evsel__reset_sample_bit(evsel, BRANCH_STACK); |
975 | break; |
976 | case EVSEL__CONFIG_TERM_STACK_USER: |
977 | dump_size = term->val.stack_user; |
978 | break; |
979 | case EVSEL__CONFIG_TERM_MAX_STACK: |
980 | max_stack = term->val.max_stack; |
981 | break; |
982 | case EVSEL__CONFIG_TERM_MAX_EVENTS: |
983 | evsel->max_events = term->val.max_events; |
984 | break; |
985 | case EVSEL__CONFIG_TERM_INHERIT: |
986 | /* |
987 | * attr->inherit should has already been set by |
988 | * evsel__config. If user explicitly set |
989 | * inherit using config terms, override global |
990 | * opt->no_inherit setting. |
991 | */ |
992 | attr->inherit = term->val.inherit ? 1 : 0; |
993 | break; |
994 | case EVSEL__CONFIG_TERM_OVERWRITE: |
995 | attr->write_backward = term->val.overwrite ? 1 : 0; |
996 | break; |
997 | case EVSEL__CONFIG_TERM_DRV_CFG: |
998 | break; |
999 | case EVSEL__CONFIG_TERM_PERCORE: |
1000 | break; |
1001 | case EVSEL__CONFIG_TERM_AUX_OUTPUT: |
1002 | attr->aux_output = term->val.aux_output ? 1 : 0; |
1003 | break; |
1004 | case EVSEL__CONFIG_TERM_AUX_SAMPLE_SIZE: |
1005 | /* Already applied by auxtrace */ |
1006 | break; |
1007 | case EVSEL__CONFIG_TERM_CFG_CHG: |
1008 | break; |
1009 | default: |
1010 | break; |
1011 | } |
1012 | } |
1013 | |
1014 | /* User explicitly set per-event callgraph, clear the old setting and reset. */ |
1015 | if ((callgraph_buf != NULL) || (dump_size > 0) || max_stack) { |
1016 | bool sample_address = false; |
1017 | |
1018 | if (max_stack) { |
1019 | param.max_stack = max_stack; |
1020 | if (callgraph_buf == NULL) |
1021 | callgraph_buf = "fp" ; |
1022 | } |
1023 | |
1024 | /* parse callgraph parameters */ |
1025 | if (callgraph_buf != NULL) { |
1026 | if (!strcmp(callgraph_buf, "no" )) { |
1027 | param.enabled = false; |
1028 | param.record_mode = CALLCHAIN_NONE; |
1029 | } else { |
1030 | param.enabled = true; |
1031 | if (parse_callchain_record(arg: callgraph_buf, param: ¶m)) { |
1032 | pr_err("per-event callgraph setting for %s failed. " |
1033 | "Apply callgraph global setting for it\n" , |
1034 | evsel->name); |
1035 | return; |
1036 | } |
1037 | if (param.record_mode == CALLCHAIN_DWARF) |
1038 | sample_address = true; |
1039 | } |
1040 | } |
1041 | if (dump_size > 0) { |
1042 | dump_size = round_up(dump_size, sizeof(u64)); |
1043 | param.dump_size = dump_size; |
1044 | } |
1045 | |
1046 | /* If global callgraph set, clear it */ |
1047 | if (callchain_param.enabled) |
1048 | evsel__reset_callgraph(evsel, param: &callchain_param); |
1049 | |
1050 | /* set perf-event callgraph */ |
1051 | if (param.enabled) { |
1052 | if (sample_address) { |
1053 | evsel__set_sample_bit(evsel, ADDR); |
1054 | evsel__set_sample_bit(evsel, DATA_SRC); |
1055 | evsel->core.attr.mmap_data = track; |
1056 | } |
1057 | evsel__config_callchain(evsel, opts, param: ¶m); |
1058 | } |
1059 | } |
1060 | } |
1061 | |
1062 | struct evsel_config_term *__evsel__get_config_term(struct evsel *evsel, enum evsel_term_type type) |
1063 | { |
1064 | struct evsel_config_term *term, *found_term = NULL; |
1065 | |
1066 | list_for_each_entry(term, &evsel->config_terms, list) { |
1067 | if (term->type == type) |
1068 | found_term = term; |
1069 | } |
1070 | |
1071 | return found_term; |
1072 | } |
1073 | |
1074 | void __weak arch_evsel__set_sample_weight(struct evsel *evsel) |
1075 | { |
1076 | evsel__set_sample_bit(evsel, WEIGHT); |
1077 | } |
1078 | |
1079 | void __weak arch__post_evsel_config(struct evsel *evsel __maybe_unused, |
1080 | struct perf_event_attr *attr __maybe_unused) |
1081 | { |
1082 | } |
1083 | |
1084 | static void evsel__set_default_freq_period(struct record_opts *opts, |
1085 | struct perf_event_attr *attr) |
1086 | { |
1087 | if (opts->freq) { |
1088 | attr->freq = 1; |
1089 | attr->sample_freq = opts->freq; |
1090 | } else { |
1091 | attr->sample_period = opts->default_interval; |
1092 | } |
1093 | } |
1094 | |
1095 | static bool evsel__is_offcpu_event(struct evsel *evsel) |
1096 | { |
1097 | return evsel__is_bpf_output(evsel) && evsel__name_is(evsel, OFFCPU_EVENT); |
1098 | } |
1099 | |
1100 | /* |
1101 | * The enable_on_exec/disabled value strategy: |
1102 | * |
1103 | * 1) For any type of traced program: |
1104 | * - all independent events and group leaders are disabled |
1105 | * - all group members are enabled |
1106 | * |
1107 | * Group members are ruled by group leaders. They need to |
1108 | * be enabled, because the group scheduling relies on that. |
1109 | * |
1110 | * 2) For traced programs executed by perf: |
1111 | * - all independent events and group leaders have |
1112 | * enable_on_exec set |
1113 | * - we don't specifically enable or disable any event during |
1114 | * the record command |
1115 | * |
1116 | * Independent events and group leaders are initially disabled |
1117 | * and get enabled by exec. Group members are ruled by group |
1118 | * leaders as stated in 1). |
1119 | * |
1120 | * 3) For traced programs attached by perf (pid/tid): |
1121 | * - we specifically enable or disable all events during |
1122 | * the record command |
1123 | * |
1124 | * When attaching events to already running traced we |
1125 | * enable/disable events specifically, as there's no |
1126 | * initial traced exec call. |
1127 | */ |
1128 | void evsel__config(struct evsel *evsel, struct record_opts *opts, |
1129 | struct callchain_param *callchain) |
1130 | { |
1131 | struct evsel *leader = evsel__leader(evsel); |
1132 | struct perf_event_attr *attr = &evsel->core.attr; |
1133 | int track = evsel->tracking; |
1134 | bool per_cpu = opts->target.default_per_cpu && !opts->target.per_thread; |
1135 | |
1136 | attr->sample_id_all = perf_missing_features.sample_id_all ? 0 : 1; |
1137 | attr->inherit = !opts->no_inherit; |
1138 | attr->write_backward = opts->overwrite ? 1 : 0; |
1139 | attr->read_format = PERF_FORMAT_LOST; |
1140 | |
1141 | evsel__set_sample_bit(evsel, IP); |
1142 | evsel__set_sample_bit(evsel, TID); |
1143 | |
1144 | if (evsel->sample_read) { |
1145 | evsel__set_sample_bit(evsel, READ); |
1146 | |
1147 | /* |
1148 | * We need ID even in case of single event, because |
1149 | * PERF_SAMPLE_READ process ID specific data. |
1150 | */ |
1151 | evsel__set_sample_id(evsel, can_sample_identifier: false); |
1152 | |
1153 | /* |
1154 | * Apply group format only if we belong to group |
1155 | * with more than one members. |
1156 | */ |
1157 | if (leader->core.nr_members > 1) { |
1158 | attr->read_format |= PERF_FORMAT_GROUP; |
1159 | attr->inherit = 0; |
1160 | } |
1161 | } |
1162 | |
1163 | /* |
1164 | * We default some events to have a default interval. But keep |
1165 | * it a weak assumption overridable by the user. |
1166 | */ |
1167 | if ((evsel->is_libpfm_event && !attr->sample_period) || |
1168 | (!evsel->is_libpfm_event && (!attr->sample_period || |
1169 | opts->user_freq != UINT_MAX || |
1170 | opts->user_interval != ULLONG_MAX))) |
1171 | evsel__set_default_freq_period(opts, attr); |
1172 | |
1173 | /* |
1174 | * If attr->freq was set (here or earlier), ask for period |
1175 | * to be sampled. |
1176 | */ |
1177 | if (attr->freq) |
1178 | evsel__set_sample_bit(evsel, PERIOD); |
1179 | |
1180 | if (opts->no_samples) |
1181 | attr->sample_freq = 0; |
1182 | |
1183 | if (opts->inherit_stat) { |
1184 | evsel->core.attr.read_format |= |
1185 | PERF_FORMAT_TOTAL_TIME_ENABLED | |
1186 | PERF_FORMAT_TOTAL_TIME_RUNNING | |
1187 | PERF_FORMAT_ID; |
1188 | attr->inherit_stat = 1; |
1189 | } |
1190 | |
1191 | if (opts->sample_address) { |
1192 | evsel__set_sample_bit(evsel, ADDR); |
1193 | attr->mmap_data = track; |
1194 | } |
1195 | |
1196 | /* |
1197 | * We don't allow user space callchains for function trace |
1198 | * event, due to issues with page faults while tracing page |
1199 | * fault handler and its overall trickiness nature. |
1200 | */ |
1201 | if (evsel__is_function_event(evsel)) |
1202 | evsel->core.attr.exclude_callchain_user = 1; |
1203 | |
1204 | if (callchain && callchain->enabled && !evsel->no_aux_samples) |
1205 | evsel__config_callchain(evsel, opts, param: callchain); |
1206 | |
1207 | if (opts->sample_intr_regs && !evsel->no_aux_samples && |
1208 | !evsel__is_dummy_event(evsel)) { |
1209 | attr->sample_regs_intr = opts->sample_intr_regs; |
1210 | evsel__set_sample_bit(evsel, REGS_INTR); |
1211 | } |
1212 | |
1213 | if (opts->sample_user_regs && !evsel->no_aux_samples && |
1214 | !evsel__is_dummy_event(evsel)) { |
1215 | attr->sample_regs_user |= opts->sample_user_regs; |
1216 | evsel__set_sample_bit(evsel, REGS_USER); |
1217 | } |
1218 | |
1219 | if (target__has_cpu(target: &opts->target) || opts->sample_cpu) |
1220 | evsel__set_sample_bit(evsel, CPU); |
1221 | |
1222 | /* |
1223 | * When the user explicitly disabled time don't force it here. |
1224 | */ |
1225 | if (opts->sample_time && |
1226 | (!perf_missing_features.sample_id_all && |
1227 | (!opts->no_inherit || target__has_cpu(target: &opts->target) || per_cpu || |
1228 | opts->sample_time_set))) |
1229 | evsel__set_sample_bit(evsel, TIME); |
1230 | |
1231 | if (opts->raw_samples && !evsel->no_aux_samples) { |
1232 | evsel__set_sample_bit(evsel, TIME); |
1233 | evsel__set_sample_bit(evsel, RAW); |
1234 | evsel__set_sample_bit(evsel, CPU); |
1235 | } |
1236 | |
1237 | if (opts->sample_address) |
1238 | evsel__set_sample_bit(evsel, DATA_SRC); |
1239 | |
1240 | if (opts->sample_phys_addr) |
1241 | evsel__set_sample_bit(evsel, PHYS_ADDR); |
1242 | |
1243 | if (opts->no_buffering) { |
1244 | attr->watermark = 0; |
1245 | attr->wakeup_events = 1; |
1246 | } |
1247 | if (opts->branch_stack && !evsel->no_aux_samples) { |
1248 | evsel__set_sample_bit(evsel, BRANCH_STACK); |
1249 | attr->branch_sample_type = opts->branch_stack; |
1250 | } |
1251 | |
1252 | if (opts->sample_weight) |
1253 | arch_evsel__set_sample_weight(evsel); |
1254 | |
1255 | attr->task = track; |
1256 | attr->mmap = track; |
1257 | attr->mmap2 = track && !perf_missing_features.mmap2; |
1258 | attr->comm = track; |
1259 | attr->build_id = track && opts->build_id; |
1260 | |
1261 | /* |
1262 | * ksymbol is tracked separately with text poke because it needs to be |
1263 | * system wide and enabled immediately. |
1264 | */ |
1265 | if (!opts->text_poke) |
1266 | attr->ksymbol = track && !perf_missing_features.ksymbol; |
1267 | attr->bpf_event = track && !opts->no_bpf_event && !perf_missing_features.bpf; |
1268 | |
1269 | if (opts->record_namespaces) |
1270 | attr->namespaces = track; |
1271 | |
1272 | if (opts->record_cgroup) { |
1273 | attr->cgroup = track && !perf_missing_features.cgroup; |
1274 | evsel__set_sample_bit(evsel, CGROUP); |
1275 | } |
1276 | |
1277 | if (opts->sample_data_page_size) |
1278 | evsel__set_sample_bit(evsel, DATA_PAGE_SIZE); |
1279 | |
1280 | if (opts->sample_code_page_size) |
1281 | evsel__set_sample_bit(evsel, CODE_PAGE_SIZE); |
1282 | |
1283 | if (opts->record_switch_events) |
1284 | attr->context_switch = track; |
1285 | |
1286 | if (opts->sample_transaction) |
1287 | evsel__set_sample_bit(evsel, TRANSACTION); |
1288 | |
1289 | if (opts->running_time) { |
1290 | evsel->core.attr.read_format |= |
1291 | PERF_FORMAT_TOTAL_TIME_ENABLED | |
1292 | PERF_FORMAT_TOTAL_TIME_RUNNING; |
1293 | } |
1294 | |
1295 | /* |
1296 | * XXX see the function comment above |
1297 | * |
1298 | * Disabling only independent events or group leaders, |
1299 | * keeping group members enabled. |
1300 | */ |
1301 | if (evsel__is_group_leader(evsel)) |
1302 | attr->disabled = 1; |
1303 | |
1304 | /* |
1305 | * Setting enable_on_exec for independent events and |
1306 | * group leaders for traced executed by perf. |
1307 | */ |
1308 | if (target__none(target: &opts->target) && evsel__is_group_leader(evsel) && |
1309 | !opts->target.initial_delay) |
1310 | attr->enable_on_exec = 1; |
1311 | |
1312 | if (evsel->immediate) { |
1313 | attr->disabled = 0; |
1314 | attr->enable_on_exec = 0; |
1315 | } |
1316 | |
1317 | clockid = opts->clockid; |
1318 | if (opts->use_clockid) { |
1319 | attr->use_clockid = 1; |
1320 | attr->clockid = opts->clockid; |
1321 | } |
1322 | |
1323 | if (evsel->precise_max) |
1324 | attr->precise_ip = 3; |
1325 | |
1326 | if (opts->all_user) { |
1327 | attr->exclude_kernel = 1; |
1328 | attr->exclude_user = 0; |
1329 | } |
1330 | |
1331 | if (opts->all_kernel) { |
1332 | attr->exclude_kernel = 0; |
1333 | attr->exclude_user = 1; |
1334 | } |
1335 | |
1336 | if (evsel->core.own_cpus || evsel->unit) |
1337 | evsel->core.attr.read_format |= PERF_FORMAT_ID; |
1338 | |
1339 | /* |
1340 | * Apply event specific term settings, |
1341 | * it overloads any global configuration. |
1342 | */ |
1343 | evsel__apply_config_terms(evsel, opts, track); |
1344 | |
1345 | evsel->ignore_missing_thread = opts->ignore_missing_thread; |
1346 | |
1347 | /* The --period option takes the precedence. */ |
1348 | if (opts->period_set) { |
1349 | if (opts->period) |
1350 | evsel__set_sample_bit(evsel, PERIOD); |
1351 | else |
1352 | evsel__reset_sample_bit(evsel, PERIOD); |
1353 | } |
1354 | |
1355 | /* |
1356 | * A dummy event never triggers any actual counter and therefore |
1357 | * cannot be used with branch_stack. |
1358 | * |
1359 | * For initial_delay, a dummy event is added implicitly. |
1360 | * The software event will trigger -EOPNOTSUPP error out, |
1361 | * if BRANCH_STACK bit is set. |
1362 | */ |
1363 | if (evsel__is_dummy_event(evsel)) |
1364 | evsel__reset_sample_bit(evsel, BRANCH_STACK); |
1365 | |
1366 | if (evsel__is_offcpu_event(evsel)) |
1367 | evsel->core.attr.sample_type &= OFFCPU_SAMPLE_TYPES; |
1368 | |
1369 | arch__post_evsel_config(evsel, attr); |
1370 | } |
1371 | |
1372 | int evsel__set_filter(struct evsel *evsel, const char *filter) |
1373 | { |
1374 | char *new_filter = strdup(filter); |
1375 | |
1376 | if (new_filter != NULL) { |
1377 | free(evsel->filter); |
1378 | evsel->filter = new_filter; |
1379 | return 0; |
1380 | } |
1381 | |
1382 | return -1; |
1383 | } |
1384 | |
1385 | static int evsel__append_filter(struct evsel *evsel, const char *fmt, const char *filter) |
1386 | { |
1387 | char *new_filter; |
1388 | |
1389 | if (evsel->filter == NULL) |
1390 | return evsel__set_filter(evsel, filter); |
1391 | |
1392 | if (asprintf(&new_filter, fmt, evsel->filter, filter) > 0) { |
1393 | free(evsel->filter); |
1394 | evsel->filter = new_filter; |
1395 | return 0; |
1396 | } |
1397 | |
1398 | return -1; |
1399 | } |
1400 | |
1401 | int evsel__append_tp_filter(struct evsel *evsel, const char *filter) |
1402 | { |
1403 | return evsel__append_filter(evsel, fmt: "(%s) && (%s)" , filter); |
1404 | } |
1405 | |
1406 | int evsel__append_addr_filter(struct evsel *evsel, const char *filter) |
1407 | { |
1408 | return evsel__append_filter(evsel, fmt: "%s,%s" , filter); |
1409 | } |
1410 | |
1411 | /* Caller has to clear disabled after going through all CPUs. */ |
1412 | int evsel__enable_cpu(struct evsel *evsel, int cpu_map_idx) |
1413 | { |
1414 | return perf_evsel__enable_cpu(&evsel->core, cpu_map_idx); |
1415 | } |
1416 | |
1417 | int evsel__enable(struct evsel *evsel) |
1418 | { |
1419 | int err = perf_evsel__enable(&evsel->core); |
1420 | |
1421 | if (!err) |
1422 | evsel->disabled = false; |
1423 | return err; |
1424 | } |
1425 | |
1426 | /* Caller has to set disabled after going through all CPUs. */ |
1427 | int evsel__disable_cpu(struct evsel *evsel, int cpu_map_idx) |
1428 | { |
1429 | return perf_evsel__disable_cpu(&evsel->core, cpu_map_idx); |
1430 | } |
1431 | |
1432 | int evsel__disable(struct evsel *evsel) |
1433 | { |
1434 | int err = perf_evsel__disable(&evsel->core); |
1435 | /* |
1436 | * We mark it disabled here so that tools that disable a event can |
1437 | * ignore events after they disable it. I.e. the ring buffer may have |
1438 | * already a few more events queued up before the kernel got the stop |
1439 | * request. |
1440 | */ |
1441 | if (!err) |
1442 | evsel->disabled = true; |
1443 | |
1444 | return err; |
1445 | } |
1446 | |
1447 | void free_config_terms(struct list_head *config_terms) |
1448 | { |
1449 | struct evsel_config_term *term, *h; |
1450 | |
1451 | list_for_each_entry_safe(term, h, config_terms, list) { |
1452 | list_del_init(entry: &term->list); |
1453 | if (term->free_str) |
1454 | zfree(&term->val.str); |
1455 | free(term); |
1456 | } |
1457 | } |
1458 | |
1459 | static void evsel__free_config_terms(struct evsel *evsel) |
1460 | { |
1461 | free_config_terms(config_terms: &evsel->config_terms); |
1462 | } |
1463 | |
1464 | void evsel__exit(struct evsel *evsel) |
1465 | { |
1466 | assert(list_empty(head: &evsel->core.node)); |
1467 | assert(evsel->evlist == NULL); |
1468 | bpf_counter__destroy(evsel); |
1469 | perf_bpf_filter__destroy(evsel); |
1470 | evsel__free_counts(evsel); |
1471 | perf_evsel__free_fd(&evsel->core); |
1472 | perf_evsel__free_id(&evsel->core); |
1473 | evsel__free_config_terms(evsel); |
1474 | cgroup__put(cgroup: evsel->cgrp); |
1475 | perf_cpu_map__put(evsel->core.cpus); |
1476 | perf_cpu_map__put(evsel->core.own_cpus); |
1477 | perf_thread_map__put(evsel->core.threads); |
1478 | zfree(&evsel->group_name); |
1479 | zfree(&evsel->name); |
1480 | zfree(&evsel->filter); |
1481 | zfree(&evsel->pmu_name); |
1482 | zfree(&evsel->group_pmu_name); |
1483 | zfree(&evsel->unit); |
1484 | zfree(&evsel->metric_id); |
1485 | evsel__zero_per_pkg(evsel); |
1486 | hashmap__free(evsel->per_pkg_mask); |
1487 | evsel->per_pkg_mask = NULL; |
1488 | zfree(&evsel->metric_events); |
1489 | perf_evsel__object.fini(evsel); |
1490 | } |
1491 | |
1492 | void evsel__delete(struct evsel *evsel) |
1493 | { |
1494 | if (!evsel) |
1495 | return; |
1496 | |
1497 | evsel__exit(evsel); |
1498 | free(evsel); |
1499 | } |
1500 | |
1501 | void evsel__compute_deltas(struct evsel *evsel, int cpu_map_idx, int thread, |
1502 | struct perf_counts_values *count) |
1503 | { |
1504 | struct perf_counts_values tmp; |
1505 | |
1506 | if (!evsel->prev_raw_counts) |
1507 | return; |
1508 | |
1509 | tmp = *perf_counts(counts: evsel->prev_raw_counts, cpu_map_idx, thread); |
1510 | *perf_counts(counts: evsel->prev_raw_counts, cpu_map_idx, thread) = *count; |
1511 | |
1512 | count->val = count->val - tmp.val; |
1513 | count->ena = count->ena - tmp.ena; |
1514 | count->run = count->run - tmp.run; |
1515 | } |
1516 | |
1517 | static int evsel__read_one(struct evsel *evsel, int cpu_map_idx, int thread) |
1518 | { |
1519 | struct perf_counts_values *count = perf_counts(counts: evsel->counts, cpu_map_idx, thread); |
1520 | |
1521 | return perf_evsel__read(&evsel->core, cpu_map_idx, thread, count); |
1522 | } |
1523 | |
1524 | static void evsel__set_count(struct evsel *counter, int cpu_map_idx, int thread, |
1525 | u64 val, u64 ena, u64 run, u64 lost) |
1526 | { |
1527 | struct perf_counts_values *count; |
1528 | |
1529 | count = perf_counts(counts: counter->counts, cpu_map_idx, thread); |
1530 | |
1531 | count->val = val; |
1532 | count->ena = ena; |
1533 | count->run = run; |
1534 | count->lost = lost; |
1535 | |
1536 | perf_counts__set_loaded(counts: counter->counts, cpu_map_idx, thread, loaded: true); |
1537 | } |
1538 | |
1539 | static int evsel__process_group_data(struct evsel *leader, int cpu_map_idx, int thread, u64 *data) |
1540 | { |
1541 | u64 read_format = leader->core.attr.read_format; |
1542 | struct sample_read_value *v; |
1543 | u64 nr, ena = 0, run = 0, lost = 0; |
1544 | |
1545 | nr = *data++; |
1546 | |
1547 | if (nr != (u64) leader->core.nr_members) |
1548 | return -EINVAL; |
1549 | |
1550 | if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) |
1551 | ena = *data++; |
1552 | |
1553 | if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) |
1554 | run = *data++; |
1555 | |
1556 | v = (void *)data; |
1557 | sample_read_group__for_each(v, nr, read_format) { |
1558 | struct evsel *counter; |
1559 | |
1560 | counter = evlist__id2evsel(evlist: leader->evlist, id: v->id); |
1561 | if (!counter) |
1562 | return -EINVAL; |
1563 | |
1564 | if (read_format & PERF_FORMAT_LOST) |
1565 | lost = v->lost; |
1566 | |
1567 | evsel__set_count(counter, cpu_map_idx, thread, val: v->value, ena, run, lost); |
1568 | } |
1569 | |
1570 | return 0; |
1571 | } |
1572 | |
1573 | static int evsel__read_group(struct evsel *leader, int cpu_map_idx, int thread) |
1574 | { |
1575 | struct perf_stat_evsel *ps = leader->stats; |
1576 | u64 read_format = leader->core.attr.read_format; |
1577 | int size = perf_evsel__read_size(&leader->core); |
1578 | u64 *data = ps->group_data; |
1579 | |
1580 | if (!(read_format & PERF_FORMAT_ID)) |
1581 | return -EINVAL; |
1582 | |
1583 | if (!evsel__is_group_leader(evsel: leader)) |
1584 | return -EINVAL; |
1585 | |
1586 | if (!data) { |
1587 | data = zalloc(size); |
1588 | if (!data) |
1589 | return -ENOMEM; |
1590 | |
1591 | ps->group_data = data; |
1592 | } |
1593 | |
1594 | if (FD(leader, cpu_map_idx, thread) < 0) |
1595 | return -EINVAL; |
1596 | |
1597 | if (readn(FD(leader, cpu_map_idx, thread), data, size) <= 0) |
1598 | return -errno; |
1599 | |
1600 | return evsel__process_group_data(leader, cpu_map_idx, thread, data); |
1601 | } |
1602 | |
1603 | int evsel__read_counter(struct evsel *evsel, int cpu_map_idx, int thread) |
1604 | { |
1605 | u64 read_format = evsel->core.attr.read_format; |
1606 | |
1607 | if (read_format & PERF_FORMAT_GROUP) |
1608 | return evsel__read_group(leader: evsel, cpu_map_idx, thread); |
1609 | |
1610 | return evsel__read_one(evsel, cpu_map_idx, thread); |
1611 | } |
1612 | |
1613 | int __evsel__read_on_cpu(struct evsel *evsel, int cpu_map_idx, int thread, bool scale) |
1614 | { |
1615 | struct perf_counts_values count; |
1616 | size_t nv = scale ? 3 : 1; |
1617 | |
1618 | if (FD(evsel, cpu_map_idx, thread) < 0) |
1619 | return -EINVAL; |
1620 | |
1621 | if (evsel->counts == NULL && evsel__alloc_counts(evsel) < 0) |
1622 | return -ENOMEM; |
1623 | |
1624 | if (readn(FD(evsel, cpu_map_idx, thread), &count, nv * sizeof(u64)) <= 0) |
1625 | return -errno; |
1626 | |
1627 | evsel__compute_deltas(evsel, cpu_map_idx, thread, count: &count); |
1628 | perf_counts_values__scale(&count, scale, NULL); |
1629 | *perf_counts(counts: evsel->counts, cpu_map_idx, thread) = count; |
1630 | return 0; |
1631 | } |
1632 | |
1633 | static int evsel__match_other_cpu(struct evsel *evsel, struct evsel *other, |
1634 | int cpu_map_idx) |
1635 | { |
1636 | struct perf_cpu cpu; |
1637 | |
1638 | cpu = perf_cpu_map__cpu(evsel->core.cpus, cpu_map_idx); |
1639 | return perf_cpu_map__idx(other->core.cpus, cpu); |
1640 | } |
1641 | |
1642 | static int evsel__hybrid_group_cpu_map_idx(struct evsel *evsel, int cpu_map_idx) |
1643 | { |
1644 | struct evsel *leader = evsel__leader(evsel); |
1645 | |
1646 | if ((evsel__is_hybrid(evsel) && !evsel__is_hybrid(evsel: leader)) || |
1647 | (!evsel__is_hybrid(evsel) && evsel__is_hybrid(evsel: leader))) { |
1648 | return evsel__match_other_cpu(evsel, other: leader, cpu_map_idx); |
1649 | } |
1650 | |
1651 | return cpu_map_idx; |
1652 | } |
1653 | |
1654 | static int get_group_fd(struct evsel *evsel, int cpu_map_idx, int thread) |
1655 | { |
1656 | struct evsel *leader = evsel__leader(evsel); |
1657 | int fd; |
1658 | |
1659 | if (evsel__is_group_leader(evsel)) |
1660 | return -1; |
1661 | |
1662 | /* |
1663 | * Leader must be already processed/open, |
1664 | * if not it's a bug. |
1665 | */ |
1666 | BUG_ON(!leader->core.fd); |
1667 | |
1668 | cpu_map_idx = evsel__hybrid_group_cpu_map_idx(evsel, cpu_map_idx); |
1669 | if (cpu_map_idx == -1) |
1670 | return -1; |
1671 | |
1672 | fd = FD(leader, cpu_map_idx, thread); |
1673 | BUG_ON(fd == -1 && !leader->skippable); |
1674 | |
1675 | /* |
1676 | * When the leader has been skipped, return -2 to distinguish from no |
1677 | * group leader case. |
1678 | */ |
1679 | return fd == -1 ? -2 : fd; |
1680 | } |
1681 | |
1682 | static void evsel__remove_fd(struct evsel *pos, int nr_cpus, int nr_threads, int thread_idx) |
1683 | { |
1684 | for (int cpu = 0; cpu < nr_cpus; cpu++) |
1685 | for (int thread = thread_idx; thread < nr_threads - 1; thread++) |
1686 | FD(pos, cpu, thread) = FD(pos, cpu, thread + 1); |
1687 | } |
1688 | |
1689 | static int update_fds(struct evsel *evsel, |
1690 | int nr_cpus, int cpu_map_idx, |
1691 | int nr_threads, int thread_idx) |
1692 | { |
1693 | struct evsel *pos; |
1694 | |
1695 | if (cpu_map_idx >= nr_cpus || thread_idx >= nr_threads) |
1696 | return -EINVAL; |
1697 | |
1698 | evlist__for_each_entry(evsel->evlist, pos) { |
1699 | nr_cpus = pos != evsel ? nr_cpus : cpu_map_idx; |
1700 | |
1701 | evsel__remove_fd(pos, nr_cpus, nr_threads, thread_idx); |
1702 | |
1703 | /* |
1704 | * Since fds for next evsel has not been created, |
1705 | * there is no need to iterate whole event list. |
1706 | */ |
1707 | if (pos == evsel) |
1708 | break; |
1709 | } |
1710 | return 0; |
1711 | } |
1712 | |
1713 | static bool evsel__ignore_missing_thread(struct evsel *evsel, |
1714 | int nr_cpus, int cpu_map_idx, |
1715 | struct perf_thread_map *threads, |
1716 | int thread, int err) |
1717 | { |
1718 | pid_t ignore_pid = perf_thread_map__pid(threads, thread); |
1719 | |
1720 | if (!evsel->ignore_missing_thread) |
1721 | return false; |
1722 | |
1723 | /* The system wide setup does not work with threads. */ |
1724 | if (evsel->core.system_wide) |
1725 | return false; |
1726 | |
1727 | /* The -ESRCH is perf event syscall errno for pid's not found. */ |
1728 | if (err != -ESRCH) |
1729 | return false; |
1730 | |
1731 | /* If there's only one thread, let it fail. */ |
1732 | if (threads->nr == 1) |
1733 | return false; |
1734 | |
1735 | /* |
1736 | * We should remove fd for missing_thread first |
1737 | * because thread_map__remove() will decrease threads->nr. |
1738 | */ |
1739 | if (update_fds(evsel, nr_cpus, cpu_map_idx, nr_threads: threads->nr, thread_idx: thread)) |
1740 | return false; |
1741 | |
1742 | if (thread_map__remove(threads, idx: thread)) |
1743 | return false; |
1744 | |
1745 | pr_warning("WARNING: Ignored open failure for pid %d\n" , |
1746 | ignore_pid); |
1747 | return true; |
1748 | } |
1749 | |
1750 | static int __open_attr__fprintf(FILE *fp, const char *name, const char *val, |
1751 | void *priv __maybe_unused) |
1752 | { |
1753 | return fprintf(fp, " %-32s %s\n" , name, val); |
1754 | } |
1755 | |
1756 | static void display_attr(struct perf_event_attr *attr) |
1757 | { |
1758 | if (verbose >= 2 || debug_peo_args) { |
1759 | fprintf(stderr, "%.60s\n" , graph_dotted_line); |
1760 | fprintf(stderr, "perf_event_attr:\n" ); |
1761 | perf_event_attr__fprintf(stderr, attr, __open_attr__fprintf, NULL); |
1762 | fprintf(stderr, "%.60s\n" , graph_dotted_line); |
1763 | } |
1764 | } |
1765 | |
1766 | bool evsel__precise_ip_fallback(struct evsel *evsel) |
1767 | { |
1768 | /* Do not try less precise if not requested. */ |
1769 | if (!evsel->precise_max) |
1770 | return false; |
1771 | |
1772 | /* |
1773 | * We tried all the precise_ip values, and it's |
1774 | * still failing, so leave it to standard fallback. |
1775 | */ |
1776 | if (!evsel->core.attr.precise_ip) { |
1777 | evsel->core.attr.precise_ip = evsel->precise_ip_original; |
1778 | return false; |
1779 | } |
1780 | |
1781 | if (!evsel->precise_ip_original) |
1782 | evsel->precise_ip_original = evsel->core.attr.precise_ip; |
1783 | |
1784 | evsel->core.attr.precise_ip--; |
1785 | pr_debug2_peo("decreasing precise_ip by one (%d)\n" , evsel->core.attr.precise_ip); |
1786 | display_attr(attr: &evsel->core.attr); |
1787 | return true; |
1788 | } |
1789 | |
1790 | static struct perf_cpu_map *empty_cpu_map; |
1791 | static struct perf_thread_map *empty_thread_map; |
1792 | |
1793 | static int __evsel__prepare_open(struct evsel *evsel, struct perf_cpu_map *cpus, |
1794 | struct perf_thread_map *threads) |
1795 | { |
1796 | int nthreads = perf_thread_map__nr(threads); |
1797 | |
1798 | if ((perf_missing_features.write_backward && evsel->core.attr.write_backward) || |
1799 | (perf_missing_features.aux_output && evsel->core.attr.aux_output)) |
1800 | return -EINVAL; |
1801 | |
1802 | if (cpus == NULL) { |
1803 | if (empty_cpu_map == NULL) { |
1804 | empty_cpu_map = perf_cpu_map__new_any_cpu(); |
1805 | if (empty_cpu_map == NULL) |
1806 | return -ENOMEM; |
1807 | } |
1808 | |
1809 | cpus = empty_cpu_map; |
1810 | } |
1811 | |
1812 | if (threads == NULL) { |
1813 | if (empty_thread_map == NULL) { |
1814 | empty_thread_map = thread_map__new_by_tid(tid: -1); |
1815 | if (empty_thread_map == NULL) |
1816 | return -ENOMEM; |
1817 | } |
1818 | |
1819 | threads = empty_thread_map; |
1820 | } |
1821 | |
1822 | if (evsel->core.fd == NULL && |
1823 | perf_evsel__alloc_fd(&evsel->core, perf_cpu_map__nr(cpus), nthreads) < 0) |
1824 | return -ENOMEM; |
1825 | |
1826 | evsel->open_flags = PERF_FLAG_FD_CLOEXEC; |
1827 | if (evsel->cgrp) |
1828 | evsel->open_flags |= PERF_FLAG_PID_CGROUP; |
1829 | |
1830 | return 0; |
1831 | } |
1832 | |
1833 | static void evsel__disable_missing_features(struct evsel *evsel) |
1834 | { |
1835 | if (perf_missing_features.branch_counters) |
1836 | evsel->core.attr.branch_sample_type &= ~PERF_SAMPLE_BRANCH_COUNTERS; |
1837 | if (perf_missing_features.read_lost) |
1838 | evsel->core.attr.read_format &= ~PERF_FORMAT_LOST; |
1839 | if (perf_missing_features.weight_struct) { |
1840 | evsel__set_sample_bit(evsel, WEIGHT); |
1841 | evsel__reset_sample_bit(evsel, WEIGHT_STRUCT); |
1842 | } |
1843 | if (perf_missing_features.clockid_wrong) |
1844 | evsel->core.attr.clockid = CLOCK_MONOTONIC; /* should always work */ |
1845 | if (perf_missing_features.clockid) { |
1846 | evsel->core.attr.use_clockid = 0; |
1847 | evsel->core.attr.clockid = 0; |
1848 | } |
1849 | if (perf_missing_features.cloexec) |
1850 | evsel->open_flags &= ~(unsigned long)PERF_FLAG_FD_CLOEXEC; |
1851 | if (perf_missing_features.mmap2) |
1852 | evsel->core.attr.mmap2 = 0; |
1853 | if (evsel->pmu && evsel->pmu->missing_features.exclude_guest) |
1854 | evsel->core.attr.exclude_guest = evsel->core.attr.exclude_host = 0; |
1855 | if (perf_missing_features.lbr_flags) |
1856 | evsel->core.attr.branch_sample_type &= ~(PERF_SAMPLE_BRANCH_NO_FLAGS | |
1857 | PERF_SAMPLE_BRANCH_NO_CYCLES); |
1858 | if (perf_missing_features.group_read && evsel->core.attr.inherit) |
1859 | evsel->core.attr.read_format &= ~(PERF_FORMAT_GROUP|PERF_FORMAT_ID); |
1860 | if (perf_missing_features.ksymbol) |
1861 | evsel->core.attr.ksymbol = 0; |
1862 | if (perf_missing_features.bpf) |
1863 | evsel->core.attr.bpf_event = 0; |
1864 | if (perf_missing_features.branch_hw_idx) |
1865 | evsel->core.attr.branch_sample_type &= ~PERF_SAMPLE_BRANCH_HW_INDEX; |
1866 | if (perf_missing_features.sample_id_all) |
1867 | evsel->core.attr.sample_id_all = 0; |
1868 | } |
1869 | |
1870 | int evsel__prepare_open(struct evsel *evsel, struct perf_cpu_map *cpus, |
1871 | struct perf_thread_map *threads) |
1872 | { |
1873 | int err; |
1874 | |
1875 | err = __evsel__prepare_open(evsel, cpus, threads); |
1876 | if (err) |
1877 | return err; |
1878 | |
1879 | evsel__disable_missing_features(evsel); |
1880 | |
1881 | return err; |
1882 | } |
1883 | |
1884 | bool evsel__detect_missing_features(struct evsel *evsel) |
1885 | { |
1886 | /* |
1887 | * Must probe features in the order they were added to the |
1888 | * perf_event_attr interface. |
1889 | */ |
1890 | if (!perf_missing_features.branch_counters && |
1891 | (evsel->core.attr.branch_sample_type & PERF_SAMPLE_BRANCH_COUNTERS)) { |
1892 | perf_missing_features.branch_counters = true; |
1893 | pr_debug2("switching off branch counters support\n" ); |
1894 | return true; |
1895 | } else if (!perf_missing_features.read_lost && |
1896 | (evsel->core.attr.read_format & PERF_FORMAT_LOST)) { |
1897 | perf_missing_features.read_lost = true; |
1898 | pr_debug2("switching off PERF_FORMAT_LOST support\n" ); |
1899 | return true; |
1900 | } else if (!perf_missing_features.weight_struct && |
1901 | (evsel->core.attr.sample_type & PERF_SAMPLE_WEIGHT_STRUCT)) { |
1902 | perf_missing_features.weight_struct = true; |
1903 | pr_debug2("switching off weight struct support\n" ); |
1904 | return true; |
1905 | } else if (!perf_missing_features.code_page_size && |
1906 | (evsel->core.attr.sample_type & PERF_SAMPLE_CODE_PAGE_SIZE)) { |
1907 | perf_missing_features.code_page_size = true; |
1908 | pr_debug2_peo("Kernel has no PERF_SAMPLE_CODE_PAGE_SIZE support, bailing out\n" ); |
1909 | return false; |
1910 | } else if (!perf_missing_features.data_page_size && |
1911 | (evsel->core.attr.sample_type & PERF_SAMPLE_DATA_PAGE_SIZE)) { |
1912 | perf_missing_features.data_page_size = true; |
1913 | pr_debug2_peo("Kernel has no PERF_SAMPLE_DATA_PAGE_SIZE support, bailing out\n" ); |
1914 | return false; |
1915 | } else if (!perf_missing_features.cgroup && evsel->core.attr.cgroup) { |
1916 | perf_missing_features.cgroup = true; |
1917 | pr_debug2_peo("Kernel has no cgroup sampling support, bailing out\n" ); |
1918 | return false; |
1919 | } else if (!perf_missing_features.branch_hw_idx && |
1920 | (evsel->core.attr.branch_sample_type & PERF_SAMPLE_BRANCH_HW_INDEX)) { |
1921 | perf_missing_features.branch_hw_idx = true; |
1922 | pr_debug2("switching off branch HW index support\n" ); |
1923 | return true; |
1924 | } else if (!perf_missing_features.aux_output && evsel->core.attr.aux_output) { |
1925 | perf_missing_features.aux_output = true; |
1926 | pr_debug2_peo("Kernel has no attr.aux_output support, bailing out\n" ); |
1927 | return false; |
1928 | } else if (!perf_missing_features.bpf && evsel->core.attr.bpf_event) { |
1929 | perf_missing_features.bpf = true; |
1930 | pr_debug2_peo("switching off bpf_event\n" ); |
1931 | return true; |
1932 | } else if (!perf_missing_features.ksymbol && evsel->core.attr.ksymbol) { |
1933 | perf_missing_features.ksymbol = true; |
1934 | pr_debug2_peo("switching off ksymbol\n" ); |
1935 | return true; |
1936 | } else if (!perf_missing_features.write_backward && evsel->core.attr.write_backward) { |
1937 | perf_missing_features.write_backward = true; |
1938 | pr_debug2_peo("switching off write_backward\n" ); |
1939 | return false; |
1940 | } else if (!perf_missing_features.clockid_wrong && evsel->core.attr.use_clockid) { |
1941 | perf_missing_features.clockid_wrong = true; |
1942 | pr_debug2_peo("switching off clockid\n" ); |
1943 | return true; |
1944 | } else if (!perf_missing_features.clockid && evsel->core.attr.use_clockid) { |
1945 | perf_missing_features.clockid = true; |
1946 | pr_debug2_peo("switching off use_clockid\n" ); |
1947 | return true; |
1948 | } else if (!perf_missing_features.cloexec && (evsel->open_flags & PERF_FLAG_FD_CLOEXEC)) { |
1949 | perf_missing_features.cloexec = true; |
1950 | pr_debug2_peo("switching off cloexec flag\n" ); |
1951 | return true; |
1952 | } else if (!perf_missing_features.mmap2 && evsel->core.attr.mmap2) { |
1953 | perf_missing_features.mmap2 = true; |
1954 | pr_debug2_peo("switching off mmap2\n" ); |
1955 | return true; |
1956 | } else if (evsel->core.attr.exclude_guest || evsel->core.attr.exclude_host) { |
1957 | if (evsel->pmu == NULL) |
1958 | evsel->pmu = evsel__find_pmu(evsel); |
1959 | |
1960 | if (evsel->pmu) |
1961 | evsel->pmu->missing_features.exclude_guest = true; |
1962 | else { |
1963 | /* we cannot find PMU, disable attrs now */ |
1964 | evsel->core.attr.exclude_host = false; |
1965 | evsel->core.attr.exclude_guest = false; |
1966 | } |
1967 | |
1968 | if (evsel->exclude_GH) { |
1969 | pr_debug2_peo("PMU has no exclude_host/guest support, bailing out\n" ); |
1970 | return false; |
1971 | } |
1972 | if (!perf_missing_features.exclude_guest) { |
1973 | perf_missing_features.exclude_guest = true; |
1974 | pr_debug2_peo("switching off exclude_guest, exclude_host\n" ); |
1975 | } |
1976 | return true; |
1977 | } else if (!perf_missing_features.sample_id_all) { |
1978 | perf_missing_features.sample_id_all = true; |
1979 | pr_debug2_peo("switching off sample_id_all\n" ); |
1980 | return true; |
1981 | } else if (!perf_missing_features.lbr_flags && |
1982 | (evsel->core.attr.branch_sample_type & |
1983 | (PERF_SAMPLE_BRANCH_NO_CYCLES | |
1984 | PERF_SAMPLE_BRANCH_NO_FLAGS))) { |
1985 | perf_missing_features.lbr_flags = true; |
1986 | pr_debug2_peo("switching off branch sample type no (cycles/flags)\n" ); |
1987 | return true; |
1988 | } else if (!perf_missing_features.group_read && |
1989 | evsel->core.attr.inherit && |
1990 | (evsel->core.attr.read_format & PERF_FORMAT_GROUP) && |
1991 | evsel__is_group_leader(evsel)) { |
1992 | perf_missing_features.group_read = true; |
1993 | pr_debug2_peo("switching off group read\n" ); |
1994 | return true; |
1995 | } else { |
1996 | return false; |
1997 | } |
1998 | } |
1999 | |
2000 | static int evsel__open_cpu(struct evsel *evsel, struct perf_cpu_map *cpus, |
2001 | struct perf_thread_map *threads, |
2002 | int start_cpu_map_idx, int end_cpu_map_idx) |
2003 | { |
2004 | int idx, thread, nthreads; |
2005 | int pid = -1, err, old_errno; |
2006 | enum rlimit_action set_rlimit = NO_CHANGE; |
2007 | |
2008 | err = __evsel__prepare_open(evsel, cpus, threads); |
2009 | if (err) |
2010 | return err; |
2011 | |
2012 | if (cpus == NULL) |
2013 | cpus = empty_cpu_map; |
2014 | |
2015 | if (threads == NULL) |
2016 | threads = empty_thread_map; |
2017 | |
2018 | nthreads = perf_thread_map__nr(threads); |
2019 | |
2020 | if (evsel->cgrp) |
2021 | pid = evsel->cgrp->fd; |
2022 | |
2023 | fallback_missing_features: |
2024 | evsel__disable_missing_features(evsel); |
2025 | |
2026 | pr_debug3("Opening: %s\n" , evsel__name(evsel)); |
2027 | display_attr(attr: &evsel->core.attr); |
2028 | |
2029 | for (idx = start_cpu_map_idx; idx < end_cpu_map_idx; idx++) { |
2030 | |
2031 | for (thread = 0; thread < nthreads; thread++) { |
2032 | int fd, group_fd; |
2033 | retry_open: |
2034 | if (thread >= nthreads) |
2035 | break; |
2036 | |
2037 | if (!evsel->cgrp && !evsel->core.system_wide) |
2038 | pid = perf_thread_map__pid(threads, thread); |
2039 | |
2040 | group_fd = get_group_fd(evsel, cpu_map_idx: idx, thread); |
2041 | |
2042 | if (group_fd == -2) { |
2043 | pr_debug("broken group leader for %s\n" , evsel->name); |
2044 | err = -EINVAL; |
2045 | goto out_close; |
2046 | } |
2047 | |
2048 | test_attr__ready(); |
2049 | |
2050 | /* Debug message used by test scripts */ |
2051 | pr_debug2_peo("sys_perf_event_open: pid %d cpu %d group_fd %d flags %#lx" , |
2052 | pid, perf_cpu_map__cpu(cpus, idx).cpu, group_fd, evsel->open_flags); |
2053 | |
2054 | fd = sys_perf_event_open(attr: &evsel->core.attr, pid, |
2055 | cpu: perf_cpu_map__cpu(cpus, idx).cpu, |
2056 | group_fd, flags: evsel->open_flags); |
2057 | |
2058 | FD(evsel, idx, thread) = fd; |
2059 | |
2060 | if (fd < 0) { |
2061 | err = -errno; |
2062 | |
2063 | pr_debug2_peo("\nsys_perf_event_open failed, error %d\n" , |
2064 | err); |
2065 | goto try_fallback; |
2066 | } |
2067 | |
2068 | bpf_counter__install_pe(evsel, cpu: idx, fd); |
2069 | |
2070 | if (unlikely(test_attr__enabled)) { |
2071 | test_attr__open(attr: &evsel->core.attr, pid, |
2072 | cpu: perf_cpu_map__cpu(cpus, idx), |
2073 | fd, group_fd, flags: evsel->open_flags); |
2074 | } |
2075 | |
2076 | /* Debug message used by test scripts */ |
2077 | pr_debug2_peo(" = %d\n" , fd); |
2078 | |
2079 | if (evsel->bpf_fd >= 0) { |
2080 | int evt_fd = fd; |
2081 | int bpf_fd = evsel->bpf_fd; |
2082 | |
2083 | err = ioctl(evt_fd, |
2084 | PERF_EVENT_IOC_SET_BPF, |
2085 | bpf_fd); |
2086 | if (err && errno != EEXIST) { |
2087 | pr_err("failed to attach bpf fd %d: %s\n" , |
2088 | bpf_fd, strerror(errno)); |
2089 | err = -EINVAL; |
2090 | goto out_close; |
2091 | } |
2092 | } |
2093 | |
2094 | set_rlimit = NO_CHANGE; |
2095 | |
2096 | /* |
2097 | * If we succeeded but had to kill clockid, fail and |
2098 | * have evsel__open_strerror() print us a nice error. |
2099 | */ |
2100 | if (perf_missing_features.clockid || |
2101 | perf_missing_features.clockid_wrong) { |
2102 | err = -EINVAL; |
2103 | goto out_close; |
2104 | } |
2105 | } |
2106 | } |
2107 | |
2108 | return 0; |
2109 | |
2110 | try_fallback: |
2111 | if (evsel__precise_ip_fallback(evsel)) |
2112 | goto retry_open; |
2113 | |
2114 | if (evsel__ignore_missing_thread(evsel, nr_cpus: perf_cpu_map__nr(cpus), |
2115 | cpu_map_idx: idx, threads, thread, err)) { |
2116 | /* We just removed 1 thread, so lower the upper nthreads limit. */ |
2117 | nthreads--; |
2118 | |
2119 | /* ... and pretend like nothing have happened. */ |
2120 | err = 0; |
2121 | goto retry_open; |
2122 | } |
2123 | /* |
2124 | * perf stat needs between 5 and 22 fds per CPU. When we run out |
2125 | * of them try to increase the limits. |
2126 | */ |
2127 | if (err == -EMFILE && rlimit__increase_nofile(set_rlimit: &set_rlimit)) |
2128 | goto retry_open; |
2129 | |
2130 | if (err != -EINVAL || idx > 0 || thread > 0) |
2131 | goto out_close; |
2132 | |
2133 | if (evsel__detect_missing_features(evsel)) |
2134 | goto fallback_missing_features; |
2135 | out_close: |
2136 | if (err) |
2137 | threads->err_thread = thread; |
2138 | |
2139 | old_errno = errno; |
2140 | do { |
2141 | while (--thread >= 0) { |
2142 | if (FD(evsel, idx, thread) >= 0) |
2143 | close(FD(evsel, idx, thread)); |
2144 | FD(evsel, idx, thread) = -1; |
2145 | } |
2146 | thread = nthreads; |
2147 | } while (--idx >= 0); |
2148 | errno = old_errno; |
2149 | return err; |
2150 | } |
2151 | |
2152 | int evsel__open(struct evsel *evsel, struct perf_cpu_map *cpus, |
2153 | struct perf_thread_map *threads) |
2154 | { |
2155 | return evsel__open_cpu(evsel, cpus, threads, start_cpu_map_idx: 0, end_cpu_map_idx: perf_cpu_map__nr(cpus)); |
2156 | } |
2157 | |
2158 | void evsel__close(struct evsel *evsel) |
2159 | { |
2160 | perf_evsel__close(&evsel->core); |
2161 | perf_evsel__free_id(&evsel->core); |
2162 | } |
2163 | |
2164 | int evsel__open_per_cpu(struct evsel *evsel, struct perf_cpu_map *cpus, int cpu_map_idx) |
2165 | { |
2166 | if (cpu_map_idx == -1) |
2167 | return evsel__open_cpu(evsel, cpus, NULL, start_cpu_map_idx: 0, end_cpu_map_idx: perf_cpu_map__nr(cpus)); |
2168 | |
2169 | return evsel__open_cpu(evsel, cpus, NULL, start_cpu_map_idx: cpu_map_idx, end_cpu_map_idx: cpu_map_idx + 1); |
2170 | } |
2171 | |
2172 | int evsel__open_per_thread(struct evsel *evsel, struct perf_thread_map *threads) |
2173 | { |
2174 | return evsel__open(evsel, NULL, threads); |
2175 | } |
2176 | |
2177 | static int perf_evsel__parse_id_sample(const struct evsel *evsel, |
2178 | const union perf_event *event, |
2179 | struct perf_sample *sample) |
2180 | { |
2181 | u64 type = evsel->core.attr.sample_type; |
2182 | const __u64 *array = event->sample.array; |
2183 | bool swapped = evsel->needs_swap; |
2184 | union u64_swap u; |
2185 | |
2186 | array += ((event->header.size - |
2187 | sizeof(event->header)) / sizeof(u64)) - 1; |
2188 | |
2189 | if (type & PERF_SAMPLE_IDENTIFIER) { |
2190 | sample->id = *array; |
2191 | array--; |
2192 | } |
2193 | |
2194 | if (type & PERF_SAMPLE_CPU) { |
2195 | u.val64 = *array; |
2196 | if (swapped) { |
2197 | /* undo swap of u64, then swap on individual u32s */ |
2198 | u.val64 = bswap_64(u.val64); |
2199 | u.val32[0] = bswap_32(u.val32[0]); |
2200 | } |
2201 | |
2202 | sample->cpu = u.val32[0]; |
2203 | array--; |
2204 | } |
2205 | |
2206 | if (type & PERF_SAMPLE_STREAM_ID) { |
2207 | sample->stream_id = *array; |
2208 | array--; |
2209 | } |
2210 | |
2211 | if (type & PERF_SAMPLE_ID) { |
2212 | sample->id = *array; |
2213 | array--; |
2214 | } |
2215 | |
2216 | if (type & PERF_SAMPLE_TIME) { |
2217 | sample->time = *array; |
2218 | array--; |
2219 | } |
2220 | |
2221 | if (type & PERF_SAMPLE_TID) { |
2222 | u.val64 = *array; |
2223 | if (swapped) { |
2224 | /* undo swap of u64, then swap on individual u32s */ |
2225 | u.val64 = bswap_64(u.val64); |
2226 | u.val32[0] = bswap_32(u.val32[0]); |
2227 | u.val32[1] = bswap_32(u.val32[1]); |
2228 | } |
2229 | |
2230 | sample->pid = u.val32[0]; |
2231 | sample->tid = u.val32[1]; |
2232 | array--; |
2233 | } |
2234 | |
2235 | return 0; |
2236 | } |
2237 | |
2238 | static inline bool overflow(const void *endp, u16 max_size, const void *offset, |
2239 | u64 size) |
2240 | { |
2241 | return size > max_size || offset + size > endp; |
2242 | } |
2243 | |
2244 | #define OVERFLOW_CHECK(offset, size, max_size) \ |
2245 | do { \ |
2246 | if (overflow(endp, (max_size), (offset), (size))) \ |
2247 | return -EFAULT; \ |
2248 | } while (0) |
2249 | |
2250 | #define OVERFLOW_CHECK_u64(offset) \ |
2251 | OVERFLOW_CHECK(offset, sizeof(u64), sizeof(u64)) |
2252 | |
2253 | static int |
2254 | perf_event__check_size(union perf_event *event, unsigned int sample_size) |
2255 | { |
2256 | /* |
2257 | * The evsel's sample_size is based on PERF_SAMPLE_MASK which includes |
2258 | * up to PERF_SAMPLE_PERIOD. After that overflow() must be used to |
2259 | * check the format does not go past the end of the event. |
2260 | */ |
2261 | if (sample_size + sizeof(event->header) > event->header.size) |
2262 | return -EFAULT; |
2263 | |
2264 | return 0; |
2265 | } |
2266 | |
2267 | void __weak arch_perf_parse_sample_weight(struct perf_sample *data, |
2268 | const __u64 *array, |
2269 | u64 type __maybe_unused) |
2270 | { |
2271 | data->weight = *array; |
2272 | } |
2273 | |
2274 | u64 evsel__bitfield_swap_branch_flags(u64 value) |
2275 | { |
2276 | u64 new_val = 0; |
2277 | |
2278 | /* |
2279 | * branch_flags |
2280 | * union { |
2281 | * u64 values; |
2282 | * struct { |
2283 | * mispred:1 //target mispredicted |
2284 | * predicted:1 //target predicted |
2285 | * in_tx:1 //in transaction |
2286 | * abort:1 //transaction abort |
2287 | * cycles:16 //cycle count to last branch |
2288 | * type:4 //branch type |
2289 | * spec:2 //branch speculation info |
2290 | * new_type:4 //additional branch type |
2291 | * priv:3 //privilege level |
2292 | * reserved:31 |
2293 | * } |
2294 | * } |
2295 | * |
2296 | * Avoid bswap64() the entire branch_flag.value, |
2297 | * as it has variable bit-field sizes. Instead the |
2298 | * macro takes the bit-field position/size, |
2299 | * swaps it based on the host endianness. |
2300 | */ |
2301 | if (host_is_bigendian()) { |
2302 | new_val = bitfield_swap(value, 0, 1); |
2303 | new_val |= bitfield_swap(value, 1, 1); |
2304 | new_val |= bitfield_swap(value, 2, 1); |
2305 | new_val |= bitfield_swap(value, 3, 1); |
2306 | new_val |= bitfield_swap(value, 4, 16); |
2307 | new_val |= bitfield_swap(value, 20, 4); |
2308 | new_val |= bitfield_swap(value, 24, 2); |
2309 | new_val |= bitfield_swap(value, 26, 4); |
2310 | new_val |= bitfield_swap(value, 30, 3); |
2311 | new_val |= bitfield_swap(value, 33, 31); |
2312 | } else { |
2313 | new_val = bitfield_swap(value, 63, 1); |
2314 | new_val |= bitfield_swap(value, 62, 1); |
2315 | new_val |= bitfield_swap(value, 61, 1); |
2316 | new_val |= bitfield_swap(value, 60, 1); |
2317 | new_val |= bitfield_swap(value, 44, 16); |
2318 | new_val |= bitfield_swap(value, 40, 4); |
2319 | new_val |= bitfield_swap(value, 38, 2); |
2320 | new_val |= bitfield_swap(value, 34, 4); |
2321 | new_val |= bitfield_swap(value, 31, 3); |
2322 | new_val |= bitfield_swap(value, 0, 31); |
2323 | } |
2324 | |
2325 | return new_val; |
2326 | } |
2327 | |
2328 | static inline bool evsel__has_branch_counters(const struct evsel *evsel) |
2329 | { |
2330 | struct evsel *cur, *leader = evsel__leader(evsel); |
2331 | |
2332 | /* The branch counters feature only supports group */ |
2333 | if (!leader || !evsel->evlist) |
2334 | return false; |
2335 | |
2336 | evlist__for_each_entry(evsel->evlist, cur) { |
2337 | if ((leader == evsel__leader(evsel: cur)) && |
2338 | (cur->core.attr.branch_sample_type & PERF_SAMPLE_BRANCH_COUNTERS)) |
2339 | return true; |
2340 | } |
2341 | return false; |
2342 | } |
2343 | |
2344 | int evsel__parse_sample(struct evsel *evsel, union perf_event *event, |
2345 | struct perf_sample *data) |
2346 | { |
2347 | u64 type = evsel->core.attr.sample_type; |
2348 | bool swapped = evsel->needs_swap; |
2349 | const __u64 *array; |
2350 | u16 max_size = event->header.size; |
2351 | const void *endp = (void *)event + max_size; |
2352 | u64 sz; |
2353 | |
2354 | /* |
2355 | * used for cross-endian analysis. See git commit 65014ab3 |
2356 | * for why this goofiness is needed. |
2357 | */ |
2358 | union u64_swap u; |
2359 | |
2360 | memset(data, 0, sizeof(*data)); |
2361 | data->cpu = data->pid = data->tid = -1; |
2362 | data->stream_id = data->id = data->time = -1ULL; |
2363 | data->period = evsel->core.attr.sample_period; |
2364 | data->cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; |
2365 | data->misc = event->header.misc; |
2366 | data->data_src = PERF_MEM_DATA_SRC_NONE; |
2367 | data->vcpu = -1; |
2368 | |
2369 | if (event->header.type != PERF_RECORD_SAMPLE) { |
2370 | if (!evsel->core.attr.sample_id_all) |
2371 | return 0; |
2372 | return perf_evsel__parse_id_sample(evsel, event, sample: data); |
2373 | } |
2374 | |
2375 | array = event->sample.array; |
2376 | |
2377 | if (perf_event__check_size(event, sample_size: evsel->sample_size)) |
2378 | return -EFAULT; |
2379 | |
2380 | if (type & PERF_SAMPLE_IDENTIFIER) { |
2381 | data->id = *array; |
2382 | array++; |
2383 | } |
2384 | |
2385 | if (type & PERF_SAMPLE_IP) { |
2386 | data->ip = *array; |
2387 | array++; |
2388 | } |
2389 | |
2390 | if (type & PERF_SAMPLE_TID) { |
2391 | u.val64 = *array; |
2392 | if (swapped) { |
2393 | /* undo swap of u64, then swap on individual u32s */ |
2394 | u.val64 = bswap_64(u.val64); |
2395 | u.val32[0] = bswap_32(u.val32[0]); |
2396 | u.val32[1] = bswap_32(u.val32[1]); |
2397 | } |
2398 | |
2399 | data->pid = u.val32[0]; |
2400 | data->tid = u.val32[1]; |
2401 | array++; |
2402 | } |
2403 | |
2404 | if (type & PERF_SAMPLE_TIME) { |
2405 | data->time = *array; |
2406 | array++; |
2407 | } |
2408 | |
2409 | if (type & PERF_SAMPLE_ADDR) { |
2410 | data->addr = *array; |
2411 | array++; |
2412 | } |
2413 | |
2414 | if (type & PERF_SAMPLE_ID) { |
2415 | data->id = *array; |
2416 | array++; |
2417 | } |
2418 | |
2419 | if (type & PERF_SAMPLE_STREAM_ID) { |
2420 | data->stream_id = *array; |
2421 | array++; |
2422 | } |
2423 | |
2424 | if (type & PERF_SAMPLE_CPU) { |
2425 | |
2426 | u.val64 = *array; |
2427 | if (swapped) { |
2428 | /* undo swap of u64, then swap on individual u32s */ |
2429 | u.val64 = bswap_64(u.val64); |
2430 | u.val32[0] = bswap_32(u.val32[0]); |
2431 | } |
2432 | |
2433 | data->cpu = u.val32[0]; |
2434 | array++; |
2435 | } |
2436 | |
2437 | if (type & PERF_SAMPLE_PERIOD) { |
2438 | data->period = *array; |
2439 | array++; |
2440 | } |
2441 | |
2442 | if (type & PERF_SAMPLE_READ) { |
2443 | u64 read_format = evsel->core.attr.read_format; |
2444 | |
2445 | OVERFLOW_CHECK_u64(array); |
2446 | if (read_format & PERF_FORMAT_GROUP) |
2447 | data->read.group.nr = *array; |
2448 | else |
2449 | data->read.one.value = *array; |
2450 | |
2451 | array++; |
2452 | |
2453 | if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) { |
2454 | OVERFLOW_CHECK_u64(array); |
2455 | data->read.time_enabled = *array; |
2456 | array++; |
2457 | } |
2458 | |
2459 | if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) { |
2460 | OVERFLOW_CHECK_u64(array); |
2461 | data->read.time_running = *array; |
2462 | array++; |
2463 | } |
2464 | |
2465 | /* PERF_FORMAT_ID is forced for PERF_SAMPLE_READ */ |
2466 | if (read_format & PERF_FORMAT_GROUP) { |
2467 | const u64 max_group_nr = UINT64_MAX / |
2468 | sizeof(struct sample_read_value); |
2469 | |
2470 | if (data->read.group.nr > max_group_nr) |
2471 | return -EFAULT; |
2472 | |
2473 | sz = data->read.group.nr * sample_read_value_size(read_format); |
2474 | OVERFLOW_CHECK(array, sz, max_size); |
2475 | data->read.group.values = |
2476 | (struct sample_read_value *)array; |
2477 | array = (void *)array + sz; |
2478 | } else { |
2479 | OVERFLOW_CHECK_u64(array); |
2480 | data->read.one.id = *array; |
2481 | array++; |
2482 | |
2483 | if (read_format & PERF_FORMAT_LOST) { |
2484 | OVERFLOW_CHECK_u64(array); |
2485 | data->read.one.lost = *array; |
2486 | array++; |
2487 | } |
2488 | } |
2489 | } |
2490 | |
2491 | if (type & PERF_SAMPLE_CALLCHAIN) { |
2492 | const u64 max_callchain_nr = UINT64_MAX / sizeof(u64); |
2493 | |
2494 | OVERFLOW_CHECK_u64(array); |
2495 | data->callchain = (struct ip_callchain *)array++; |
2496 | if (data->callchain->nr > max_callchain_nr) |
2497 | return -EFAULT; |
2498 | sz = data->callchain->nr * sizeof(u64); |
2499 | OVERFLOW_CHECK(array, sz, max_size); |
2500 | array = (void *)array + sz; |
2501 | } |
2502 | |
2503 | if (type & PERF_SAMPLE_RAW) { |
2504 | OVERFLOW_CHECK_u64(array); |
2505 | u.val64 = *array; |
2506 | |
2507 | /* |
2508 | * Undo swap of u64, then swap on individual u32s, |
2509 | * get the size of the raw area and undo all of the |
2510 | * swap. The pevent interface handles endianness by |
2511 | * itself. |
2512 | */ |
2513 | if (swapped) { |
2514 | u.val64 = bswap_64(u.val64); |
2515 | u.val32[0] = bswap_32(u.val32[0]); |
2516 | u.val32[1] = bswap_32(u.val32[1]); |
2517 | } |
2518 | data->raw_size = u.val32[0]; |
2519 | |
2520 | /* |
2521 | * The raw data is aligned on 64bits including the |
2522 | * u32 size, so it's safe to use mem_bswap_64. |
2523 | */ |
2524 | if (swapped) |
2525 | mem_bswap_64(src: (void *) array, byte_size: data->raw_size); |
2526 | |
2527 | array = (void *)array + sizeof(u32); |
2528 | |
2529 | OVERFLOW_CHECK(array, data->raw_size, max_size); |
2530 | data->raw_data = (void *)array; |
2531 | array = (void *)array + data->raw_size; |
2532 | } |
2533 | |
2534 | if (type & PERF_SAMPLE_BRANCH_STACK) { |
2535 | const u64 max_branch_nr = UINT64_MAX / |
2536 | sizeof(struct branch_entry); |
2537 | struct branch_entry *e; |
2538 | unsigned int i; |
2539 | |
2540 | OVERFLOW_CHECK_u64(array); |
2541 | data->branch_stack = (struct branch_stack *)array++; |
2542 | |
2543 | if (data->branch_stack->nr > max_branch_nr) |
2544 | return -EFAULT; |
2545 | |
2546 | sz = data->branch_stack->nr * sizeof(struct branch_entry); |
2547 | if (evsel__has_branch_hw_idx(evsel)) { |
2548 | sz += sizeof(u64); |
2549 | e = &data->branch_stack->entries[0]; |
2550 | } else { |
2551 | data->no_hw_idx = true; |
2552 | /* |
2553 | * if the PERF_SAMPLE_BRANCH_HW_INDEX is not applied, |
2554 | * only nr and entries[] will be output by kernel. |
2555 | */ |
2556 | e = (struct branch_entry *)&data->branch_stack->hw_idx; |
2557 | } |
2558 | |
2559 | if (swapped) { |
2560 | /* |
2561 | * struct branch_flag does not have endian |
2562 | * specific bit field definition. And bswap |
2563 | * will not resolve the issue, since these |
2564 | * are bit fields. |
2565 | * |
2566 | * evsel__bitfield_swap_branch_flags() uses a |
2567 | * bitfield_swap macro to swap the bit position |
2568 | * based on the host endians. |
2569 | */ |
2570 | for (i = 0; i < data->branch_stack->nr; i++, e++) |
2571 | e->flags.value = evsel__bitfield_swap_branch_flags(value: e->flags.value); |
2572 | } |
2573 | |
2574 | OVERFLOW_CHECK(array, sz, max_size); |
2575 | array = (void *)array + sz; |
2576 | |
2577 | if (evsel__has_branch_counters(evsel)) { |
2578 | OVERFLOW_CHECK_u64(array); |
2579 | |
2580 | data->branch_stack_cntr = (u64 *)array; |
2581 | sz = data->branch_stack->nr * sizeof(u64); |
2582 | |
2583 | OVERFLOW_CHECK(array, sz, max_size); |
2584 | array = (void *)array + sz; |
2585 | } |
2586 | } |
2587 | |
2588 | if (type & PERF_SAMPLE_REGS_USER) { |
2589 | OVERFLOW_CHECK_u64(array); |
2590 | data->user_regs.abi = *array; |
2591 | array++; |
2592 | |
2593 | if (data->user_regs.abi) { |
2594 | u64 mask = evsel->core.attr.sample_regs_user; |
2595 | |
2596 | sz = hweight64(mask) * sizeof(u64); |
2597 | OVERFLOW_CHECK(array, sz, max_size); |
2598 | data->user_regs.mask = mask; |
2599 | data->user_regs.regs = (u64 *)array; |
2600 | array = (void *)array + sz; |
2601 | } |
2602 | } |
2603 | |
2604 | if (type & PERF_SAMPLE_STACK_USER) { |
2605 | OVERFLOW_CHECK_u64(array); |
2606 | sz = *array++; |
2607 | |
2608 | data->user_stack.offset = ((char *)(array - 1) |
2609 | - (char *) event); |
2610 | |
2611 | if (!sz) { |
2612 | data->user_stack.size = 0; |
2613 | } else { |
2614 | OVERFLOW_CHECK(array, sz, max_size); |
2615 | data->user_stack.data = (char *)array; |
2616 | array = (void *)array + sz; |
2617 | OVERFLOW_CHECK_u64(array); |
2618 | data->user_stack.size = *array++; |
2619 | if (WARN_ONCE(data->user_stack.size > sz, |
2620 | "user stack dump failure\n" )) |
2621 | return -EFAULT; |
2622 | } |
2623 | } |
2624 | |
2625 | if (type & PERF_SAMPLE_WEIGHT_TYPE) { |
2626 | OVERFLOW_CHECK_u64(array); |
2627 | arch_perf_parse_sample_weight(data, array, type); |
2628 | array++; |
2629 | } |
2630 | |
2631 | if (type & PERF_SAMPLE_DATA_SRC) { |
2632 | OVERFLOW_CHECK_u64(array); |
2633 | data->data_src = *array; |
2634 | array++; |
2635 | } |
2636 | |
2637 | if (type & PERF_SAMPLE_TRANSACTION) { |
2638 | OVERFLOW_CHECK_u64(array); |
2639 | data->transaction = *array; |
2640 | array++; |
2641 | } |
2642 | |
2643 | data->intr_regs.abi = PERF_SAMPLE_REGS_ABI_NONE; |
2644 | if (type & PERF_SAMPLE_REGS_INTR) { |
2645 | OVERFLOW_CHECK_u64(array); |
2646 | data->intr_regs.abi = *array; |
2647 | array++; |
2648 | |
2649 | if (data->intr_regs.abi != PERF_SAMPLE_REGS_ABI_NONE) { |
2650 | u64 mask = evsel->core.attr.sample_regs_intr; |
2651 | |
2652 | sz = hweight64(mask) * sizeof(u64); |
2653 | OVERFLOW_CHECK(array, sz, max_size); |
2654 | data->intr_regs.mask = mask; |
2655 | data->intr_regs.regs = (u64 *)array; |
2656 | array = (void *)array + sz; |
2657 | } |
2658 | } |
2659 | |
2660 | data->phys_addr = 0; |
2661 | if (type & PERF_SAMPLE_PHYS_ADDR) { |
2662 | data->phys_addr = *array; |
2663 | array++; |
2664 | } |
2665 | |
2666 | data->cgroup = 0; |
2667 | if (type & PERF_SAMPLE_CGROUP) { |
2668 | data->cgroup = *array; |
2669 | array++; |
2670 | } |
2671 | |
2672 | data->data_page_size = 0; |
2673 | if (type & PERF_SAMPLE_DATA_PAGE_SIZE) { |
2674 | data->data_page_size = *array; |
2675 | array++; |
2676 | } |
2677 | |
2678 | data->code_page_size = 0; |
2679 | if (type & PERF_SAMPLE_CODE_PAGE_SIZE) { |
2680 | data->code_page_size = *array; |
2681 | array++; |
2682 | } |
2683 | |
2684 | if (type & PERF_SAMPLE_AUX) { |
2685 | OVERFLOW_CHECK_u64(array); |
2686 | sz = *array++; |
2687 | |
2688 | OVERFLOW_CHECK(array, sz, max_size); |
2689 | /* Undo swap of data */ |
2690 | if (swapped) |
2691 | mem_bswap_64(src: (char *)array, byte_size: sz); |
2692 | data->aux_sample.size = sz; |
2693 | data->aux_sample.data = (char *)array; |
2694 | array = (void *)array + sz; |
2695 | } |
2696 | |
2697 | return 0; |
2698 | } |
2699 | |
2700 | int evsel__parse_sample_timestamp(struct evsel *evsel, union perf_event *event, |
2701 | u64 *timestamp) |
2702 | { |
2703 | u64 type = evsel->core.attr.sample_type; |
2704 | const __u64 *array; |
2705 | |
2706 | if (!(type & PERF_SAMPLE_TIME)) |
2707 | return -1; |
2708 | |
2709 | if (event->header.type != PERF_RECORD_SAMPLE) { |
2710 | struct perf_sample data = { |
2711 | .time = -1ULL, |
2712 | }; |
2713 | |
2714 | if (!evsel->core.attr.sample_id_all) |
2715 | return -1; |
2716 | if (perf_evsel__parse_id_sample(evsel, event, sample: &data)) |
2717 | return -1; |
2718 | |
2719 | *timestamp = data.time; |
2720 | return 0; |
2721 | } |
2722 | |
2723 | array = event->sample.array; |
2724 | |
2725 | if (perf_event__check_size(event, sample_size: evsel->sample_size)) |
2726 | return -EFAULT; |
2727 | |
2728 | if (type & PERF_SAMPLE_IDENTIFIER) |
2729 | array++; |
2730 | |
2731 | if (type & PERF_SAMPLE_IP) |
2732 | array++; |
2733 | |
2734 | if (type & PERF_SAMPLE_TID) |
2735 | array++; |
2736 | |
2737 | if (type & PERF_SAMPLE_TIME) |
2738 | *timestamp = *array; |
2739 | |
2740 | return 0; |
2741 | } |
2742 | |
2743 | u16 evsel__id_hdr_size(struct evsel *evsel) |
2744 | { |
2745 | u64 sample_type = evsel->core.attr.sample_type; |
2746 | u16 size = 0; |
2747 | |
2748 | if (sample_type & PERF_SAMPLE_TID) |
2749 | size += sizeof(u64); |
2750 | |
2751 | if (sample_type & PERF_SAMPLE_TIME) |
2752 | size += sizeof(u64); |
2753 | |
2754 | if (sample_type & PERF_SAMPLE_ID) |
2755 | size += sizeof(u64); |
2756 | |
2757 | if (sample_type & PERF_SAMPLE_STREAM_ID) |
2758 | size += sizeof(u64); |
2759 | |
2760 | if (sample_type & PERF_SAMPLE_CPU) |
2761 | size += sizeof(u64); |
2762 | |
2763 | if (sample_type & PERF_SAMPLE_IDENTIFIER) |
2764 | size += sizeof(u64); |
2765 | |
2766 | return size; |
2767 | } |
2768 | |
2769 | #ifdef HAVE_LIBTRACEEVENT |
2770 | struct tep_format_field *evsel__field(struct evsel *evsel, const char *name) |
2771 | { |
2772 | return tep_find_field(evsel->tp_format, name); |
2773 | } |
2774 | |
2775 | struct tep_format_field *evsel__common_field(struct evsel *evsel, const char *name) |
2776 | { |
2777 | return tep_find_common_field(evsel->tp_format, name); |
2778 | } |
2779 | |
2780 | void *evsel__rawptr(struct evsel *evsel, struct perf_sample *sample, const char *name) |
2781 | { |
2782 | struct tep_format_field *field = evsel__field(evsel, name); |
2783 | int offset; |
2784 | |
2785 | if (!field) |
2786 | return NULL; |
2787 | |
2788 | offset = field->offset; |
2789 | |
2790 | if (field->flags & TEP_FIELD_IS_DYNAMIC) { |
2791 | offset = *(int *)(sample->raw_data + field->offset); |
2792 | offset &= 0xffff; |
2793 | if (tep_field_is_relative(field->flags)) |
2794 | offset += field->offset + field->size; |
2795 | } |
2796 | |
2797 | return sample->raw_data + offset; |
2798 | } |
2799 | |
2800 | u64 format_field__intval(struct tep_format_field *field, struct perf_sample *sample, |
2801 | bool needs_swap) |
2802 | { |
2803 | u64 value; |
2804 | void *ptr = sample->raw_data + field->offset; |
2805 | |
2806 | switch (field->size) { |
2807 | case 1: |
2808 | return *(u8 *)ptr; |
2809 | case 2: |
2810 | value = *(u16 *)ptr; |
2811 | break; |
2812 | case 4: |
2813 | value = *(u32 *)ptr; |
2814 | break; |
2815 | case 8: |
2816 | memcpy(&value, ptr, sizeof(u64)); |
2817 | break; |
2818 | default: |
2819 | return 0; |
2820 | } |
2821 | |
2822 | if (!needs_swap) |
2823 | return value; |
2824 | |
2825 | switch (field->size) { |
2826 | case 2: |
2827 | return bswap_16(value); |
2828 | case 4: |
2829 | return bswap_32(value); |
2830 | case 8: |
2831 | return bswap_64(value); |
2832 | default: |
2833 | return 0; |
2834 | } |
2835 | |
2836 | return 0; |
2837 | } |
2838 | |
2839 | u64 evsel__intval(struct evsel *evsel, struct perf_sample *sample, const char *name) |
2840 | { |
2841 | struct tep_format_field *field = evsel__field(evsel, name); |
2842 | |
2843 | return field ? format_field__intval(field, sample, evsel->needs_swap) : 0; |
2844 | } |
2845 | |
2846 | u64 evsel__intval_common(struct evsel *evsel, struct perf_sample *sample, const char *name) |
2847 | { |
2848 | struct tep_format_field *field = evsel__common_field(evsel, name); |
2849 | |
2850 | return field ? format_field__intval(field, sample, evsel->needs_swap) : 0; |
2851 | } |
2852 | |
2853 | char evsel__taskstate(struct evsel *evsel, struct perf_sample *sample, const char *name) |
2854 | { |
2855 | static struct tep_format_field *prev_state_field; |
2856 | static const char *states; |
2857 | struct tep_format_field *field; |
2858 | unsigned long long val; |
2859 | unsigned int bit; |
2860 | char state = '?'; /* '?' denotes unknown task state */ |
2861 | |
2862 | field = evsel__field(evsel, name); |
2863 | |
2864 | if (!field) |
2865 | return state; |
2866 | |
2867 | if (!states || field != prev_state_field) { |
2868 | states = parse_task_states(field); |
2869 | if (!states) |
2870 | return state; |
2871 | prev_state_field = field; |
2872 | } |
2873 | |
2874 | /* |
2875 | * Note since the kernel exposes TASK_REPORT_MAX to userspace |
2876 | * to denote the 'preempted' state, we might as welll report |
2877 | * 'R' for this case, which make senses to users as well. |
2878 | * |
2879 | * We can change this if we have a good reason in the future. |
2880 | */ |
2881 | val = evsel__intval(evsel, sample, name); |
2882 | bit = val ? ffs(val) : 0; |
2883 | state = (!bit || bit > strlen(states)) ? 'R' : states[bit-1]; |
2884 | return state; |
2885 | } |
2886 | #endif |
2887 | |
2888 | bool evsel__fallback(struct evsel *evsel, struct target *target, int err, |
2889 | char *msg, size_t msgsize) |
2890 | { |
2891 | int paranoid; |
2892 | |
2893 | if ((err == ENOENT || err == ENXIO || err == ENODEV) && |
2894 | evsel->core.attr.type == PERF_TYPE_HARDWARE && |
2895 | evsel->core.attr.config == PERF_COUNT_HW_CPU_CYCLES) { |
2896 | /* |
2897 | * If it's cycles then fall back to hrtimer based cpu-clock sw |
2898 | * counter, which is always available even if no PMU support. |
2899 | * |
2900 | * PPC returns ENXIO until 2.6.37 (behavior changed with commit |
2901 | * b0a873e). |
2902 | */ |
2903 | evsel->core.attr.type = PERF_TYPE_SOFTWARE; |
2904 | evsel->core.attr.config = target__has_cpu(target) |
2905 | ? PERF_COUNT_SW_CPU_CLOCK |
2906 | : PERF_COUNT_SW_TASK_CLOCK; |
2907 | scnprintf(buf: msg, size: msgsize, |
2908 | fmt: "The cycles event is not supported, trying to fall back to %s" , |
2909 | target__has_cpu(target) ? "cpu-clock" : "task-clock" ); |
2910 | |
2911 | zfree(&evsel->name); |
2912 | return true; |
2913 | } else if (err == EACCES && !evsel->core.attr.exclude_kernel && |
2914 | (paranoid = perf_event_paranoid()) > 1) { |
2915 | const char *name = evsel__name(evsel); |
2916 | char *new_name; |
2917 | const char *sep = ":" ; |
2918 | |
2919 | /* If event has exclude user then don't exclude kernel. */ |
2920 | if (evsel->core.attr.exclude_user) |
2921 | return false; |
2922 | |
2923 | /* Is there already the separator in the name. */ |
2924 | if (strchr(name, '/') || |
2925 | (strchr(name, ':') && !evsel->is_libpfm_event)) |
2926 | sep = "" ; |
2927 | |
2928 | if (asprintf(&new_name, "%s%su" , name, sep) < 0) |
2929 | return false; |
2930 | |
2931 | free(evsel->name); |
2932 | evsel->name = new_name; |
2933 | scnprintf(buf: msg, size: msgsize, fmt: "kernel.perf_event_paranoid=%d, trying " |
2934 | "to fall back to excluding kernel and hypervisor " |
2935 | " samples" , paranoid); |
2936 | evsel->core.attr.exclude_kernel = 1; |
2937 | evsel->core.attr.exclude_hv = 1; |
2938 | |
2939 | return true; |
2940 | } |
2941 | |
2942 | return false; |
2943 | } |
2944 | |
2945 | static bool find_process(const char *name) |
2946 | { |
2947 | size_t len = strlen(name); |
2948 | DIR *dir; |
2949 | struct dirent *d; |
2950 | int ret = -1; |
2951 | |
2952 | dir = opendir(procfs__mountpoint()); |
2953 | if (!dir) |
2954 | return false; |
2955 | |
2956 | /* Walk through the directory. */ |
2957 | while (ret && (d = readdir(dir)) != NULL) { |
2958 | char path[PATH_MAX]; |
2959 | char *data; |
2960 | size_t size; |
2961 | |
2962 | if ((d->d_type != DT_DIR) || |
2963 | !strcmp("." , d->d_name) || |
2964 | !strcmp(".." , d->d_name)) |
2965 | continue; |
2966 | |
2967 | scnprintf(buf: path, size: sizeof(path), fmt: "%s/%s/comm" , |
2968 | procfs__mountpoint(), d->d_name); |
2969 | |
2970 | if (filename__read_str(path, &data, &size)) |
2971 | continue; |
2972 | |
2973 | ret = strncmp(name, data, len); |
2974 | free(data); |
2975 | } |
2976 | |
2977 | closedir(dir); |
2978 | return ret ? false : true; |
2979 | } |
2980 | |
2981 | int __weak arch_evsel__open_strerror(struct evsel *evsel __maybe_unused, |
2982 | char *msg __maybe_unused, |
2983 | size_t size __maybe_unused) |
2984 | { |
2985 | return 0; |
2986 | } |
2987 | |
2988 | int evsel__open_strerror(struct evsel *evsel, struct target *target, |
2989 | int err, char *msg, size_t size) |
2990 | { |
2991 | char sbuf[STRERR_BUFSIZE]; |
2992 | int printed = 0, enforced = 0; |
2993 | int ret; |
2994 | |
2995 | switch (err) { |
2996 | case EPERM: |
2997 | case EACCES: |
2998 | printed += scnprintf(buf: msg + printed, size: size - printed, |
2999 | fmt: "Access to performance monitoring and observability operations is limited.\n" ); |
3000 | |
3001 | if (!sysfs__read_int("fs/selinux/enforce" , &enforced)) { |
3002 | if (enforced) { |
3003 | printed += scnprintf(buf: msg + printed, size: size - printed, |
3004 | fmt: "Enforced MAC policy settings (SELinux) can limit access to performance\n" |
3005 | "monitoring and observability operations. Inspect system audit records for\n" |
3006 | "more perf_event access control information and adjusting the policy.\n" ); |
3007 | } |
3008 | } |
3009 | |
3010 | if (err == EPERM) |
3011 | printed += scnprintf(buf: msg, size, |
3012 | fmt: "No permission to enable %s event.\n\n" , evsel__name(evsel)); |
3013 | |
3014 | return scnprintf(buf: msg + printed, size: size - printed, |
3015 | fmt: "Consider adjusting /proc/sys/kernel/perf_event_paranoid setting to open\n" |
3016 | "access to performance monitoring and observability operations for processes\n" |
3017 | "without CAP_PERFMON, CAP_SYS_PTRACE or CAP_SYS_ADMIN Linux capability.\n" |
3018 | "More information can be found at 'Perf events and tool security' document:\n" |
3019 | "https://www.kernel.org/doc/html/latest/admin-guide/perf-security.html\n" |
3020 | "perf_event_paranoid setting is %d:\n" |
3021 | " -1: Allow use of (almost) all events by all users\n" |
3022 | " Ignore mlock limit after perf_event_mlock_kb without CAP_IPC_LOCK\n" |
3023 | ">= 0: Disallow raw and ftrace function tracepoint access\n" |
3024 | ">= 1: Disallow CPU event access\n" |
3025 | ">= 2: Disallow kernel profiling\n" |
3026 | "To make the adjusted perf_event_paranoid setting permanent preserve it\n" |
3027 | "in /etc/sysctl.conf (e.g. kernel.perf_event_paranoid = <setting>)" , |
3028 | perf_event_paranoid()); |
3029 | case ENOENT: |
3030 | return scnprintf(buf: msg, size, fmt: "The %s event is not supported." , evsel__name(evsel)); |
3031 | case EMFILE: |
3032 | return scnprintf(buf: msg, size, fmt: "%s" , |
3033 | "Too many events are opened.\n" |
3034 | "Probably the maximum number of open file descriptors has been reached.\n" |
3035 | "Hint: Try again after reducing the number of events.\n" |
3036 | "Hint: Try increasing the limit with 'ulimit -n <limit>'" ); |
3037 | case ENOMEM: |
3038 | if (evsel__has_callchain(evsel) && |
3039 | access("/proc/sys/kernel/perf_event_max_stack" , F_OK) == 0) |
3040 | return scnprintf(buf: msg, size, |
3041 | fmt: "Not enough memory to setup event with callchain.\n" |
3042 | "Hint: Try tweaking /proc/sys/kernel/perf_event_max_stack\n" |
3043 | "Hint: Current value: %d" , sysctl__max_stack()); |
3044 | break; |
3045 | case ENODEV: |
3046 | if (target->cpu_list) |
3047 | return scnprintf(buf: msg, size, fmt: "%s" , |
3048 | "No such device - did you specify an out-of-range profile CPU?" ); |
3049 | break; |
3050 | case EOPNOTSUPP: |
3051 | if (evsel->core.attr.sample_type & PERF_SAMPLE_BRANCH_STACK) |
3052 | return scnprintf(buf: msg, size, |
3053 | fmt: "%s: PMU Hardware or event type doesn't support branch stack sampling." , |
3054 | evsel__name(evsel)); |
3055 | if (evsel->core.attr.aux_output) |
3056 | return scnprintf(buf: msg, size, |
3057 | fmt: "%s: PMU Hardware doesn't support 'aux_output' feature" , |
3058 | evsel__name(evsel)); |
3059 | if (evsel->core.attr.sample_period != 0) |
3060 | return scnprintf(buf: msg, size, |
3061 | fmt: "%s: PMU Hardware doesn't support sampling/overflow-interrupts. Try 'perf stat'" , |
3062 | evsel__name(evsel)); |
3063 | if (evsel->core.attr.precise_ip) |
3064 | return scnprintf(buf: msg, size, fmt: "%s" , |
3065 | "\'precise\' request may not be supported. Try removing 'p' modifier." ); |
3066 | #if defined(__i386__) || defined(__x86_64__) |
3067 | if (evsel->core.attr.type == PERF_TYPE_HARDWARE) |
3068 | return scnprintf(buf: msg, size, fmt: "%s" , |
3069 | "No hardware sampling interrupt available.\n" ); |
3070 | #endif |
3071 | break; |
3072 | case EBUSY: |
3073 | if (find_process(name: "oprofiled" )) |
3074 | return scnprintf(buf: msg, size, |
3075 | fmt: "The PMU counters are busy/taken by another profiler.\n" |
3076 | "We found oprofile daemon running, please stop it and try again." ); |
3077 | break; |
3078 | case EINVAL: |
3079 | if (evsel->core.attr.sample_type & PERF_SAMPLE_CODE_PAGE_SIZE && perf_missing_features.code_page_size) |
3080 | return scnprintf(buf: msg, size, fmt: "Asking for the code page size isn't supported by this kernel." ); |
3081 | if (evsel->core.attr.sample_type & PERF_SAMPLE_DATA_PAGE_SIZE && perf_missing_features.data_page_size) |
3082 | return scnprintf(buf: msg, size, fmt: "Asking for the data page size isn't supported by this kernel." ); |
3083 | if (evsel->core.attr.write_backward && perf_missing_features.write_backward) |
3084 | return scnprintf(buf: msg, size, fmt: "Reading from overwrite event is not supported by this kernel." ); |
3085 | if (perf_missing_features.clockid) |
3086 | return scnprintf(buf: msg, size, fmt: "clockid feature not supported." ); |
3087 | if (perf_missing_features.clockid_wrong) |
3088 | return scnprintf(buf: msg, size, fmt: "wrong clockid (%d)." , clockid); |
3089 | if (perf_missing_features.aux_output) |
3090 | return scnprintf(buf: msg, size, fmt: "The 'aux_output' feature is not supported, update the kernel." ); |
3091 | if (!target__has_cpu(target)) |
3092 | return scnprintf(buf: msg, size, |
3093 | fmt: "Invalid event (%s) in per-thread mode, enable system wide with '-a'." , |
3094 | evsel__name(evsel)); |
3095 | |
3096 | break; |
3097 | case ENODATA: |
3098 | return scnprintf(buf: msg, size, fmt: "Cannot collect data source with the load latency event alone. " |
3099 | "Please add an auxiliary event in front of the load latency event." ); |
3100 | default: |
3101 | break; |
3102 | } |
3103 | |
3104 | ret = arch_evsel__open_strerror(evsel, msg, size); |
3105 | if (ret) |
3106 | return ret; |
3107 | |
3108 | return scnprintf(buf: msg, size, |
3109 | fmt: "The sys_perf_event_open() syscall returned with %d (%s) for event (%s).\n" |
3110 | "/bin/dmesg | grep -i perf may provide additional information.\n" , |
3111 | err, str_error_r(err, sbuf, sizeof(sbuf)), evsel__name(evsel)); |
3112 | } |
3113 | |
3114 | struct perf_env *evsel__env(struct evsel *evsel) |
3115 | { |
3116 | if (evsel && evsel->evlist && evsel->evlist->env) |
3117 | return evsel->evlist->env; |
3118 | return &perf_env; |
3119 | } |
3120 | |
3121 | static int store_evsel_ids(struct evsel *evsel, struct evlist *evlist) |
3122 | { |
3123 | int cpu_map_idx, thread; |
3124 | |
3125 | for (cpu_map_idx = 0; cpu_map_idx < xyarray__max_x(evsel->core.fd); cpu_map_idx++) { |
3126 | for (thread = 0; thread < xyarray__max_y(evsel->core.fd); |
3127 | thread++) { |
3128 | int fd = FD(evsel, cpu_map_idx, thread); |
3129 | |
3130 | if (perf_evlist__id_add_fd(&evlist->core, &evsel->core, |
3131 | cpu_map_idx, thread, fd) < 0) |
3132 | return -1; |
3133 | } |
3134 | } |
3135 | |
3136 | return 0; |
3137 | } |
3138 | |
3139 | int evsel__store_ids(struct evsel *evsel, struct evlist *evlist) |
3140 | { |
3141 | struct perf_cpu_map *cpus = evsel->core.cpus; |
3142 | struct perf_thread_map *threads = evsel->core.threads; |
3143 | |
3144 | if (perf_evsel__alloc_id(&evsel->core, perf_cpu_map__nr(cpus), threads->nr)) |
3145 | return -ENOMEM; |
3146 | |
3147 | return store_evsel_ids(evsel, evlist); |
3148 | } |
3149 | |
3150 | void evsel__zero_per_pkg(struct evsel *evsel) |
3151 | { |
3152 | struct hashmap_entry *cur; |
3153 | size_t bkt; |
3154 | |
3155 | if (evsel->per_pkg_mask) { |
3156 | hashmap__for_each_entry(evsel->per_pkg_mask, cur, bkt) |
3157 | zfree(&cur->pkey); |
3158 | |
3159 | hashmap__clear(evsel->per_pkg_mask); |
3160 | } |
3161 | } |
3162 | |
3163 | /** |
3164 | * evsel__is_hybrid - does the evsel have a known PMU that is hybrid. Note, this |
3165 | * will be false on hybrid systems for hardware and legacy |
3166 | * cache events. |
3167 | */ |
3168 | bool evsel__is_hybrid(const struct evsel *evsel) |
3169 | { |
3170 | if (perf_pmus__num_core_pmus() == 1) |
3171 | return false; |
3172 | |
3173 | return evsel->core.is_pmu_core; |
3174 | } |
3175 | |
3176 | struct evsel *evsel__leader(const struct evsel *evsel) |
3177 | { |
3178 | return container_of(evsel->core.leader, struct evsel, core); |
3179 | } |
3180 | |
3181 | bool evsel__has_leader(struct evsel *evsel, struct evsel *leader) |
3182 | { |
3183 | return evsel->core.leader == &leader->core; |
3184 | } |
3185 | |
3186 | bool evsel__is_leader(struct evsel *evsel) |
3187 | { |
3188 | return evsel__has_leader(evsel, leader: evsel); |
3189 | } |
3190 | |
3191 | void evsel__set_leader(struct evsel *evsel, struct evsel *leader) |
3192 | { |
3193 | evsel->core.leader = &leader->core; |
3194 | } |
3195 | |
3196 | int evsel__source_count(const struct evsel *evsel) |
3197 | { |
3198 | struct evsel *pos; |
3199 | int count = 0; |
3200 | |
3201 | evlist__for_each_entry(evsel->evlist, pos) { |
3202 | if (pos->metric_leader == evsel) |
3203 | count++; |
3204 | } |
3205 | return count; |
3206 | } |
3207 | |
3208 | bool __weak arch_evsel__must_be_in_group(const struct evsel *evsel __maybe_unused) |
3209 | { |
3210 | return false; |
3211 | } |
3212 | |
3213 | /* |
3214 | * Remove an event from a given group (leader). |
3215 | * Some events, e.g., perf metrics Topdown events, |
3216 | * must always be grouped. Ignore the events. |
3217 | */ |
3218 | void evsel__remove_from_group(struct evsel *evsel, struct evsel *leader) |
3219 | { |
3220 | if (!arch_evsel__must_be_in_group(evsel) && evsel != leader) { |
3221 | evsel__set_leader(evsel, leader: evsel); |
3222 | evsel->core.nr_members = 0; |
3223 | leader->core.nr_members--; |
3224 | } |
3225 | } |
3226 | |